package service

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"strconv"
	"strings"
	"time"
	"youngee_b_api/consts"
	"youngee_b_api/db"
	"youngee_b_api/model/redis_model"
	"youngee_b_api/model/system_model"
	"youngee_b_api/redis"
	"youngee_b_api/util"

	"github.com/sirupsen/logrus"
)

var LoginAuth *loginAuth

func LoginAuthInit(config *system_model.Session) {
	auth := new(loginAuth)
	auth.sessionTTL = time.Duration(config.TTL) * time.Minute
	LoginAuth = auth
}

type loginAuth struct {
	sessionTTL time.Duration
}

func (l *loginAuth) AuthToken(ctx context.Context, token string) (*redis_model.Auth, error) {
	phone, err := l.parseToken(ctx, token)
	if err != nil {
		logrus.Debug("token格式错误:%+v", token)
		return nil, err
	}
	auth, err := l.getSession(ctx, phone)
	if err != nil {
		logrus.Debug("获取session redis错误: token:%+v,err:%+v", token, err)
		return nil, err
	}
	if auth.Token != token {
		logrus.Debug("获取session time过期错误: token:%+v", token)
		return nil, errors.New("auth failed")
	}
	return auth, nil

}

func (l *loginAuth) AuthMSG(ctx context.Context, phone string, vcode string) (string, error) {
	// 验证是否存在
	user, err := db.GetUserByPhone(ctx, phone)
	if err != nil {
		return "", err
	}
	code, err := l.getSessionCode(ctx, phone)
	if err != nil {
		return "", err
	}
	if user == nil {
		fmt.Printf("user == nil\n")
	}
	if string(user.Role) != consts.BRole {
		fmt.Printf("%+v\n", string(user.Role))
	}
	if *code != vcode {
		fmt.Printf("code:%+v, vcode:%+v\n", *code, vcode)
	}
	if user == nil || string(user.Role) != consts.BRole || *code != vcode { // 登录失败
		logrus.Debugf("[AuthPassword] auth fail,phone:%+v", phone)
		return "", errors.New("auth fail")
	}
	token := l.getToken(ctx, phone)
	auth := &redis_model.Auth{
		Phone:    phone,
		ID:       user.ID,
		User:     user.User,
		Username: user.Username,
		RealName: user.RealName,
		Role:     user.Role,
		Email:    user.Email,
		Token:    token,
	}
	if err := l.setSession(ctx, phone, auth); err != nil {
		fmt.Printf("setSession error\n")
		return "", err
	}
	return token, nil
}

func (l *loginAuth) AuthPassword(ctx context.Context, phone string, password string) (string, error) {
	// 验证是否存在
	user, err := db.GetUserByPhone(ctx, phone)
	if err != nil {
		return "", err
	}
	// 验证正确性
	if user == nil || user.Role != consts.BRole || user.Password != l.encryptPassword(password) {
		// 登录失败
		logrus.Debugf("[AuthPassword] auth fail,phone:%+v", phone)
		return "", errors.New("auth fail")
	}
	token := l.getToken(ctx, phone)
	auth := &redis_model.Auth{
		Phone:    phone,
		ID:       user.ID,
		User:     user.User,
		Username: user.Username,
		RealName: user.RealName,
		Role:     user.Role,
		Email:    user.Email,
		Token:    token,
	}
	if err := l.setSession(ctx, phone, auth); err != nil {
		return "", err
	}
	return token, nil
}

func (l *loginAuth) setSession(ctx context.Context, phone string, auth *redis_model.Auth) error {
	if authJson, err := json.Marshal(auth); err == nil {
		err = redis.Set(ctx, l.getRedisKey(phone), string(authJson), l.sessionTTL)
		if err == nil {
			return err
		}
	}
	return nil
}

func (l *loginAuth) getSessionCode(ctx context.Context, phone string) (*string, error) {
	value, err := redis.Get(ctx, l.getRedisKey(phone))
	if err != nil {
		if err == consts.RedisNil {
			return nil, fmt.Errorf("not found in redis,phone:%+v", phone)
		}
		return nil, err
	}
	return &value, nil
}

func (l *loginAuth) getSession(ctx context.Context, phone string) (*redis_model.Auth, error) {
	value, err := redis.Get(ctx, l.getRedisKey(phone))
	if err != nil {
		if err == consts.RedisNil {
			return nil, fmt.Errorf("not found in redis,phone:%+v", phone)
		}
		return nil, err
	}
	auth := new(redis_model.Auth)
	if err = json.Unmarshal([]byte(value), auth); err != nil {
		return nil, err
	}
	return auth, nil
}
func (l *loginAuth) getToken(ctx context.Context, phone string) string {
	timeSeed := strconv.FormatInt(time.Now().Unix(), 10)
	token := phone + "." + timeSeed + "." + util.MD5(phone, timeSeed, consts.AuthSalt)
	return token
}
func (l *loginAuth) parseToken(ctx context.Context, token string) (string, error) {
	parts := strings.Split(token, ".")
	if len(parts) == 3 {
		phone := parts[0]
		timeSeed := parts[1]
		if parts[2] == util.MD5(phone, timeSeed, consts.AuthSalt) {
			return phone, nil
		}
	}
	return "", errors.New("token invalid")
}
func (l *loginAuth) encryptPassword(password string) string {
	return util.MD5(password)
}
func (l *loginAuth) getRedisKey(key string) string {
	return fmt.Sprintf("%s%s", consts.SessionRedisPrefix, key)
}