package user

import (
	"SciencesServer/app/api/admin/model"
	"SciencesServer/app/basic/controller"
	model2 "SciencesServer/app/common/model"
	"SciencesServer/app/service"
	"SciencesServer/app/session"
	"SciencesServer/config"
	"SciencesServer/serve/logger"
	"SciencesServer/serve/orm"
	"SciencesServer/utils"
	"errors"
	"fmt"
	"gorm.io/gorm"
	"strings"
	"time"
)

type Instance struct{ *session.Admin }

type InstanceHandle func(session *session.Admin) *Instance

type (
	// InstanceInfo 基本信息
	InstanceInfo struct {
		ID string `json:"id"`
		InstanceUserInfo
		Gender     model2.GenderKind           `json:"gender"`
		IsAdmin    model2.SysUserAdministrator `json:"is_admin"`
		Status     model2.SysUserStatus        `json:"status"`
		Department *InstanceDepartmentInfo     `json:"department"`
		Role       *InstanceRoleInfo           `json:"role"`
		CreatedAt  time.Time                   `json:"created_at"`
	}
	// InstanceUserInfo 用户信息
	InstanceUserInfo struct {
		UID    string `json:"uid"`
		Avatar string `json:"avatar"`
		Name   string `json:"name"`
		Email  string `json:"email"`
		Mobile string `json:"mobile"`
	}
	// InstanceDepartmentInfo 部门信息
	InstanceDepartmentInfo struct {
		ID   string `json:"id"`
		Name string `json:"name"`
	}
	// InstanceRoleInfo 角色信息
	InstanceRoleInfo struct {
		IDs   []string `json:"ids"`
		Names []string `json:"names"`
	}
)

// InstanceForm 表单信息
type InstanceForm struct {
	ID                                      uint64
	Account, Name, Mobile, Password, Remark string
	Gender                                  int
	DepartmentID                            uint64
	RoleIDs                                 []uint64
}

func (c *InstanceForm) sync(tx *gorm.DB, first bool, uid, tenantID uint64) error {
	var err error

	mSysUserDepartment := model.NewSysUserDepartment()
	mSysUserRole := model.NewSysUserRole()

	permission := service.NewPermission(
		service.WithAuthTenant(fmt.Sprintf("%d", tenantID)),
		service.WithAuthUser(fmt.Sprintf("%d", uid)),
	)
	if !first {
		if err = model2.DeleteWhere(mSysUserDepartment.SysUserDepartment, []*model2.ModelWhere{
			model2.NewWhere("uid", uid)}, tx); err != nil {
			return err
		}

		if err = model2.DeleteWhere(mSysUserRole.SysUserRole, []*model2.ModelWhere{
			model2.NewWhere("uid", uid)}, tx); err != nil {
			return err
		}
		go utils.TryCatch(func() {
			if _, err = permission.DeleteRolesForUser(false); err != nil {
				logger.ErrorF("Casbin 删除用户【%d】权限错误：%v", uid, err)
			}
		})
	}
	if c.DepartmentID > 0 {
		mSysUserDepartment.UID = uid
		mSysUserDepartment.DepartmentID = c.DepartmentID

		if err = model2.Create(mSysUserDepartment.SysUserDepartment, tx); err != nil {
			return err
		}
	}
	if len(c.RoleIDs) > 0 {
		roles := make([]*model2.SysUserRole, 0)

		rolesIDs := make([]string, 0)

		for _, v := range c.RoleIDs {
			roles = append(roles, &model2.SysUserRole{
				UID:    uid,
				RoleID: v,
			})
			rolesIDs = append(rolesIDs, fmt.Sprintf("%d", v))
		}
		if err := model2.Creates(mSysUserRole.SysUserRole, roles, tx); err != nil {
			return err
		}
		go utils.TryCatch(func() {
			permission.AddRole(rolesIDs)

			if _, err = permission.AddRoleForUser(); err != nil {
				logger.ErrorF("Casbin 给予用户【%d】权限错误：%v", uid, err)
			}
		})
	}
	return nil
}

// Info 用户信息
func (c *Instance) Info() (*InstanceUserInfo, error) {
	mSysUser := model.NewSysUser()

	_, err := model2.FirstWhere(mSysUser.SysUser, model2.NewWhere("uuid", c.UID))

	if err != nil {
		return nil, err
	}
	return &InstanceUserInfo{
		UID: mSysUser.UUIDString(), Avatar: mSysUser.Avatar, Name: mSysUser.Name,
		Email: mSysUser.Email, Mobile: mSysUser.Mobile,
	}, nil
}

// Index 列表信息
func (c *Instance) Index(name, mobile string, departmentIDs []uint64, status, page, pageSize int) (*controller.ReturnPages, error) {
	where := []*model2.ModelWhere{model2.NewWhere("u.tenant_id", c.TenantID)}

	if name != "" {
		where = append(where, model2.NewWhereLike("u.name", name))
	}
	if mobile != "" {
		where = append(where, model2.NewWhereLike("u.mobile", mobile))
	}
	if len(departmentIDs) > 0 {
		where = append(where, model2.NewWhereIn("d.id", departmentIDs))
	}
	if status > 0 {
		where = append(where, model2.NewWhere("u.status", status))
	}
	mSysUser := model.NewSysUser()

	var count int64

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

	if err != nil {
		return nil, err
	}
	list := make([]*InstanceInfo, 0)

	obj := new(model2.Model)

	for _, v := range out {
		data := &InstanceInfo{ID: v.GetEncodeID(),
			InstanceUserInfo: InstanceUserInfo{
				UID: v.UUIDString(), Avatar: v.Avatar, Name: v.Name, Email: v.Email, Mobile: v.Mobile,
			},
			Gender: v.Gender.Gender, IsAdmin: v.IsAdmin, Status: v.Status, CreatedAt: v.CreatedAt,
		}

		if v.DepartmentID > 0 {
			obj.ID = v.DepartmentID
			data.Department = &InstanceDepartmentInfo{
				ID:   obj.GetEncodeID(),
				Name: v.DepartmentName,
			}
		}
		if v.RoleIDs != "" {
			roleIDs := make([]string, 0)

			for _, v := range strings.Split(v.RoleIDs, "&&") {
				obj.ID = utils.StringToUnit64(v)
				roleIDs = append(roleIDs, obj.GetEncodeID())
			}
			roles := &InstanceRoleInfo{
				IDs:   roleIDs,
				Names: strings.Split(v.RoleNames, "&&"),
			}
			data.Role = roles
		}
		list = append(list, data)
	}
	return &controller.ReturnPages{Data: list, Count: count}, nil
}

// Add 添加用户
func (c *Instance) Add(params *InstanceForm) error {
	if utils.ValidateMobile(params.Mobile) {
		return errors.New("操作错误，手机号码格式错误")
	}
	mSysUser := model.NewSysUser()
	// 查询登录账户或手机号码是否注册
	var count int64

	err := model2.Count(mSysUser.SysUser, &count, model2.NewWhere("mobile", params.Mobile),
		model2.NewWhere("tenant_id", c.TenantID))

	if err != nil {
		return err
	}

	return orm.GetDB().Transaction(func(tx *gorm.DB) error {
		mSysUser.TenantID = c.TenantID
		mSysUser.Account = params.Account
		mSysUser.Name = params.Name
		mSysUser.Mobile = params.Mobile
		mSysUser.Gender.Gender = model2.GenderKind(params.Gender)
		mSysUser.Password = params.Password
		mSysUser.Remark = params.Remark

		if err = model2.Create(mSysUser.SysUser, tx); err != nil {
			return err
		}

		if err = params.sync(tx, true, mSysUser.UUID, c.TenantID); err != nil {
			return err
		}
		return nil
	})
}

// Edit 修改用户信息
func (c *Instance) Edit(params *InstanceForm) error {
	mSysUser := model.NewSysUser()
	mSysUser.ID = params.ID

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

	if err != nil {
		return nil
	} else if !isExist {
		return errors.New("操作错误，用户信息不存在或已被删除")
	} else if c.TenantID > 0 && mSysUser.TenantID != c.TenantID {
		return errors.New("操作错误，无权限操作")
	}
	if mSysUser.Mobile != params.Mobile {
		if utils.ValidateMobile(params.Mobile) {
			return errors.New("操作错误，手机号码格式错误")
		}
		var count int64

		if err = model2.Count(mSysUser.SysUser, &count, model2.NewWhere("mobile", params.Mobile),
			model2.NewWhere("tenant_id", c.TenantID)); err != nil {
			return nil
		} else if count > 0 {
			return errors.New("操作错误，当前手机号码已注册")
		}
		mSysUser.Mobile = params.Mobile
	}
	mSysUser.Account = params.Account
	mSysUser.Name = params.Name
	mSysUser.Gender.Gender = model2.GenderKind(params.Gender)
	mSysUser.Remark = params.Remark

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

func (c *Instance) Password(id uint64, password, repeatPwd string) error {
	if password != repeatPwd {
		return errors.New("操作错误，两次密码输入不一致")
	}
	mSysUser := model.NewSysUser()

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

	if err != nil {
		return nil
	} else if !isExist {
		return errors.New("操作错误，用户信息不存在或已被删除")
	} else if c.TenantID > 0 && mSysUser.TenantID != c.TenantID {
		return errors.New("操作错误，无权限操作")
	}
	mSysUser.Password = password
	mSysUser.Pass()

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

// PasswordEdit 主动修改密码
func (c *Person) PasswordEdit(oldPassword, password, repeatPwd string) error {
	if password != repeatPwd {
		return errors.New("操作错误，两次密码输入不一致")
	}
	mSysUser := model.NewSysUser()

	_, err := model2.FirstField(mSysUser.SysUser, []string{"id", "uuid", "is_admin"}, model2.NewWhere("uuid", c.UID))

	if err != nil {
		return err
	}
	if !mSysUser.ValidatePassword(oldPassword) {
		return errors.New("操作错误，旧密码输入错误")
	}
	mSysUser.Password = password
	mSysUser.Pass()

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

func (c *Instance) Delete(id uint64) error {
	mSysUser := model.NewSysUser()
	mSysUser.ID = id

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

	if err != nil {
		return nil
	} else if !isExist {
		return errors.New("操作错误，用户信息不存在或已被删除")
	} else if c.TenantID > 0 && mSysUser.TenantID != c.TenantID {
		return errors.New("操作错误，无权限操作")
	} else if mSysUser.IsAdminUser() {
		return errors.New("操作错误，超管用户不允许删除")
	}
	if err = model2.Delete(mSysUser.SysUser); err != nil {
		return err
	}
	service.Publish(config.EventForRedisHashDestroy, config.RedisKeyForAccountAdmin, utils.UintToString(mSysUser.UUID))
	return nil
}

func NewInstance() InstanceHandle {
	return func(session *session.Admin) *Instance {
		return &Instance{Admin: session}
	}
}