package mysqldao

import (
	"context"

	"git.lzcwy.cn/zhengchiliu/zt-closet-backend/global"
	"git.lzcwy.cn/zhengchiliu/zt-closet-backend/internal/mysqlmodel"
	"gorm.io/gorm"
)

// OrderDao 订单数据访问
type OrderDao struct {
	db *gorm.DB
}

// NewOrderDao 创建订单 DAO
func NewOrderDao() *OrderDao {
	return &OrderDao{db: global.MysqlEngine}
}

// OrderCreate 创建订单
func (d *OrderDao) OrderCreate(ctx context.Context, order *mysqlmodel.Order) error {
	ctx, span := global.Tracer.Start(ctx, "mysqldao.OrderCreate")
	defer span.End()

	if err := d.db.WithContext(ctx).Create(order).Error; err != nil {
		span.RecordError(err)
		return err
	}
	return nil
}

// OrderUpdateByOrderNo 按订单号更新订单字段
func (d *OrderDao) OrderUpdateByOrderNo(ctx context.Context, orderNo string, updates map[string]any) error {
	ctx, span := global.Tracer.Start(ctx, "mysqldao.OrderUpdateByOrderNo")
	defer span.End()

	if err := d.db.WithContext(ctx).Model(&mysqlmodel.Order{}).Where("order_no = ?", orderNo).Updates(updates).Error; err != nil {
		span.RecordError(err)
		return err
	}
	return nil
}

// OrderUpdateStatusByOrderNo 条件流转订单状态（防重复回调），返回是否更新成功
func (d *OrderDao) OrderUpdateStatusByOrderNo(ctx context.Context, orderNo string, fromStatus, toStatus int8) (bool, error) {
	ctx, span := global.Tracer.Start(ctx, "mysqldao.OrderUpdateStatusByOrderNo")
	defer span.End()

	res := d.db.WithContext(ctx).Model(&mysqlmodel.Order{}).
		Where("order_no = ? AND order_status = ?", orderNo, fromStatus).
		Update("order_status", toStatus)
	if res.Error != nil {
		span.RecordError(res.Error)
		return false, res.Error
	}
	return res.RowsAffected > 0, nil
}

// OrderExpireByTime 将超过支付有效期的待支付订单批量置为已过期，返回更新条数。
// 状态字面量：1=待支付 4=已过期（与 service 层 OrderStatusPending/OrderStatusExpired 一致）。
func (d *OrderDao) OrderExpireByTime(ctx context.Context, now int64) (int64, error) {
	ctx, span := global.Tracer.Start(ctx, "mysqldao.OrderExpireByTime")
	defer span.End()

	res := d.db.WithContext(ctx).Model(&mysqlmodel.Order{}).
		Where("order_status = ? AND expire_time < ?", 1, now).
		Update("order_status", 4)
	if res.Error != nil {
		span.RecordError(res.Error)
		return 0, res.Error
	}
	return res.RowsAffected, nil
}

// OrderListVirtualUnconfirmed 查询需主动查单确认的虚拟支付订单：
// 支付渠道为虚拟支付（2）且状态为待支付（1）/已过期（4），创建时间落在 [since, until) 内。
// 用于「发货推送丢失」的兜底轮询（官方建议推送与轮询同时实现），按 id 升序限量返回。
func (d *OrderDao) OrderListVirtualUnconfirmed(ctx context.Context, since, until int64, limit int) ([]mysqlmodel.Order, error) {
	ctx, span := global.Tracer.Start(ctx, "mysqldao.OrderListVirtualUnconfirmed")
	defer span.End()

	var list []mysqlmodel.Order
	if err := d.db.WithContext(ctx).
		Where("pay_channel = ? AND order_status IN ? AND created_at >= ? AND created_at < ?",
			2, []int8{1, 4}, since, until).
		Order("id ASC").Limit(limit).Find(&list).Error; err != nil {
		span.RecordError(err)
		return nil, err
	}
	return list, nil
}

// OrderListPaidMissingBenefitTasks 查询存在未建权益任务的已支付订单，修复支付回调与任务落库之间的崩溃窗口。
func (d *OrderDao) OrderListPaidMissingBenefitTasks(ctx context.Context, limit int) ([]mysqlmodel.Order, error) {
	var list []mysqlmodel.Order
	err := d.db.WithContext(ctx).Where("order_status = ?", 2).
		Where(`(member_days > 0 AND NOT EXISTS (SELECT 1 FROM benefit_grant_tasks t WHERE t.order_no=orders.order_no AND t.benefit_type=1)) OR
		(cos_quota > 0 AND NOT EXISTS (SELECT 1 FROM benefit_grant_tasks t WHERE t.order_no=orders.order_no AND t.benefit_type=2)) OR
		(ai_recommend_quota > 0 AND NOT EXISTS (SELECT 1 FROM benefit_grant_tasks t WHERE t.order_no=orders.order_no AND t.benefit_type=3)) OR
		(closet_share_quota > 0 AND NOT EXISTS (SELECT 1 FROM benefit_grant_tasks t WHERE t.order_no=orders.order_no AND t.benefit_type=4)) OR
		(outfit_share_quota > 0 AND NOT EXISTS (SELECT 1 FROM benefit_grant_tasks t WHERE t.order_no=orders.order_no AND t.benefit_type=5))`).
		Order("id ASC").Limit(limit).Find(&list).Error
	return list, err
}

// OrderGetByID 按主键 ID 查询订单
func (d *OrderDao) OrderGetByID(ctx context.Context, id int64) (*mysqlmodel.Order, error) {
	ctx, span := global.Tracer.Start(ctx, "mysqldao.OrderGetByID")
	defer span.End()

	var order mysqlmodel.Order
	if err := d.db.WithContext(ctx).First(&order, id).Error; err != nil {
		span.RecordError(err)
		return nil, err
	}
	return &order, nil
}

// OrderGetByOrderNo 按商户订单号查询订单
func (d *OrderDao) OrderGetByOrderNo(ctx context.Context, orderNo string) (*mysqlmodel.Order, error) {
	ctx, span := global.Tracer.Start(ctx, "mysqldao.OrderGetByOrderNo")
	defer span.End()

	var order mysqlmodel.Order
	if err := d.db.WithContext(ctx).Where("order_no = ?", orderNo).First(&order).Error; err != nil {
		span.RecordError(err)
		return nil, err
	}
	return &order, nil
}

// OrderListByUserID 分页查询用户订单（status 为 0 不筛选）
func (d *OrderDao) OrderListByUserID(ctx context.Context, userID int64, status int8, page, pageSize int) ([]mysqlmodel.Order, int64, error) {
	ctx, span := global.Tracer.Start(ctx, "mysqldao.OrderListByUserID")
	defer span.End()

	var list []mysqlmodel.Order
	var total int64
	q := d.db.WithContext(ctx).Model(&mysqlmodel.Order{}).Where("user_id = ?", userID)
	if status != 0 {
		q = q.Where("order_status = ?", status)
	}
	if err := q.Count(&total).Error; err != nil {
		span.RecordError(err)
		return nil, 0, err
	}
	if err := q.Offset((page - 1) * pageSize).Limit(pageSize).Order("id DESC").Find(&list).Error; err != nil {
		span.RecordError(err)
		return nil, 0, err
	}
	return list, total, nil
}

// RefundFlowLogDao 退款流水数据访问
type RefundFlowLogDao struct {
	db *gorm.DB
}

// NewRefundFlowLogDao 创建退款流水 DAO
func NewRefundFlowLogDao() *RefundFlowLogDao {
	return &RefundFlowLogDao{db: global.MysqlEngine}
}

// RefundFlowLogCreate 创建退款流水
func (d *RefundFlowLogDao) RefundFlowLogCreate(ctx context.Context, log *mysqlmodel.RefundFlowLog) error {
	ctx, span := global.Tracer.Start(ctx, "mysqldao.RefundFlowLogCreate")
	defer span.End()

	if err := d.db.WithContext(ctx).Create(log).Error; err != nil {
		span.RecordError(err)
		return err
	}
	return nil
}

// RefundFlowLogUpdateStatus 按退款单号更新退款流水字段
func (d *RefundFlowLogDao) RefundFlowLogUpdateStatus(ctx context.Context, refundNo string, updates map[string]any) error {
	ctx, span := global.Tracer.Start(ctx, "mysqldao.RefundFlowLogUpdateStatus")
	defer span.End()

	if err := d.db.WithContext(ctx).Model(&mysqlmodel.RefundFlowLog{}).Where("refund_no = ?", refundNo).Updates(updates).Error; err != nil {
		span.RecordError(err)
		return err
	}
	return nil
}

// RefundFlowLogUpdateStatusByFrom 条件流转退款流水状态（防并发/乱序回调覆盖），返回是否更新成功。
func (d *RefundFlowLogDao) RefundFlowLogUpdateStatusByFrom(ctx context.Context, refundNo string, fromStatus int8, updates map[string]any) (bool, error) {
	ctx, span := global.Tracer.Start(ctx, "mysqldao.RefundFlowLogUpdateStatusByFrom")
	defer span.End()

	res := d.db.WithContext(ctx).Model(&mysqlmodel.RefundFlowLog{}).
		Where("refund_no = ? AND status = ?", refundNo, fromStatus).
		Updates(updates)
	if res.Error != nil {
		span.RecordError(res.Error)
		return false, res.Error
	}
	return res.RowsAffected > 0, nil
}

// RefundFlowLogGetByRefundNo 按退款单号查询退款流水
func (d *RefundFlowLogDao) RefundFlowLogGetByRefundNo(ctx context.Context, refundNo string) (*mysqlmodel.RefundFlowLog, error) {
	ctx, span := global.Tracer.Start(ctx, "mysqldao.RefundFlowLogGetByRefundNo")
	defer span.End()

	var log mysqlmodel.RefundFlowLog
	if err := d.db.WithContext(ctx).Where("refund_no = ?", refundNo).First(&log).Error; err != nil {
		span.RecordError(err)
		return nil, err
	}
	return &log, nil
}

// RefundFlowLogGetByOrderNo 按商户订单号查询退款流水
func (d *RefundFlowLogDao) RefundFlowLogGetByOrderNo(ctx context.Context, orderNo string) (*mysqlmodel.RefundFlowLog, error) {
	ctx, span := global.Tracer.Start(ctx, "mysqldao.RefundFlowLogGetByOrderNo")
	defer span.End()

	var log mysqlmodel.RefundFlowLog
	if err := d.db.WithContext(ctx).Where("order_no = ?", orderNo).First(&log).Error; err != nil {
		span.RecordError(err)
		return nil, err
	}
	return &log, nil
}