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")
		}).
		Preload("Site").
		Preload("User").
		Preload("Payment").
		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) FindPrintDetailByID(ctx context.Context, id int64) (*entity.OrderPrintDetail, error) {
	var printDetail entity.OrderPrintDetail

	err := r.db.WithContext(ctx).
		Table("orders").
		Select("orders.id, partners.name as partner_name, sites.name as site_name, partners.logo as logo, orders.ref_id as order_id, "+
			"orders.visit_date, orders.payment_type, orders.source, "+
			"orders.ticket_status, orders.total, orders.fee").
		Joins("JOIN partners ON partners.id = orders.partner_id").
		Joins("JOIN sites ON sites.id = orders.site_id").
		Where("orders.id = ?", id).
		Scan(&printDetail).Error

	if err == nil {
		err = r.db.WithContext(ctx).Where("order_id = ?", id).Preload("Product").Find(&printDetail.OrderItems).Error
	}

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

	return &printDetail, nil
}

func (r *OrderRepository) FindByQRCode(ctx context.Context, refID string) (*entity.Order, error) {
	var order entity.Order

	err := r.db.WithContext(ctx).
		Preload("OrderItems", func(db *gorm.DB) *gorm.DB {
			return db.Preload("Product")
		}).
		Preload("User").
		Preload("Payment").
		Where("ref_id = ?", refID).
		First(&order).Error

	if err != nil {
		logger.ContextLogger(ctx).Error("error when finding order by refID", 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).Model(&entity.Order{}).Where("id = ?", order.ID).Updates(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, orders.visit_date as visit_date, orders.ticket_status as ticket_status, orders.source as source").
		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").
		Where("orders.payment_type != ?", "NEW")

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

	if req.CreatedBy != 0 {
		query = query.Where("orders.created_by = ?", req.CreatedBy)
	}

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

	if !req.IsAdmin && !req.IsCustomer {
		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 + " 00:00:00"
		endDate := req.EndDate + " 23:59:59"

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

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

	if req.Source != "" {
		query = query.Where("orders.source = ?", req.Source)
	}

	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
	}

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

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

	if err := query.Debug().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) {
	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")

	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)

	query := r.db.Table("orders").
		Select("sum(amount) as amount").
		Where("status = ?", "PAID")

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

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

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

	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

	var dateTrunc, periodFilter string
	now := time.Now()

	switch req.Period {
	case "1d":
		dateTrunc = "hour"
		periodFilter = now.Add(-24 * time.Hour).Format("2006-01-02 15:04:05")
	case "7d":
		dateTrunc = "day"
		periodFilter = now.Add(-7 * 24 * time.Hour).Format("2006-01-02 15:04:05")
	case "1m":
		dateTrunc = "day"
		periodFilter = now.AddDate(0, -1, 0).Format("2006-01-02 15:04:05")
	case "1y":
		dateTrunc = "week"
		periodFilter = now.AddDate(-1, 0, 0).Format("2006-01-02 15:04:05")
	default:
		dateTrunc = "day"
		periodFilter = now.AddDate(0, -1, 0).Format("2006-01-02 15:04:05") // Default to last month
	}

	// Build the query with GORM
	query := r.db.WithContext(ctx).
		Table("orders o").
		Select(`DATE_TRUNC(?, o.created_at) AS day, s.id AS site_id, s.name AS site_name, o.payment_type, SUM(oi.qty * oi.price) AS total`, dateTrunc).
		Joins("JOIN order_items oi ON o.id = oi.order_id").
		Joins("JOIN sites s ON o.site_id = s.id").
		Where("o.status = ?", "PAID").
		Where("o.created_at >= ?", periodFilter)

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

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

	query = query.Group("day, s.id, s.name, o.payment_type").
		Order("day")

	if err := query.Find(&sales).Error; err != nil {
		return nil, err
	}

	return sales, nil
}

func (r *OrderRepository) GetPaymentTypeDistribution(ctx context.Context, req entity.OrderSearch) ([]entity.PaymentTypeDistribution, error) {
	var distribution []entity.PaymentTypeDistribution

	var periodFilter string
	now := time.Now()

	switch req.Period {
	case "1d":
		periodFilter = now.Add(-24 * time.Hour).Format("2006-01-02 15:04:05")
	case "7d":
		periodFilter = now.Add(-7 * 24 * time.Hour).Format("2006-01-02 15:04:05")
	case "1m":
		periodFilter = now.AddDate(0, -1, 0).Format("2006-01-02 15:04:05")
	case "1y":
		periodFilter = now.AddDate(-1, 0, 0).Format("2006-01-02 15:04:05")
	default:
		periodFilter = now.AddDate(0, -1, 0).Format("2006-01-02 15:04:05") // Default to last month
	}

	query := r.db.WithContext(ctx).
		Table("orders o").
		Select("payment_type, COUNT(*) as count").
		Where("status = ?", "PAID").
		Where("o.created_at >= ?", periodFilter)

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

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

	query = query.Group("payment_type")

	if err := query.Scan(&distribution).Error; err != nil {
		return nil, err
	}

	return distribution, nil
}