package auth

import (
	"cls/internal/domain/auth"
	domainUser "cls/internal/domain/user"
	middleware "cls/internal/infrastructure/middleware/auth"
	"cls/pkg/logger"
	"cls/pkg/xorm_engine"
	"errors"
	"fmt"
	"xorm.io/builder"
)

type AuthRepositoryORM struct {
	engine *xorm_engine.Engine
	auth   *middleware.AuthMiddleware
	log    logger.Logger
}

var _ auth.AuthRepository = (*AuthRepositoryORM)(nil)

func NewAuthRepositoryORM(db *xorm_engine.Engine, auth *middleware.AuthMiddleware, logger logger.New) auth.AuthRepository {
	return &AuthRepositoryORM{
		engine: db,
		auth:   auth,
		log:    logger("panoramic:persistence:auth"),
	}
}
func (a AuthRepositoryORM) LoginByPassword(phone, password string) (string, error) {
	u := &domainUser.User{}
	has, err := a.engine.Where(builder.Eq{"phone": phone}).Get(u)
	if err != nil {
		a.log.Error(err)
		return "", err
	}
	if !has {
		a.log.Errorf("用户不存在")
		return "", errors.New("")
	}

	if u.Password == "" {
		return "", errors.New("请使用验证码登录")
	}

	if u.Password != password {
		return "", errors.New("密码错误")
	}
	token, err := a.auth.GenerateUserToken(phone, u.Openid)
	if err != nil {
		a.log.Error(err.Error())
		return "", err
	}
	return token, nil
}

func (a AuthRepositoryORM) LoginByCaptcha(phone, openid string) (string, error) {
	u := &domainUser.User{}
	has, err := a.engine.Where(builder.Eq{"phone": phone}).Get(u)
	if err != nil {
		a.log.Error(err)
		return "", err
	}
	if !has {
		//注册用户
		u.Phone = phone
		u.GiftCount = 2
		u.Status = 1
		u.Openid = openid
		_, err = a.engine.Insert(u)
		if err != nil {
			a.log.Error(err)
		}
	}

	if u.Openid != openid {
		a.log.Errorf("openid和手机号不匹配,[%s]-[%s]", phone, openid)
		return "", errors.New("不支持换机登录")
	}

	if u.Status == 0 {
		return "", errors.New(fmt.Sprintf("用户【%d】禁止登录", u.Id))
	}

	token, err := a.auth.GenerateUserToken(phone, u.Openid)
	if err != nil {
		a.log.Error(err)
	}
	return token, nil
}