package controllers

import (
	"encoding/json"
	"eta/eta_mini_crm/models"
	"eta/eta_mini_crm/models/request"
	"eta/eta_mini_crm/models/response"
	"eta/eta_mini_crm/utils"
	"fmt"
	"github.com/rdlucklib/rdluck_tools/paging"
	"strings"
	"time"
)

// UserLevelController 用户等级
type UserLevelController struct {
	BaseAuthController
}

// Add
// @Title 新增用户等级
// @Description 新增用户等级
// @Param	request	body request.UserLevelAddReq true "type json string"
// @Success 200 Ret=200 操作成功
// @router /level/add [post]
func (this *UserLevelController) Add() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req request.UserLevelAddReq
	if e := json.Unmarshal(this.Ctx.Input.RequestBody, &req); e != nil {
		br.Msg = "参数解析异常"
		br.ErrMsg = fmt.Sprintf("参数解析异常, %v", e)
		return
	}
	if req.LevelRank <= 0 {
		br.Msg = "请输入正确的等级"
		return
	}
	req.LevelName = strings.TrimSpace(req.LevelName)
	if req.LevelName == "" {
		br.Msg = "请输入等级名称"
		return
	}
	if len(req.ClassifyIds) == 0 {
		br.Msg = "请选择阅读权限"
		return
	}

	// 校验等级名称是否重复
	levelOb := new(models.UserLevel)
	//{
	//	cond := fmt.Sprintf(` AND %s = ?`, levelOb.Cols().LevelName)
	//	pars := make([]interface{}, 0)
	//	pars = append(pars, req.LevelName)
	//	exist, e := levelOb.GetItemByCondition(cond, pars, "")
	//	if e != nil && e.Error() != utils.ErrNoRow() {
	//		br.Msg = "操作失败"
	//		br.ErrMsg = fmt.Sprintf("获取同名用户等级失败, %v", e)
	//		return
	//	}
	//	if exist != nil && exist.UserLevelId > 0 {
	//		br.Msg = "等级名称已存在"
	//		return
	//	}
	//}

	levelOb.LevelRank = req.LevelRank
	levelOb.LevelName = req.LevelName
	levelOb.State = req.State
	levelOb.SysUserId = sysUser.SysUserId
	levelOb.SysUserRealName = sysUser.SysRealName
	levelOb.CreateTime = time.Now().Local()
	levelOb.ModifyTime = time.Now().Local()
	if e := levelOb.Create(); e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = fmt.Sprintf("新增用户等级失败, %v", e)
		return
	}
	mappings := make([]*models.UserLevelMapping, 0)
	classifyIds := make([]int, 0)
	for _, v := range req.ClassifyIds {
		m := new(models.UserLevelMapping)
		m.ClassifyId = v
		m.UserLevelId = levelOb.UserLevelId
		m.CreateTime = time.Now().Local()
		mappings = append(mappings, m)
		classifyIds = append(classifyIds, m.ClassifyId)
	}
	mappingOb := new(models.UserLevelMapping)
	if e := mappingOb.CreateMulti(mappings); e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = fmt.Sprintf("新增用户等级权限失败, %v", e)
		return
	}
	resp := levelOb.Format2Item()
	resp.ClassifyIds = classifyIds

	br.Data = resp
	br.Ret = 200
	br.Msg = "操作成功"
	br.Success = true
}

// Edit
// @Title 编辑用户等级
// @Description 编辑用户等级
// @Param	request	body request.UserLevelEditReq true "type json string"
// @Success 200 Ret=200 操作成功
// @router /level/edit [post]
func (this *UserLevelController) Edit() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req request.UserLevelEditReq
	if e := json.Unmarshal(this.Ctx.Input.RequestBody, &req); e != nil {
		br.Msg = "参数解析异常"
		br.ErrMsg = fmt.Sprintf("参数解析异常, %v", e)
		return
	}
	if req.UserLevelId <= 0 {
		br.Msg = "参数有误"
		return
	}
	if req.LevelRank <= 0 {
		br.Msg = "请输入正确的等级"
		return
	}
	req.LevelName = strings.TrimSpace(req.LevelName)
	if req.LevelName == "" {
		br.Msg = "请输入等级名称"
		return
	}
	if len(req.ClassifyIds) == 0 {
		br.Msg = "请选择阅读权限"
		return
	}

	// 校验是否已删除
	levelOb := new(models.UserLevel)
	levelItem, e := levelOb.GetItemById(req.UserLevelId)
	if e != nil {
		if e.Error() == utils.ErrNoRow() {
			br.Msg = "等级不存在，请刷新页面"
			return
		}
		br.Msg = "操作失败"
		br.ErrMsg = fmt.Sprintf("获取用户等级失败, %v", e)
		return
	}
	originName := levelItem.LevelName

	// 校验等级名称是否重复
	//{
	//	cond := fmt.Sprintf(` AND %s <> ? AND %s = ?`, levelOb.Cols().PrimaryId, levelOb.Cols().LevelName)
	//	pars := make([]interface{}, 0)
	//	pars = append(pars, req.UserLevelId, req.LevelName)
	//	exist, e := levelOb.GetItemByCondition(cond, pars, "")
	//	if e != nil && e.Error() != utils.ErrNoRow() {
	//		br.Msg = "操作失败"
	//		br.ErrMsg = fmt.Sprintf("获取同名用户等级失败, %v", e)
	//		return
	//	}
	//	if exist != nil && exist.UserLevelId > 0 {
	//		br.Msg = "等级名称已存在"
	//		return
	//	}
	//}

	updateCols := []string{levelOb.Cols().LevelRank, levelOb.Cols().LevelName, levelOb.Cols().State, levelOb.Cols().ModifyTime}
	levelItem.LevelRank = req.LevelRank
	levelItem.LevelName = req.LevelName
	levelItem.State = req.State
	levelItem.ModifyTime = time.Now().Local()
	if e := levelItem.Update(updateCols); e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = fmt.Sprintf("更新用户等级失败, %v", e)
		return
	}

	// 移除并新增权限
	mappingOb := new(models.UserLevelMapping)
	cond := fmt.Sprintf(`%s = ?`, mappingOb.Cols().UserLevelId)
	pars := make([]interface{}, 0)
	pars = append(pars, levelItem.UserLevelId)
	if e = mappingOb.RemoveByCondition(cond, pars); e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = fmt.Sprintf("移除用户等级权限失败, %v", e)
		return
	}
	mappings := make([]*models.UserLevelMapping, 0)
	classifyIds := make([]int, 0)
	for _, v := range req.ClassifyIds {
		m := new(models.UserLevelMapping)
		m.ClassifyId = v
		m.UserLevelId = levelItem.UserLevelId
		m.CreateTime = time.Now().Local()
		mappings = append(mappings, m)
		classifyIds = append(classifyIds, m.ClassifyId)
	}
	if e = mappingOb.CreateMulti(mappings); e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = fmt.Sprintf("新增用户等级权限失败, %v", e)
		return
	}

	// 如果名称有更改，更新冗余字段
	if originName != req.LevelName {
		go func() {
			usersOb := new(models.Users)
			if e = usersOb.UpdateUserLevelName(req.UserLevelId, req.LevelName); e != nil {
				utils.FileLog.Info("更新users表用户等级名称失败, %v", e)
			}
			companyOb := new(models.Company)
			if e = companyOb.UpdateUserLevelName(req.UserLevelId, req.LevelName); e != nil {
				utils.FileLog.Info("更新company表用户等级名称失败, %v", e)
			}
		}()
	}
	resp := levelItem.Format2Item()
	resp.ClassifyIds = classifyIds

	br.Data = resp
	br.Ret = 200
	br.Msg = "操作成功"
	br.Success = true
}

// Remove
// @Title 删除用户等级
// @Description 删除用户等级
// @Param	request	body request.UserLevelRemoveReq true "type json string"
// @Success 200 Ret=200 操作成功
// @router /level/remove [post]
func (this *UserLevelController) Remove() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req request.UserLevelRemoveReq
	if e := json.Unmarshal(this.Ctx.Input.RequestBody, &req); e != nil {
		br.Msg = "参数解析异常"
		br.ErrMsg = fmt.Sprintf("参数解析异常, %v", e)
		return
	}
	if req.UserLevelId <= 0 {
		br.Msg = "参数有误"
		br.ErrMsg = fmt.Sprintf("用户等级ID参数有误, UserId: %d", req.UserLevelId)
		return
	}

	levelOb := new(models.UserLevel)
	levelItem, e := levelOb.GetItemById(req.UserLevelId)
	if e != nil {
		if e.Error() == utils.ErrNoRow() {
			br.Msg = "等级不存在，请刷新页面"
			return
		}
		br.Msg = "操作失败"
		br.ErrMsg = fmt.Sprintf("获取用户等级失败, %v", e)
		return
	}

	// 是否关联用户/机构
	usersOb := new(models.Users)
	cond := fmt.Sprintf(` AND %s = ?`, usersOb.Cols().UserLevelId)
	pars := make([]interface{}, 0)
	pars = append(pars, req.UserLevelId)
	count, e := usersOb.GetCountByCondition(cond, pars)
	if e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = fmt.Sprintf("获取等级关联用户失败, %v", e)
		return
	}
	if count > 0 {
		br.Msg = "该等级已关联用户，删除失败"
		return
	}
	companyOb := new(models.Company)
	count, e = companyOb.GetCountByCondition(cond, pars)
	if e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = fmt.Sprintf("获取等级关联机构失败, %v", e)
		return
	}
	if count > 0 {
		br.Msg = "该等级已关联用户，删除失败"
		return
	}

	// 删除用户等级和权限
	if e = levelItem.Remove(); e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = fmt.Sprintf("删除用户等级失败, %v", e)
		return
	}
	mappingOb := new(models.UserLevelMapping)
	cond = fmt.Sprintf(`%s = ?`, mappingOb.Cols().UserLevelId)
	pars = make([]interface{}, 0)
	pars = append(pars, levelItem.UserLevelId)
	if e = mappingOb.RemoveByCondition(cond, pars); e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = fmt.Sprintf("移除用户等级权限失败, %v", e)
		return
	}

	br.Ret = 200
	br.Msg = "操作成功"
	br.Success = true
}

// Detail
// @Title 用户等级详情
// @Description 用户等级详情
// @Param   UserLevelId  query  int  true  "用户等级ID"
// @Success 200 {object} models.UserLevelItem
// @router /level/detail [get]
func (this *UserLevelController) Detail() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	userLevelId, _ := this.GetInt("UserLevelId")
	if userLevelId <= 0 {
		br.Msg = "参数有误"
		br.ErrMsg = fmt.Sprintf("参数有误, %d", userLevelId)
		return
	}

	levelOb := new(models.UserLevel)
	levelItem, e := levelOb.GetItemById(userLevelId)
	if e != nil {
		if e.Error() == utils.ErrNoRow() {
			br.Msg = "等级不存在，请刷新页面"
			return
		}
		br.Msg = "获取失败"
		br.ErrMsg = fmt.Sprintf("获取用户等级失败, %v", e)
		return
	}
	resp := levelItem.Format2Item()

	// 关联权限
	mappingOb := new(models.UserLevelMapping)
	cond := fmt.Sprintf(` AND %s = ?`, mappingOb.Cols().UserLevelId)
	pars := make([]interface{}, 0)
	pars = append(pars, levelItem.UserLevelId)
	mappings, e := mappingOb.GetItemsByCondition(cond, pars, []string{}, "")
	if e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = fmt.Sprintf("获取用户等级关联权限失败, %v", e)
		return
	}
	for _, v := range mappings {
		resp.ClassifyIds = append(resp.ClassifyIds, v.ClassifyId)
	}

	br.Data = resp
	br.Ret = 200
	br.Msg = "获取成功"
	br.Success = true
}

// PageList
// @Title 用户等级列表-分页
// @Description 用户等级列表-分页
// @Param	request	body request.UserLevelListForm true "type json string"
// @Success 200 {object} response.UserLevelPageListResp
// @router /level/page_list [get]
func (this *UserLevelController) PageList() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	params := new(request.UserLevelListForm)
	if e := this.ParseForm(params); e != nil {
		br.Msg = "参数解析异常"
		br.ErrMsg = fmt.Sprintf("参数解析异常, %v", e)
		return
	}
	resp := new(response.UserLevelPageListResp)

	// 分页
	var startSize int
	if params.PageSize <= 0 {
		params.PageSize = utils.PageSize20
	}
	if params.CurrentIndex <= 0 {
		params.CurrentIndex = 1
	}
	startSize = utils.StartIndex(params.CurrentIndex, params.PageSize)

	// 查询列表
	levelOb := new(models.UserLevel)
	cond := ``
	pars := make([]interface{}, 0)
	if params.OnlyEnabled {
		cond += fmt.Sprintf(` AND %s = ?`, levelOb.Cols().State)
		pars = append(pars, models.UserLevelEnabled)
	}
	total, e := levelOb.GetCountByCondition(cond, pars)
	if e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = fmt.Sprintf("获取用户等级列表总数失败, %v", e)
		return
	}
	orderRule := fmt.Sprintf(`%s ASC, %s DESC`, levelOb.Cols().LevelRank, levelOb.Cols().CreateTime)
	list, e := levelOb.GetPageItemsByCondition(cond, pars, []string{}, orderRule, startSize, params.PageSize)
	if e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = fmt.Sprintf("获取用户等级列表失败, %v", e)
		return
	}
	respList := make([]*models.UserLevelItem, 0)
	for _, v := range list {
		respList = append(respList, v.Format2Item())
	}

	page := paging.GetPaging(params.CurrentIndex, params.PageSize, total)
	resp.Paging = page
	resp.List = respList
	br.Data = resp
	br.Ret = 200
	br.Msg = "获取成功"
	br.Success = true
}

// List
// @Title 用户等级列表
// @Description 用户等级列表
// @Param	request	body request.UserLevelListForm true "type json string"
// @Success 200 {object} response.UserLevelPageListResp
// @router /level/list [get]
func (this *UserLevelController) List() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	params := new(request.UserLevelListForm)
	if e := this.ParseForm(params); e != nil {
		br.Msg = "参数解析异常"
		br.ErrMsg = fmt.Sprintf("参数解析异常, %v", e)
		return
	}
	resp := make([]*models.UserLevelItem, 0)

	// 查询列表
	levelOb := new(models.UserLevel)
	cond := ``
	pars := make([]interface{}, 0)
	if params.OnlyEnabled {
		cond += fmt.Sprintf(` AND %s = ?`, levelOb.Cols().State)
		pars = append(pars, models.UserLevelEnabled)
	}
	orderRule := fmt.Sprintf(`%s ASC, %s DESC`, levelOb.Cols().LevelRank, levelOb.Cols().CreateTime)
	list, e := levelOb.GetItemsByCondition(cond, pars, []string{}, orderRule)
	if e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = fmt.Sprintf("获取用户等级列表失败, %v", e)
		return
	}
	for _, v := range list {
		resp = append(resp, v.Format2Item())
	}

	br.Data = resp
	br.Ret = 200
	br.Msg = "获取成功"
	br.Success = true
}