package user

import (
	coupon2 "cls-server/internal/application/coupon"
	"cls-server/internal/application/crypto"
	gift_log "cls-server/internal/application/gift_log"
	"cls-server/internal/domain/coupon"
	gift_log2 "cls-server/internal/domain/gift_log"
	"cls-server/internal/domain/user"
	"cls-server/pkg/logger"
	"cls-server/pkg/util/page"
	"cls-server/pkg/web"
	"errors"
	"fmt"
	"math/rand"
	"regexp"
	"time"
)

var (
	ErrInvalidPhone      = errors.New("手机号格式不正确")
	ErrInvalidVerifyCode = errors.New("验证码不正确")
	ErrVerifyCodeExpired = errors.New("验证码已过期")
	ErrUserNotFound      = errors.New("用户不存在")
)

const (
	VerifyCodeKeyPrefix  = "sms:verify:code:" // Redis中验证码的key前缀
	VerifyCodeExpiration = 5 * time.Minute    // 验证码有效期5分钟
)

// UserService 用户业务逻辑
type UserService struct {
	repo            user.UserRepository
	phoneEncryption *crypto.PhoneEncryptionService
	passwordHash    *crypto.PasswordHashService
	uglAggregate    user.UserGiftLogAggregateRepository
	couponRepo      coupon.CouponRepository
	log             logger.Logger
}

func NewUserService(repo user.UserRepository,
	phoneEncryption *crypto.PhoneEncryptionService,
	uglAggregate user.UserGiftLogAggregateRepository,
	couponRepo coupon.CouponRepository,
	passwordHash *crypto.PasswordHashService, logger logger.New) *UserService {
	return &UserService{
		repo:            repo,
		phoneEncryption: phoneEncryption,
		passwordHash:    passwordHash,
		uglAggregate:    uglAggregate,
		couponRepo:      couponRepo,
		log:             logger("panoramic:AccountModule:UserService"),
	}
}

// ListUsers 获取用户列表
func (u *UserService) ListUsers(p *page.Page, params map[string]string) error {
	conds := web.ParseFilters(params)
	data := make([]*user.User, 0)
	p.Content = &data
	err := u.repo.FindAll(p, conds)
	if err != nil {
		u.log.Error(err)
		return err
	}

	dtoData := make([]*UserDto, 0, len(data))
	for _, v := range data {
		sP, err := u.phoneEncryption.StringPhone(v.Phone)
		if err != nil {
			u.log.Error(err)
			continue
		}
		dtoData = append(dtoData, &UserDto{
			Uid:       v.Id,
			Username:  v.Username,
			Phone:     sP,
			Password:  v.Password != "",
			GiftCount: v.GiftCount,
			Status:    v.Status,
		})
	}
	p.Content = &dtoData
	return nil
}

func (u *UserService) GiveGift(gl *gift_log.GiftLogDto) error {
	ugla, err := u.uglAggregate.GetUserGiftLogAggregate(gl.UserId)
	if err != nil {
		u.log.Error(err)
		return err
	}
	fmt.Printf("%+v\n", ugla)
	err = ugla.AddGiftToUser(&gift_log2.GiftLog{
		Id:      gl.Id,
		AdminId: gl.AdminId,
		UserId:  gl.UserId,
		Num:     gl.Num,
	})
	if err != nil {
		u.log.Error(err)
		return err
	}
	err = u.uglAggregate.SaveUserGiftLogAggregate(ugla)
	if err != nil {
		u.log.Error(err)
	}
	return err
}

func (u *UserService) GiveCoupon(uc *coupon2.CouponDto) error {
	fmt.Println("发放优惠券", uc)
	err := u.couponRepo.Create(&coupon.Coupon{
		Name:      uc.Name,
		Type:      uc.Type,
		Value:     uc.Value,
		MinAmount: uc.MinAmount,
		StartTime: uc.StartTime,
		EndTime:   uc.EndTime,
		AdminID:   uc.AdminId,
		UserID:    uc.UserId,
	})
	if err != nil {
		u.log.Error(err)
	}
	return err
}

// DisableUser 禁用用户
func (u *UserService) DisableUser(id uint64) error {
	existUser, err := u.repo.FindByID(id)
	if err != nil {
		return err
	}

	existUser.Status = 0
	return u.repo.Save(existUser)
}

// EnableUser 启用用户
func (u *UserService) EnableUser(id uint64) error {
	existUser, err := u.repo.FindByID(id)
	if err != nil {
		return err
	}
	existUser.Status = 1
	return u.repo.Save(existUser)
}

// isValidPhone 验证手机号格式
func isValidPhone(phone string) bool {
	pattern := `^1[3-9]\d{9}$`
	reg := regexp.MustCompile(pattern)
	return reg.MatchString(phone)
}

// generateVerifyCode 生成6位数字验证码
func generateVerifyCode() string {
	rand.Seed(time.Now().UnixNano())
	return fmt.Sprintf("%06d", rand.Intn(1000000))
}