package user

import (
	model2 "ArmedPolice/app/common/model"
	"ArmedPolice/app/controller/basic"
	"ArmedPolice/app/model"
	"ArmedPolice/app/service"
	"ArmedPolice/config"
	"ArmedPolice/serve/orm"
	"ArmedPolice/utils"
	"errors"
	"gorm.io/gorm"
	"time"
)

type Instance struct{ *service.Session }

type InstanceHandle func(session *service.Session) *Instance

type (
	// InstanceBasic 基本信息
	InstanceBasic struct {
		Name       string `json:"name"`
		Avatar     string `json:"avatar"`
		TenantName string `json:"tenant_name"`
	}
	// InstanceInfo 用户信息
	InstanceInfo struct {
		ID string `json:"id"`
		*model.SysUserInfo
	}
	// InstanceDetailInfo 详细信息
	InstanceDetailInfo struct {
		ID string `json:"id"`
		*model2.SysUser
		Roles []*InstanceRoleInfo `json:"roles"`
	}
	// InstanceRoleInfo 角色信息
	InstanceRoleInfo struct {
		ID string `json:"id"`
		*model.SysUserRoleInfo
	}
	// InstanceParams 参数信息
	InstanceParams struct {
		ID, TenantID                                    uint64
		Account, Name, Avatar, Mobile, Password, Remark string
		Gender, Status                                  int
		RoleIDs                                         []uint64
	}
	// InstanceBasicInfo 基本信息
	InstanceBasicInfo struct {
		UUID string `json:"id"` // 别名更改为ID
		Name string `json:"name"`
	}
)

// roleHandle 角色处理
func (c *InstanceParams) roleHandle(tx *gorm.DB, uid uint64) error {
	mSysUserRole := model.NewSysUserRole()

	err := model2.DeleteWhere(mSysUserRole.SysUserRole,
		[]*model2.ModelWhere{model2.NewWhere("uid", uid)}, tx)
	if err != nil {
		return err
	}
	roles := make([]*model2.SysUserRole, 0)
	obj := make([]string, 0)

	mark := make(map[uint64]uint64, 0)

	for _, v := range c.RoleIDs {
		if _, has := mark[v]; has {
			continue
		}
		obj = append(obj, utils.UintToString(v))

		roles = append(roles, &model2.SysUserRole{
			UID: uid, RoleID: v,
		})
		mark[v] = v
	}
	if err = model2.Creates(mSysUserRole.SysUserRole, roles, tx); err != nil {
		return err
	}
	return nil
}

// Info 基本信息
func (c *Instance) Info() *InstanceBasic {
	out := &InstanceBasic{Name: c.Name, Avatar: c.Avatar}

	if c.TenantID > 0 {
		mSysTenant := model.NewSysTenant()
		mSysTenant.ID = c.TenantID
		_, _ = model2.FirstField(mSysTenant.SysTenant, []string{"id", "name"})
		out.TenantName = mSysTenant.Name
	}
	return out
}

// Select 筛选信息
func (c *Instance) Select() ([]*InstanceBasicInfo, error) {
	mSysUser := model.NewSysUser()

	out := make([]*InstanceBasicInfo, 0)

	if err := model2.ScanFields(mSysUser.SysUser, &out, []string{"uuid", "name"}); err != nil {
		return nil, err
	}
	return out, nil
}

// List 列表信息
func (c *Instance) List(name, mobile string, tenantID uint64, page, pageSize int) (*basic.PageDataResponse, error) {
	mSysUser := model.NewSysUser()

	where := make([]*model2.ModelWhere, 0)

	if name != "" {
		where = append(where, model2.NewWhereLike("u.name", name))
	}
	if mobile != "" {
		where = append(where, model2.NewWhereLike("u.mobile", mobile))
	}
	if tenantID > 0 {
		where = append(where, model2.NewWhere("u.tenant_id", tenantID))
	}
	var count int64

	out, err := mSysUser.Users(page, pageSize, &count)

	if err != nil {
		return nil, err
	}

	list := make([]*InstanceInfo, 0)

	mImage := new(model2.Image)

	for _, v := range out {
		mImage.Image = v.Avatar
		v.Avatar = mImage.Analysis(config.SystemConfig[config.Domain].(string))
		list = append(list, &InstanceInfo{ID: v.GetEncodeID(), SysUserInfo: v})
	}
	return &basic.PageDataResponse{Data: list, Count: count}, nil
}

// Detail 详细信息
func (*Instance) Detail(id uint64) (*InstanceDetailInfo, error) {
	mSysUser := model.NewSysUser()
	mSysUser.ID = id

	isExist, err := model2.FirstWhere(mSysUser.SysUser)

	if err != nil {
		return nil, err
	} else if !isExist {
		return nil, err
	}
	mSysUserRole := model.NewSysUserRole()

	roles := make([]*model.SysUserRoleInfo, 0)

	if roles, err = mSysUserRole.Roles(mSysUser.UUID); err != nil {
		return nil, err
	}
	out := &InstanceDetailInfo{
		ID:      mSysUser.GetEncodeID(),
		SysUser: mSysUser.SysUser,
		Roles:   make([]*InstanceRoleInfo, 0),
	}
	for _, v := range roles {
		mSysUserRole.ID = v.ID
		out.Roles = append(out.Roles, &InstanceRoleInfo{
			ID:              mSysUserRole.GetEncodeID(),
			SysUserRoleInfo: v,
		})
	}
	return out, nil
}

// Form 数据操作
func (c *Instance) Form(params *InstanceParams) error {
	mSysUser := model.NewSysUser()

	if params.ID > 0 {
		mSysUser.ID = params.ID

		isExist, err := model2.FirstField(mSysUser.SysUser, []string{"id", "name", "mobile"})

		if err != nil {
			return err
		} else if !isExist {
			return errors.New("操作错误，用户信息不存在或已被删除")
		}
		if mSysUser.Mobile != params.Mobile {
			var count int64

			if err = model2.Count(mSysUser.SysUser, &count, model2.NewWhere("mobile", params.Mobile)); err != nil {
				return err
			} else if count > 0 {
				return errors.New("操作错误，该手机号已被注册")
			}
		}
		return orm.GetDB().Transaction(func(tx *gorm.DB) error {
			if err = model2.Updates(mSysUser.SysUser, map[string]interface{}{
				"tenant_id": params.TenantID, "name": params.Name, "mobile": params.Mobile, "avatar": params.Avatar, "gender": params.Gender,
				"status": params.Status, "remark": params.Remark, "updated_at": time.Now(),
			}, tx); err != nil {
				return err
			}
			if err = params.roleHandle(tx, mSysUser.UUID); err != nil {
				return err
			}
			return nil
		})
	}
	if params.Password == "" {
		return errors.New("操作错误，密码不可为空")
	}
	var count int64

	err := model2.Count(mSysUser.SysUser, &count, model2.NewWhere("account", params.Account))

	if err != nil {
		return err
	} else if count > 0 {
		return errors.New("操作错误，该账户名已被注册")
	}
	if err = model2.Count(mSysUser.SysUser, &count, model2.NewWhere("mobile", params.Mobile)); err != nil {
		return err
	} else if count > 0 {
		return errors.New("操作错误，该手机号已被注册")
	}
	mSysUser.TenantID = params.TenantID
	mSysUser.Account = params.Account
	mSysUser.Name = params.Name
	mSysUser.Mobile = params.Mobile
	mSysUser.Avatar = params.Avatar
	mSysUser.Password = params.Password
	mSysUser.Gender.Gender = model2.GenderKind(params.Gender)
	mSysUser.Status = model2.SysUserStatus(params.Status)
	mSysUser.Remark = params.Remark

	return orm.GetDB().Transaction(func(tx *gorm.DB) error {
		if err = model2.Create(mSysUser.SysUser, tx); err != nil {
			return err
		}
		if err = params.roleHandle(tx, mSysUser.UUID); err != nil {
			return err
		}
		return nil
	})
}

// Delete 删除信息
func (c *Instance) Delete(id uint64) error {
	mSysUser := model.NewSysUser()
	mSysUser.ID = id
	return model2.Delete(mSysUser.SysUser)
}

// PasswordQuick 快速设置密码
func (c *Instance) PasswordQuick(id uint64, password string) error {
	mSysUser := model.NewSysUser()
	mSysUser.ID = id
	mSysUser.Password = password
	mSysUser.Pass()

	if err := model2.Updates(mSysUser.SysUser, map[string]interface{}{
		"password": mSysUser.Password, "salt": mSysUser.Salt, "updated_at": time.Now(),
	}); err != nil {
		return err
	}
	return nil
}

// PasswordTradition 传统设置密码
func (c *Instance) PasswordTradition(id uint64, originalPwd, password, repeatPwd string) error {
	if password != repeatPwd {
		return errors.New("操作错误，密码输入不正确")
	}
	mSysUser := model.NewSysUser()
	mSysUser.ID = id

	isExist, err := model2.FirstField(mSysUser.SysUser, []string{"id", "password", "salt"})

	if err != nil {
		return err
	} else if !isExist {
		return errors.New("操作错误，用户信息不存在或已被删除")
	}
	if !mSysUser.ValidatePassword(originalPwd) {
		return errors.New("操作错误，旧密码不正确")
	}
	mSysUser.Password = password
	mSysUser.Pass()

	if err := model2.Updates(mSysUser.SysUser, map[string]interface{}{
		"password": mSysUser.Password, "salt": mSysUser.Salt, "updated_at": time.Now(),
	}); err != nil {
		return err
	}
	return nil
}

// Status 状态处理
func (c *Instance) Status(id uint64, status model2.SysUserStatus) error {
	mSysUser := model.NewSysUser()
	mSysUser.ID = id

	if err := model2.Updates(mSysUser.SysUser, map[string]interface{}{
		"status": status, "updated_at": time.Now(),
	}); err != nil {
		return err
	}
	return nil
}

func NewInstance() InstanceHandle {
	return func(session *service.Session) *Instance {
		return &Instance{session}
	}
}