package admin

import (
	"context"
	"github.com/gogf/gf/v2/database/gdb"
	"github.com/gogf/gf/v2/os/glog"
	"server/internal/consts"
	"server/internal/dao"
	"server/internal/model"
	"server/internal/model/do"
	"server/internal/model/entity"
	"server/internal/service"
	"server/utility/ecode"
	utility "server/utility/encrypt"
	"server/utility/jwt"
)

type sAdmin struct {
}

func New() service.IAdmin {
	return &sAdmin{}
}

func checkAdmin() {
	ctx := context.Background()

	if err := dao.Roles.Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
		// 检查角色是否存在
		exist, err := tx.Model(dao.Roles.Table()).Where(do.Roles{Code: consts.AdminRoleCode}).Exist()
		if err != nil {
			return err
		}
		var roleId int64
		if !exist {
			roleId, err = tx.Model(dao.Roles.Table()).InsertAndGetId(do.Roles{
				Name:        "系统管理员",
				Code:        consts.AdminRoleCode,
				Description: "管理员角色",
				Status:      consts.RoleEnable,
				IsDeletable: false,
			})
		} else {
			value, err := tx.Model(dao.Roles.Table()).Where(do.Roles{Code: consts.AdminRoleCode}).Fields(dao.Roles.Columns().Id).Value()
			if err != nil {
				return err
			}
			roleId = value.Int64()
		}

		// 检查管理员是否存在
		exist, err = tx.Model(dao.Admins.Table()).Where(do.Admins{Username: "admin"}).Exist()
		if err != nil {
			return err
		}
		if !exist {
			password, err := utility.EncryptPassword("Aa123456")
			if err != nil {
				return err
			}
			_, err = tx.Model(dao.Admins.Table()).InsertAndGetId(do.Admins{
				Username:     "admin",
				PasswordHash: password,
				RoleId:       roleId,
				Status:       1,
			})
			if err != nil {
				return err
			}
		}
		return nil
	}); err != nil {
		panic("初始化系统失败")
	}
	glog.Infof(ctx, "初始化管理员成功")
}

func init() {
	service.RegisterAdmin(New())
	go checkAdmin()
}
func (s *sAdmin) Login(ctx context.Context, in *model.AdminLoginIn) (out *model.LoginOut, err error) {
	exist, err := dao.Admins.Ctx(ctx).Exist(do.Admins{Username: in.Username})
	if err != nil {
		return nil, ecode.Fail.Sub("查询管理员失败")
	}
	if !exist {
		return nil, ecode.Params.Sub("该用户不存在")
	}
	var admin entity.Admins
	if err := dao.Admins.Ctx(ctx).Where(do.Admins{Username: in.Username}).Scan(&admin); err != nil {
		return nil, ecode.Fail.Sub("查询管理员失败")
	}
	if !utility.ComparePassword(admin.PasswordHash, in.Password) {
		return nil, ecode.Auth
	}
	value, err := dao.Roles.Ctx(ctx).WherePri(admin.RoleId).Fields(dao.Roles.Columns().Code).Value()
	if err != nil {
		return nil, ecode.Fail.Sub("查询角色失败")
	}
	token, err := jwt.GenerateToken(&jwt.TokenIn{UserId: admin.Id, Role: value.String()})
	if err != nil {
		return nil, ecode.Fail.Sub("生成token失败")
	}

	out = &model.LoginOut{
		Token: token,
	}
	return
}

func (s *sAdmin) Info(ctx context.Context, in *model.AdminInfoIn) (out *model.AdminInfoOut, err error) {
	exist, err := dao.Admins.Ctx(ctx).WherePri(in.Id).Exist()
	if err != nil {
		return nil, ecode.Fail.Sub("查询管理员失败")
	}
	if !exist {
		return nil, ecode.Params.Sub("该用户不存在")
	}
	var admin entity.Admins
	if err := dao.Admins.Ctx(ctx).WherePri(in.Id).Scan(&admin); err != nil {
		return nil, ecode.Fail.Sub("查询管理员失败")
	}
	out = &model.AdminInfoOut{
		Id:       admin.Id,
		Username: admin.Username,
	}
	return
}