package repository

import (
	"fmt"
	"time"
	"users_management/m/model/entity"

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

type TowerRepo interface {
	Post(tower entity.Tower) error
	GetAll() ([]entity.Tower, error)
	Update(id uuid.UUID,updates map[string]interface{}) error
	GetByID(id uuid.UUID) (entity.Tower, error)
    CheckDeviceExists(deviceID uuid.UUID) (bool, error)
	BulkUpdateImages(updates map[uuid.UUID]string) error
	GetDeviceLocation(deviceID uuid.UUID) (longitude, latitude float64, err error)
}

type towerRepo struct {
	db *gorm.DB
}

func NewTowerRepo(db *gorm.DB) TowerRepo {
	return &towerRepo{
		db: db,
	}
}

func (r *towerRepo) GetDeviceLocation(deviceID uuid.UUID) (longitude, latitude float64, err error) {
    var device entity.Device
    err = r.db.Select("longitude, latitude").Where("id = ?", deviceID).First(&device).Error
    if err != nil {
        return 0, 0, fmt.Errorf("device not found: %w", err)
    }
    return device.Longitude, device.Latitude, nil
}

func (r *towerRepo) Post(tower entity.Tower) error {
	err := r.db.Create(&tower).Error
	if err != nil {
		return err
	}
	return nil
}

func (r *towerRepo) GetAll() ([]entity.Tower, error) {
	var towers []entity.Tower
	// Chain debug methods
	result := r.db.Preload("Device").Find(&towers)
	if result.Error != nil {
		return nil, result.Error
	}
	return towers, nil
}

func (r *towerRepo) CheckDeviceExists(deviceID uuid.UUID) (bool, error) {
    var count int64
    err := r.db.Model(&entity.Device{}).Where("id = ?", deviceID).Count(&count).Error
    return count > 0, err
}
func (r *towerRepo) Update(id uuid.UUID,updates map[string]interface{}) error {
	err := r.db.Model(&entity.Tower{}).Where("id = ?", id).Updates(updates).Error
	if err != nil {
		return err
	}
	return nil
}

func (r *towerRepo) GetByID(id uuid.UUID) (entity.Tower, error) {
	var tower entity.Tower
	err := r.db.Where("id = ?", id).Preload("Device").First(&tower).Error
	if err != nil {
		return tower, err
	}
	return tower, nil
}

func (r *towerRepo) BulkUpdateImages(updates map[uuid.UUID]string) error {
    return r.db.Transaction(func(tx *gorm.DB) error {
        for towerID, imageURL := range updates {
            if err := tx.Model(&entity.Tower{}).
                Where("id = ?", towerID).
                Updates(map[string]interface{}{
                    "image_url":  imageURL,
                    "updated_at": time.Now(),
                }).Error; err != nil {
                return fmt.Errorf("failed to update tower %s: %w", towerID, err)
            }
        }
        return nil
    })
}