package system

import (
	"context"
	"encoding/json"
	"errors"
	"time"

	"management/internal/db/model/dto"
	db "management/internal/db/sqlc"
	"management/internal/erpserver/model/req"
	"management/internal/global/know"
	"management/internal/pkg/crypto"
	"management/internal/pkg/session"
)

// UserBiz 定义处理用户请求所需的方法.
type UserBiz interface {
	Create(ctx context.Context, req *db.CreateSysUserParams) (*db.SysUser, error)
	Update(ctx context.Context, req *db.UpdateSysUserParams) (*db.SysUser, error)
	List(ctx context.Context, q dto.SearchDto) ([]*db.ListSysUserConditionRow, int64, error)
	Get(ctx context.Context, id int32) (*db.SysUser, error)

	UserExpansion
}

// UserExpansion 定义用户操作的扩展方法.
type UserExpansion interface {
	Login(ctx context.Context, req *req.Login) error
}

// userBiz 是 UserBiz 接口的实现.
type userBiz struct {
	store   db.Store
	session session.ISession
}

// 确保 userBiz 实现了 UserBiz 接口.
var _ UserBiz = (*userBiz)(nil)

func NewUser(store db.Store, session session.ISession) *userBiz {
	return &userBiz{
		store:   store,
		session: session,
	}
}

func (b *userBiz) Create(ctx context.Context, req *db.CreateSysUserParams) (*db.SysUser, error) {
	return b.store.CreateSysUser(ctx, req)
}

func (b *userBiz) Update(ctx context.Context, req *db.UpdateSysUserParams) (*db.SysUser, error) {
	return b.store.UpdateSysUser(ctx, req)
}

func (b *userBiz) List(ctx context.Context, q dto.SearchDto) ([]*db.ListSysUserConditionRow, int64, error) {
	count, err := b.store.CountSysUserCondition(ctx, &db.CountSysUserConditionParams{
		IsStatus: q.SearchStatus != 9999,
		Status:   int32(q.SearchStatus),
		IsID:     q.SearchID != 0,
		ID:       int32(q.SearchID),
		Username: q.SearchName,
		Email:    q.SearchEmail,
	})
	if err != nil {
		return nil, 0, err
	}

	users, err := b.store.ListSysUserCondition(ctx, &db.ListSysUserConditionParams{
		IsStatus: q.SearchStatus != 9999,
		Status:   int32(q.SearchStatus),
		IsID:     q.SearchID != 0,
		ID:       int32(q.SearchID),
		Username: q.SearchName,
		Email:    q.SearchEmail,
		Skip:     (int32(q.Page) - 1) * int32(q.Rows),
		Size:     int32(q.Rows),
	})
	if err != nil {
		return nil, 0, err
	}

	return users, count, nil
}

func (b *userBiz) Get(ctx context.Context, id int32) (*db.SysUser, error) {
	return b.store.GetSysUser(ctx, id)
}

func (b *userBiz) Login(ctx context.Context, req *req.Login) error {
	log := &db.CreateSysUserLoginLogParams{
		CreatedAt:  time.Now(),
		Email:      req.Email,
		IsSuccess:  false,
		RefererUrl: req.Referrer,
		Url:        req.Url,
		Os:         req.Os,
		Ip:         req.Ip,
		Browser:    req.Browser,
	}

	user, err := b.store.GetSysUserByEmail(ctx, req.Email)
	if err != nil {
		log.Message = err.Error()
		_ = b.store.CreateSysUserLoginLog(ctx, log)
		return err
	}
	log.UserUuid = user.Uuid
	log.Username = user.Username

	err = crypto.BcryptComparePassword(user.HashedPassword, req.Password+user.Salt)
	if err != nil {
		log.Message = "compare password failed"
		_ = b.store.CreateSysUserLoginLog(ctx, log)
		return errors.New(log.Message)
	}

	// 登陆成功

	if user.RoleID == 0 {
		log.Message = "账号没有配置角色, 请联系管理员"
		_ = b.store.CreateSysUserLoginLog(ctx, log)
		return errors.New(log.Message)
	}

	sysRole, err := b.store.GetSysRole(ctx, user.RoleID)
	if err != nil {
		log.Message = "账号配置的角色错误, 请联系管理员"
		_ = b.store.CreateSysUserLoginLog(ctx, log)
		return errors.New(log.Message)
	}

	auth := dto.AuthorizeUser{
		ID:       user.ID,
		Uuid:     user.Uuid,
		Email:    user.Email,
		Username: user.Username,
		RoleID:   sysRole.ID,
		RoleName: sysRole.Name,
		OS:       log.Os,
		IP:       log.Ip,
		Browser:  log.Browser,
	}

	gob, err := json.Marshal(auth)
	if err != nil {
		log.Message = err.Error()
		_ = b.store.CreateSysUserLoginLog(ctx, log)
		return err
	}

	b.session.Put(ctx, know.StoreName, gob)

	log.IsSuccess = true
	log.Message = "登陆成功"
	_ = b.store.CreateSysUserLoginLog(ctx, log)
	return nil
}