package user

import (
	"SciencesServer/app/api/admin/controller"
	"SciencesServer/app/api/admin/model"
	model2 "SciencesServer/app/common/model"
	"SciencesServer/app/service"
	"SciencesServer/config"
	"SciencesServer/utils"
	"errors"
	"time"
)

type Instance struct{ *controller.Platform }

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

type (
	// InstanceInfo 基本信息
	InstanceInfo struct {
		ID string `json:"id"`
		InstanceUserInfo
		Gender    model2.GenderKind           `json:"gender"`
		IsAdmin   model2.SysUserAdministrator `json:"is_admin"`
		CreatedAt time.Time                   `json:"created_at"`
	}
	// InstanceUserInfo 用户信息
	InstanceUserInfo struct {
		UID    string `json:"uid"`
		Name   string `json:"name"`
		Email  string `json:"email"`
		Mobile string `json:"mobile"`
	}
)

// InstanceForm 表单信息
type InstanceForm struct {
	ID                                      uint64 // 租户用户主键ID
	Account, Name, Mobile, Password, Remark string
	Gender                                  int
	Departments, Roles                      []uint64
}

// 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(), Name: mSysUser.Name, Email: mSysUser.Email, Mobile: mSysUser.Mobile,
	}, nil
}

// Index 列表信息
func (c *Instance) Index(name, mobile string, status, page, pageSize int) (*controller.ReturnPages, error) {
	where := []*model2.ModelWhereOrder{&model2.ModelWhereOrder{
		Where: model2.NewWhere("tenant_id", c.TenantID),
		Order: model2.NewOrder("id", model2.OrderModeToDesc),
	}}
	if name != "" {
		where = append(where, &model2.ModelWhereOrder{
			Where: model2.NewWhereLike("name", name),
		})
	}
	if mobile != "" {
		where = append(where, &model2.ModelWhereOrder{
			Where: model2.NewWhereLike("mobile", mobile),
		})
	}
	if status > 0 {
		where = append(where, &model2.ModelWhereOrder{
			Where: model2.NewWhere("status", status),
		})
	}
	mSysUser := model.NewSysUser()

	out := make([]*model2.SysUser, 0)

	var count int64

	if err := model2.PagesFields(mSysUser.SysUser, out, []string{"id", "uid", "account", "name", "mobile", "gender",
		"is_admin", "created_at"}, page, pageSize, &count, where...); err != nil {
		return nil, err
	}
	list := make([]*InstanceInfo, 0)

	for _, v := range out {
		list = append(list, &InstanceInfo{ID: v.GetEncodeID(),
			InstanceUserInfo: InstanceUserInfo{
				UID:    v.UUIDString(),
				Name:   v.Name,
				Email:  v.Email,
				Mobile: v.Mobile,
			},
			Gender:    v.Gender.Gender,
			IsAdmin:   v.IsAdmin,
			CreatedAt: v.CreatedAt,
		})
	}
	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
	}
	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

	return model2.Create(mSysUser.SysUser)
}

// 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 model2.Updates(mSysUser.SysUser, mSysUser.SysUser)
}

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 *service.Session) *Instance {
		return &Instance{Platform: &controller.Platform{Session: session}}
	}
}