package sites

import (
	"context"
	"furtuna-be/internal/common/logger"
	"furtuna-be/internal/common/mycontext"
	"furtuna-be/internal/entity"

	"go.uber.org/zap"
	"gorm.io/gorm"
)

type SiteRepository struct {
	db *gorm.DB
}

func NewSiteRepository(db *gorm.DB) *SiteRepository {
	return &SiteRepository{
		db: db,
	}
}

func (r *SiteRepository) Upsert(ctx context.Context, site *entity.Site) (*entity.Site, error) {
	err := r.db.Transaction(func(tx *gorm.DB) error {
		if site.ID != 0 {
			// Update site
			if err := tx.Save(site).Error; err != nil {
				return err
			}
		} else {
			// Create new site
			if err := tx.Create(site).Error; err != nil {
				return err
			}
		}

		if len(site.Products) > 0 {
			for i := range site.Products {
				site.Products[i].SiteID = site.ID
				if site.Products[i].ID != 0 {
					// Update existing product
					if err := tx.Save(&site.Products[i]).Error; err != nil {
						return err
					}
				} else {
					// Create new product
					if err := tx.Create(&site.Products[i]).Error; err != nil {
						return err
					}
				}
			}
		}
		return nil
	})

	if err != nil {
		logger.ContextLogger(ctx).Error("error when upserting site", zap.Error(err))
		return nil, err
	}
	return site, nil
}

func (r *SiteRepository) Create(ctx context.Context, site *entity.SiteDB) (*entity.SiteDB, error) {
	err := r.db.Create(site).Error
	if err != nil {
		logger.ContextLogger(ctx).Error("error when creating site", zap.Error(err))
		return nil, err
	}
	return site, nil
}

func (r *SiteRepository) Update(ctx context.Context, site *entity.SiteDB) (*entity.SiteDB, error) {
	if err := r.db.Save(site).Error; err != nil {
		logger.ContextLogger(ctx).Error("error when updating site", zap.Error(err))
		return nil, err
	}
	return site, nil
}

func (r *SiteRepository) GetByID(ctx context.Context, id int64) (*entity.SiteDB, error) {
	site := new(entity.SiteDB)
	if err := r.db.First(site, id).Error; err != nil {
		logger.ContextLogger(ctx).Error("error when getting site by ID", zap.Error(err))
		return nil, err
	}
	return site, nil
}

func (r *SiteRepository) GetAll(ctx context.Context, req entity.SiteSearch) (entity.SiteList, int, error) {
	var sites []*entity.SiteDB
	var total int64

	query := r.db
	query = query.Where("deleted_at IS NULL")

	if req.Search != "" {
		query = query.Where("name ILIKE ?", "%"+req.Search+"%")
	}

	if req.Name != "" {
		query = query.Where("name ILIKE ?", "%"+req.Name+"%")
	}

	if req.PartnerID != nil {
		query = query.Where("partner_id = ?", req.PartnerID)
	}

	if req.SiteID != nil {
		query = query.Where("id = ?", req.SiteID)
	}

	if req.Limit > 0 {
		query = query.Limit(req.Limit)
	}

	if req.Offset > 0 {
		query = query.Offset(req.Offset)
	}

	if err := query.Find(&sites).Error; err != nil {
		logger.ContextLogger(ctx).Error("error when getting all sites", zap.Error(err))
		return nil, 0, err
	}

	if err := r.db.Model(&entity.SiteDB{}).Where(query).Count(&total).Error; err != nil {
		logger.ContextLogger(ctx).Error("error when counting sites", zap.Error(err))
		return nil, 0, err
	}

	return sites, int(total), nil
}

func (r *SiteRepository) Delete(ctx context.Context, id int64) error {
	site := new(entity.SiteDB)
	site.ID = id
	if err := r.db.Delete(site).Error; err != nil {
		return err
	}
	return nil
}

func (r *SiteRepository) Count(ctx mycontext.Context, req entity.SiteSearch) (*entity.SiteCountDB, error) {
	count := new(entity.SiteCountDB)

	query := r.db.Table("sites").
		Select("count(*) as count")

	if !req.IsAdmin {
		query = query.Where("partner_id = ?", req.PartnerID)
	}

	if err := query.Scan(&count).Error; err != nil {
		logger.ContextLogger(ctx).Error("error when get count sites", zap.Error(err))
		return nil, err
	}

	return count, nil
}