package user

import (
	"SciencesServer/app/api/admin/controller"
	model3 "SciencesServer/app/api/admin/model"
	model2 "SciencesServer/app/common/model"
	"SciencesServer/app/service"
	"SciencesServer/serve/orm"
	"SciencesServer/utils"
	"errors"
	"strings"
	"time"

	"gorm.io/gorm"
)

type Instance struct{ *controller.Platform }

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

type (
	// InstanceInfo 基本信息
	InstanceInfo struct {
		UID    string `json:"uid"`
		Name   string `json:"name"`
		Email  string `json:"email"`
		Mobile string `json:"mobile"`
		Remark string `json:"remark"`
	}
	// InstanceUserInfo 用户信息
	InstanceUserInfo struct {
		*model3.SysUserTenantUser
		UID string `json:"uid"`
	}
)

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

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

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

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

// List 列表信息
func (c *Instance) List(name, mobile string, status, page, pageSize int) (*controller.ReturnPages, error) {
	mSysUserTenant := model3.NewSysUserTenant()

	where := []*model2.ModelWhere{model2.NewWhere("u_t.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 status > 0 {
		where = append(where, model2.NewWhere("u_t.status", status))
	}
	var count int64

	out, err := mSysUserTenant.User(page, pageSize, &count, where...)

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

	for _, v := range out {
		list = append(list, &InstanceUserInfo{SysUserTenantUser: v, UID: utils.UintToString(v.UID)})
	}
	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 := model3.NewSysUser()
	// 查询登录账户或手机号码是否注册
	var count int64

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

	if err != nil {
		return err
	}
	if err = model2.Count(mSysUser.SysUser, &count, model2.NewWhere("mobile", params.Mobile)); 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 orm.GetDB().Transaction(func(tx *gorm.DB) error {
		if err = model2.Create(mSysUser.SysUser, tx); err != nil {
			return err
		}
		mSysUserTenant := model3.NewSysUserTenant()
		mSysUserTenant.TenantID = c.TenantID
		mSysUserTenant.UID = mSysUser.UUID
		if len(params.Departments) > 0 {
			mSysUserTenant.Department = strings.Join(utils.ArrayStrings(params.Departments), ",")
		}
		if len(params.Roles) > 0 {
			mSysUserTenant.Role = strings.Join(utils.ArrayStrings(params.Roles), ",")
		}
		mSysUserTenant.Identity = model2.SysUserTenantIdentityForSystemUser

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

// Edit 修改用户信息
func (c *Instance) Edit(params *InstanceForm) error {
	if utils.ValidateMobile(params.Mobile) {
		return errors.New("手机号码格式错误")
	}
	mSysUserTenant := model3.NewSysUserTenant()
	mSysUserTenant.ID = params.ID

	isExist, err := model2.FirstField(mSysUserTenant.SysUserTenant, []string{"id", "tenant_id", "identity"})

	if err != nil {
		return nil
	} else if !isExist {
		return errors.New("用户信息不存在")
	} else if mSysUserTenant.TenantID != c.TenantID {
		return errors.New("不可修改他人用户信息")
	}
	// 查询用户信息
	mSysUser := model3.NewSysUser()

	if isExist, err = model2.FirstWhere(mSysUser.SysUser, model2.NewWhere("uuid", mSysUserTenant.UID)); err != nil {
		return err
	} else if !isExist {
		return errors.New("用户信息不存在")
	}
	if params.Mobile != mSysUser.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("该手机号码已注册")
		}
	}
	now := time.Now()
	return orm.GetDB().Transaction(func(tx *gorm.DB) error {
		if err = model2.Updates(mSysUserTenant.SysUserTenant, map[string]interface{}{
			"department": strings.Join(utils.ArrayStrings(params.Departments), ","),
			"role":       strings.Join(utils.ArrayStrings(params.Roles), ","),
			"updated_at": now,
		}, tx); err != nil {
			return err
		}
		if err = model2.Updates(mSysUser.SysUser, map[string]interface{}{
			"name": params.Name, "mobile": params.Mobile, "gender": params.Gender, "remark": params.Remark, "updated_at": now,
		}, tx); err != nil {
			return err
		}
		return nil
	})
}

func (c *Instance) Password(id uint64, password, repeatPwd string) error {
	if password != repeatPwd {
		return errors.New("两次密码不一致")
	}
	mSysUserTenant := model3.NewSysUserTenant()
	mSysUserTenant.ID = id

	isExist, err := model2.FirstField(mSysUserTenant.SysUserTenant, []string{"id", "tenant_id", "identity"})

	if err != nil {
		return nil
	} else if !isExist {
		return errors.New("用户信息不存在")
	} else if mSysUserTenant.TenantID != c.TenantID {
		return errors.New("不可修改他人用户密码")
	}
	mSysUser := model3.NewSysUser()
	mSysUser.Password = password
	mSysUser.Pass()

	if err = model2.UpdatesWhere(mSysUser.SysUser, map[string]interface{}{
		"password": mSysUser.Password, "salt": mSysUser.Salt, "updated_at": time.Now(),
	}, []*model2.ModelWhere{
		model2.NewWhere("uuid", mSysUserTenant.UID),
	}); err != nil {
		return err
	}
	return nil
}

func (c *Instance) Delete(id uint64) error {
	mSysUserTenant := model3.NewSysUserTenant()
	mSysUserTenant.ID = id

	isExist, err := model2.FirstField(mSysUserTenant.SysUserTenant, []string{"id", "tenant_id", "identity"})

	if err != nil {
		return nil
	} else if !isExist {
		return errors.New("用户信息不存在")
	} else if mSysUserTenant.TenantID != c.TenantID {
		return errors.New("不可删除他人用户信息")
	}
	return orm.GetDB().Transaction(func(tx *gorm.DB) error {
		if err = model2.Delete(mSysUserTenant.SysUserTenant, tx); err != nil {
			return err
		}
		mSysUser := model3.NewSysUser()

		if err = model2.DeleteWhere(mSysUser.SysUser, []*model2.ModelWhere{
			model2.NewWhere("uuid", mSysUserTenant.UID),
		}, tx); err != nil {
			return err
		}
		return nil
	})
}

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