package orders

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

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

type OrderRepository struct {
	db *gorm.DB
}

func NewOrderRepository(db *gorm.DB) *OrderRepository {
	return &OrderRepository{
		db: db,
	}
}

func (r *OrderRepository) Create(ctx context.Context, order *entity.Order) (*entity.Order, error) {
	err := r.db.WithContext(ctx).Create(order).Error
	if err != nil {
		logger.ContextLogger(ctx).Error("error when creating order", zap.Error(err))
		return nil, err
	}
	return r.FindByID(ctx, order.ID)
}

func (r *OrderRepository) UpdateStatus(ctx context.Context, orderID int64, status string) (*entity.Order, error) {
	order := new(entity.Order)
	if err := r.db.WithContext(ctx).First(order, orderID).Error; err != nil {
		logger.ContextLogger(ctx).Error("error when finding order", zap.Error(err))
		return nil, err
	}
	order.Status = status
	if err := r.db.WithContext(ctx).Save(order).Error; err != nil {
		logger.ContextLogger(ctx).Error("error when updating order status", zap.Error(err))
		return nil, err
	}
	return order, nil
}

func (r *OrderRepository) FindByID(ctx context.Context, id int64) (*entity.Order, error) {
	var order entity.Order

	err := r.db.WithContext(ctx).Preload("OrderItems", func(db *gorm.DB) *gorm.DB {
		return db.Preload("Product")
	}).First(&order, id).Error

	if err != nil {
		logger.ContextLogger(ctx).Error("error when finding order by ID", zap.Error(err))
		return nil, err
	}

	return &order, nil
}

func (r *OrderRepository) SetOrderStatus(ctx context.Context, db *gorm.DB, orderID int64, status string) error {
	var order entity.Order
	if err := db.WithContext(ctx).Preload("OrderItems").First(&order, orderID).Error; err != nil {
		logger.ContextLogger(ctx).Error("error when finding order by ID", zap.Error(err))
		return err
	}

	order.Status = status

	if err := db.WithContext(ctx).Save(&order).Error; err != nil {
		logger.ContextLogger(ctx).Error("error when updating order status", zap.Error(err))
		return err
	}

	return nil
}

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

func (b *OrderRepository) GetAllHystoryOrders(ctx context.Context, req entity.OrderSearch) (entity.HistoryOrderList, int, error) {
	var orders []*entity.HistoryOrderDB
	var total int64

	query := b.db.Table("orders").
		Select("orders.id as id, users.name as employee, sites.name as site, orders.created_at as timestamp, orders.created_at as booking_time, STRING_AGG(ticket_summary.name || ' x' || ticket_summary.total_qty, ', ') AS tickets, orders.payment_type as payment_type, orders.status as status, orders.amount as amount").
		Joins("left join (SELECT items.order_id, products.name, SUM(items.qty) AS total_qty FROM order_items items LEFT JOIN products ON items.item_id = products.id GROUP BY items.order_id, products.name) AS ticket_summary ON orders.id = ticket_summary.order_id").
		Joins("left join users on orders.created_by = users.id").
		Joins("left join sites on orders.site_id = sites.id")

	if req.PaymentType != "" {
		query = query.Where("orders.payment_type = ?", req.PaymentType)
	}

	if req.Status != "" {
		query = query.Where("orders.status = ?", req.Status)
	}

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

	if req.StartDate != "" && req.EndDate != "" {
		// Assuming req.Date and req.EndDate are in string format "YYYY-MM-DD"
		startDate := req.StartDate
		endDate := req.EndDate

		if endDate == "" {
			endDate = time.Now().Format("2006-01-02")
		}

		query = query.Where("orders.created_at BETWEEN ? AND ?", startDate, endDate)
	}

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

	query = query.Group("orders.id, users.name, sites.name, orders.created_at, orders.payment_type, orders.status")

	query = query.Order("orders.created_at DESC")

	if err := query.Count(&total).Error; err != nil {
		logger.ContextLogger(ctx).Error("error when count history orders", zap.Error(err))
		return nil, 0, err
	}

	page := (req.Offset - 1) * req.Limit

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

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

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

	for i, order := range orders {
		if order.RawTickets != "" {
			orders[i].Tickets = strings.Split(order.RawTickets, ", ")
		}
	}

	return orders, int(total), nil
}

func (r *OrderRepository) CountSoldOfTicket(ctx mycontext.Context, req entity.OrderSearch) (*entity.TicketSoldDB, error) {
	today := time.Now().Format("2006-01-02")
	ticketCount := new(entity.TicketSoldDB)

	query := r.db.Table("orders").
		Select("sum(items.qty) as count").
		Joins("left join order_items items on orders.id = items.order_id").
		Where("orders.status = ?", "PAID").
		Where("orders.created_at = ?", today)

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

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

	return ticketCount, nil
}

func (r *OrderRepository) SumAmount(ctx mycontext.Context, req entity.OrderSearch) (*entity.OrderDB, error) {
	amount := new(entity.OrderDB)
	today := time.Now().Format("2006-01-02")

	query := r.db.Table("orders").
		Select("sum(amount) as amount").
		Where("payment_type = ?", req.PaymentType).
		Where("date(created_at) = ?", today).
		Where("status = ?", "PAID")

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

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

	return amount, nil
}

func (r *OrderRepository) GetDailySalesMetrics(ctx context.Context, req entity.OrderSearch) ([]entity.ProductDailySales, error) {
	var sales []entity.ProductDailySales

	// Build the query with GORM
	query := r.db.WithContext(ctx).
		Table("orders o").
		Select(`DATE_TRUNC('day', o.created_at) AS day, oi.item_id, SUM(oi.qty) AS total_quantity`).
		Joins("LEFT JOIN order_items oi ON o.id = oi.order_id").
		Where("o.status = ?", "PAID").
		Where("o.created_at >= ?", time.Now().AddDate(0, 0, -30)). // Last 30 days
		Group("day, oi.item_id").
		Order("day")

	// Apply filters based on the presence of PartnerID and SiteID
	if req.PartnerID != nil {
		query = query.Where("o.partner_id = ?", *req.PartnerID)
	}
	if req.SiteID != nil {
		query = query.Where("o.site_id = ?", *req.SiteID)
	}

	// Execute the query and scan the results
	if err := query.Find(&sales).Error; err != nil {
		return nil, err
	}

	return sales, nil
}