package repository

import (
	"users_management/m/model/entity"

	"github.com/google/uuid"
	"gorm.io/gorm"
)

type CountAssetsRepo interface {
	Get() (entity.CountAssets, error)
	UpdateCounts() error
}


type countAssetsRepo struct {
    db *gorm.DB
}


func NewCountAssetsRepo(db *gorm.DB) CountAssetsRepo {
    return &countAssetsRepo{
        db: db,
    }
}

func (r *countAssetsRepo) Get() (entity.CountAssets, error) {
    var countAssets entity.CountAssets
    
    // Try to get existing record, if not found create a new one
    err := r.db.First(&countAssets).Error
    if err != nil {
        if err == gorm.ErrRecordNotFound {
            // Create new record with current counts
            return r.createNewCountRecord()
        }
        return countAssets, err
    }
    
    return countAssets, nil
}

func (r *countAssetsRepo) UpdateCounts() error {
    var countAssets entity.CountAssets
    
    // Get current counts from each table
    fishboneCount, err := r.countFishbones()
    if err != nil {
        return err
    }
    
    backboneCount, err := r.countBackbones()
    if err != nil {
        return err
    }
    
    deviceCount, err := r.countDevices()
    if err != nil {
        return err
    }
    
    towerCount, err := r.countTowers()
    if err != nil {
        return err
    }
    
    // Check if record exists
    err = r.db.First(&countAssets).Error
    if err != nil {
        if err == gorm.ErrRecordNotFound {
            // Create new record
            countAssets = entity.CountAssets{
                ID:             uuid.New(),
                FishboneAmount: fishboneCount,
                BackboneAmount: backboneCount,
                DeviceAmount:   deviceCount,
                TowerAmount:    towerCount,
            }
            return r.db.Create(&countAssets).Error
        }
        return err
    }
    
    // Update existing record
    updates := map[string]interface{}{
        "fishbone_amount": fishboneCount,
        "backbone_amount": backboneCount,
        "device_amount":   deviceCount,
        "tower_amount":    towerCount,
    }
    
    return r.db.Model(&countAssets).Updates(updates).Error
}

func (r *countAssetsRepo) createNewCountRecord() (entity.CountAssets, error) {
    fishboneCount, _ := r.countFishbones()
    backboneCount, _ := r.countBackbones()
    deviceCount, _ := r.countDevices()
    towerCount, _ := r.countTowers()
    
    countAssets := entity.CountAssets{
        ID:             uuid.New(),
        FishboneAmount: fishboneCount,
        BackboneAmount: backboneCount,
        DeviceAmount:   deviceCount,
        TowerAmount:    towerCount,
    }
    
    err := r.db.Create(&countAssets).Error
    return countAssets, err
}

// Helper methods to count each entity
func (r *countAssetsRepo) countFishbones() (int, error) {
    var count int64
    err := r.db.Model(&entity.Fishbone{}).Count(&count).Error
    return int(count), err
}

func (r *countAssetsRepo) countBackbones() (int, error) {
    var count int64
    err := r.db.Model(&entity.Backbone{}).Count(&count).Error
    return int(count), err
}

func (r *countAssetsRepo) countDevices() (int, error) {
    var count int64
    err := r.db.Model(&entity.Device{}).Count(&count).Error
    return int(count), err
}

func (r *countAssetsRepo) countTowers() (int, error) {
    var count int64
    err := r.db.Model(&entity.Tower{}).Count(&count).Error
    return int(count), err
}