package user

import (
	"cls/internal/domain/purchase"
	domainUser "cls/internal/domain/user"
	"cls/pkg/logger"
	"cls/pkg/xorm_engine"
	"errors"
	"xorm.io/builder"
)

// UserAggregateRepositoryORM 用户聚合根仓储实现
type UserAggregateRepositoryORM struct {
	engine *xorm_engine.Engine
	log    logger.Logger
}

var _ domainUser.UserAggregateRepository = (*UserAggregateRepositoryORM)(nil)

func NewUserAggregateRepositoryORM(db *xorm_engine.Engine, logger logger.New) domainUser.UserAggregateRepository {
	return &UserAggregateRepositoryORM{
		engine: db,
		log:    logger("panoramic:persistence:user_aggregate"),
	}
}

func (u *UserAggregateRepositoryORM) GetUserAggregate(phone string) (*domainUser.UserAggregate, error) {
	// 1. 获取用户信息
	user := &domainUser.User{}
	exist, err := u.engine.Where(builder.Eq{"phone": phone}).Get(user)
	if err != nil {
		u.log.Error("获取用户信息失败", err)
		return nil, err
	}
	if !exist {
		return nil, errors.New("用户不存在")
	}

	// 2. 获取用户的购买记录
	var purchases []*purchase.Purchase
	err = u.engine.Where(builder.Eq{"user_id": user.Id}).Find(&purchases)
	if err != nil {
		u.log.Error("获取用户购买记录失败", err)
		return nil, err
	}

	// 3. 构建用户聚合根
	aggregate := domainUser.NewUserAggregate(user)
	aggregate.SetPurchases(purchases)

	return aggregate, nil
}

func (u *UserAggregateRepositoryORM) SaveUserAggregate(aggregate *domainUser.UserAggregate) error {
	// 1. 开启事务
	session := u.engine.NewSession()
	if err := session.Begin(); err != nil {
		u.log.Error("开启事务失败", err)
		return err
	}
	defer session.Close()

	// 2. 更新用户信息
	if _, err := session.Where(builder.Eq{"id": aggregate.GetUser().Id}).Cols("gift_count").Unscoped().Update(aggregate.GetUser()); err != nil {
		u.log.Error("更新用户信息失败", err)
		return err
	}

	// 3. 保存购买记录
	for _, p := range aggregate.GetPurchases() {
		if p.Id < 1 {
			if _, err := session.Insert(p); err != nil {
				u.log.Error("保存购买记录失败", err)
				return err
			}
		}
	}

	// 4. 提交事务
	if err := session.Commit(); err != nil {
		u.log.Error("提交事务失败", err)
		return err
	}

	return nil
}