package order

import (
	"cls/internal/domain/coupon"
	"cls/internal/domain/order"
	"cls/internal/domain/payment"
	"cls/internal/domain/purchase"
	"cls/pkg/logger"
	"cls/pkg/util/page"
	"cls/pkg/xorm_engine"
	"errors"
	"xorm.io/builder"
)

// AggregateRepositoryORM 订单聚合根仓储实现
type AggregateRepositoryORM struct {
	engine *xorm_engine.Engine
	log    logger.Logger
}

var _ order.AggregateRepository = (*AggregateRepositoryORM)(nil)

// NewAggregateRepositoryORM 创建订单聚合根仓储实现
func NewAggregateRepositoryORM(engine *xorm_engine.Engine, log logger.New) order.AggregateRepository {
	return &AggregateRepositoryORM{
		engine: engine,
		log:    log("cls:repo:order:aggregate"),
	}
}

// Save 保存订单聚合根
func (r *AggregateRepositoryORM) Save(aggregate *order.OrderAggregate) error {
	session := r.engine.NewSession()
	defer session.Close()

	if err := session.Begin(); err != nil {
		return err
	}

	// 保存订单
	if _, err := session.Insert(aggregate.Order); err != nil {
		return err
	}

	// 保存支付订单
	if aggregate.Payment != nil {
		if _, err := session.Insert(aggregate.Payment); err != nil {
			return err
		}
	}

	if aggregate.Coupon != nil {
		if aggregate.Coupon.ID > 0 {
			_, err := session.Where(builder.Eq{"id": aggregate.Coupon.ID}).Cols("status").Update(aggregate.Coupon)
			if err != nil {
				return err
			}
		}

	}

	if err := session.Commit(); err != nil {
		return err
	}

	return nil
}

func (r *AggregateRepositoryORM) PaySuccess(aggregate *order.OrderAggregate) error {
	session := r.engine.NewSession()
	defer session.Close()
	if err := session.Begin(); err != nil {
		return err
	}
	_, err := session.Where(builder.Eq{"id": aggregate.Payment.ID}.
		And(builder.Eq{"order_no": aggregate.Payment.OrderNo})).Cols("status", "transaction_id", "notify_data").Update(aggregate.Payment)
	if err != nil {
		return err
	}

	_, err = session.Where(builder.Eq{"id": aggregate.Order.ID}.
		And(builder.Eq{"order_no": aggregate.Order.OrderNo})).Cols("status").Update(aggregate.Order)
	if err != nil {
		return err
	}
	_, err = session.Insert(aggregate.Purchase)
	if err != nil {
		return err
	}
	err = session.Commit()
	return err
}

func (r *AggregateRepositoryORM) PayFailed(aggregate *order.OrderAggregate) error {
	session := r.engine.NewSession()
	defer session.Close()
	if err := session.Begin(); err != nil {
		return err
	}
	_, err := session.Where(builder.Eq{"id": aggregate.Payment.ID}.
		And(builder.Eq{"order_no": aggregate.Payment.OrderNo})).Cols("status", "transaction_id", "notify_data").Update(aggregate.Payment)
	if err != nil {
		return err
	}

	_, err = session.Where(builder.Eq{"id": aggregate.Order.ID}.
		And(builder.Eq{"order_no": aggregate.Order.OrderNo})).Cols("status").Update(aggregate.Order)
	if err != nil {
		return err
	}

	if aggregate.Coupon != nil {
		if aggregate.Coupon.ID > 0 {
			//回退优惠券
			_, err = session.Where(builder.Eq{"id": aggregate.Coupon.ID}).Cols("status").Update(aggregate.Coupon)
			if err != nil {
				return err
			}
		}
	}

	err = session.Commit()
	return err
}

// GetByOrderNo 根据订单号获取订单聚合根
func (r *AggregateRepositoryORM) GetByOrderNo(orderNo string) (*order.OrderAggregate, error) {
	// 获取订单
	o := &order.Order{}
	has, err := r.engine.Where(builder.Eq{"order_no": orderNo}).Get(o)
	if err != nil {
		return nil, err
	}
	if !has {
		return nil, errors.New("订单不存在")
	}
	aggregate := order.NewOrderAggregate(o)

	// 获取支付订单
	p := &payment.Payment{}
	has, err = r.engine.Where(builder.Eq{"order_no": orderNo}).Get(p)
	if err != nil {
		return nil, err
	}
	if has {
		aggregate.Payment = p
	}

	// 获取购买记录
	pu := &purchase.Purchase{}
	has, err = r.engine.Where(builder.Eq{"user_id": o.UserID, "content_id": o.TargetID}).Get(pu)
	if err != nil {
		return nil, err
	}
	if has {
		aggregate.Purchase = pu
	}

	// 获取优惠券
	co := &coupon.Coupon{}
	has, err = r.engine.Where(builder.Eq{"id": o.Coupon}).Get(co)
	if err != nil {
		return nil, err
	}
	if has {
		aggregate.Coupon = co
	}
	return aggregate, nil
}

// GetByID 根据ID获取订单聚合根
func (r *AggregateRepositoryORM) GetByID(id uint64) (*order.OrderAggregate, error) {
	// 获取订单
	o := &order.Order{}
	has, err := r.engine.ID(id).Get(o)
	if err != nil {
		r.log.Error(err)
		return nil, err
	}
	if !has {
		return nil, errors.New("订单不存在")
	}

	// 获取支付订单
	p := &payment.Payment{}
	has, err = r.engine.Where(builder.Eq{"order_no": o.OrderNo}).Get(p)
	if err != nil {
		r.log.Error(err)
		return nil, err
	}

	// 获取购买记录
	pu := &purchase.Purchase{}
	has, err = r.engine.Where(builder.Eq{"user_id": o.UserID, "content_id": o.TargetID}).Get(pu)
	if err != nil {
		r.log.Error(err)
		return nil, err
	}

	aggregate := order.NewOrderAggregate(o)
	if has {
		aggregate.Payment = p
		aggregate.Purchase = pu
	}

	return aggregate, nil
}

// ListByUserID 获取用户订单聚合根列表
func (r *AggregateRepositoryORM) ListByUserID(userID uint64, page *page.Page) ([]*order.OrderAggregate, int64, error) {
	// 获取订单总数
	o := &order.Order{}
	total, err := r.engine.Where(builder.Eq{"user_id": userID}).Count(o)
	if err != nil {
		r.log.Error(err)
		return nil, 0, err
	}

	// 获取订单列表
	var orders []*order.Order
	err = r.engine.Where(builder.Eq{"user_id": userID}).
		Limit(page.PageSize, (page.PageNumber-1)*page.PageSize).
		Find(&orders)
	if err != nil {
		r.log.Error(err)
		return nil, 0, err
	}

	// 获取支付订单和购买记录
	aggregates := make([]*order.OrderAggregate, len(orders))
	for i, o := range orders {
		aggregate := order.NewOrderAggregate(o)

		// 获取支付订单
		p := &payment.Payment{}
		has, err := r.engine.Where(builder.Eq{"order_no": o.OrderNo}).Get(p)
		if err != nil {
			r.log.Error(err)
			return nil, 0, err
		}
		if has {
			aggregate.Payment = p
		}

		// 获取购买记录
		pu := &purchase.Purchase{}
		has, err = r.engine.Where(builder.Eq{"user_id": o.UserID, "content_id": o.TargetID}).Get(pu)
		if err != nil {
			r.log.Error(err)
			return nil, 0, err
		}
		if has {
			aggregate.Purchase = pu
		}

		aggregates[i] = aggregate
	}

	return aggregates, total, nil
}

// Delete 删除订单聚合根
func (r *AggregateRepositoryORM) Delete(id uint64) error {
	session := r.engine.NewSession()
	defer session.Close()

	if err := session.Begin(); err != nil {
		r.log.Error(err)
		return err
	}

	// 获取订单
	o := &order.Order{}
	has, err := session.ID(id).Get(o)
	if err != nil {
		session.Rollback()
		r.log.Error(err)
		return err
	}
	if !has {
		session.Rollback()
		return errors.New("订单不存在")
	}

	// 删除支付订单
	if _, err := session.Where(builder.Eq{"order_no": o.OrderNo}).Delete(&payment.Payment{}); err != nil {
		session.Rollback()
		r.log.Error(err)
		return err
	}

	// 删除购买记录
	if _, err := session.Where(builder.Eq{"user_id": o.UserID, "content_id": o.TargetID}).Delete(&purchase.Purchase{}); err != nil {
		session.Rollback()
		r.log.Error(err)
		return err
	}

	// 删除订单
	if _, err := session.ID(id).Delete(&order.Order{}); err != nil {
		session.Rollback()
		r.log.Error(err)
		return err
	}

	if err := session.Commit(); err != nil {
		r.log.Error(err)
		return err
	}

	return nil
}