package controller

import (
	"designs/app/common/request"
	"designs/app/common/response"
	"designs/global"
	"designs/model"
	"designs/service"
	"designs/utils"
	"fmt"
	"github.com/gin-gonic/gin"
	"strings"
	"time"
)

var permissionToInterface = map[string][]string{
	"1": {"/property/imageList"},
	"2": {"/property/imageSet", "/property/imageDelete", "/property/upload", "/property/updateImageTags"},
	"3": {"/property/videoSet", "/property/videoDelete", "/property/updateVideoTags"},
	"4": {"/property/videoList"},
}

var permissions = map[int]string{
	1:   "图片查看",
	2:   "图片编辑",
	3:   "视频编辑",
	4:   "视频查看",
	999: "超级权限",
}

func CreateAdminUser(c *gin.Context) {
	form := request.Check(c, &struct {
		Account  string `json:"account" binding:"required"`
		Name     string `json:"name" binding:"required"`
		Identity int    `json:"identity" binding:"required"`
	}{})

	if form.Account == "admin" {
		response.Fail(c, 1001, "admin名称不可用")
		return
	}

	newPass := utils.RandomStringFast(10)

	now := model.XTime{
		Time: time.Now(),
	}
	newAdmin := model.AdminUser{
		Account:    form.Account,
		Name:       form.Name,
		IdentityId: form.Identity,
		Password:   newPass,
		CreatedAt:  now,
		UpdatedAt:  now,
	}
	err := global.App.DB.Table(model.TableAdminUser).Create(&newAdmin).Error
	if err != nil {
		response.Fail(c, 500, err.Error())
		return
	}

	//记录日志
	userId := c.GetInt("userId")
	err = service.SetActionLog("新增", userId, "管理员", newAdmin)
	if err != nil {
		response.Fail(c, 500, err.Error())
		return
	}

	response.Success(c, gin.H{
		"data": map[string]interface{}{
			"password": newPass,
			"account":  newAdmin.Account,
		},
	})
}

func AdminUserList(c *gin.Context) {
	form := request.Check(c, &struct {
		Limit    int    `form:"limit" json:"limit" binding:"required"`
		Offset   int    `form:"offset" json:"offset" binding:""`
		Search   string `form:"search" json:"search" binding:""`
		Identity []int  `form:"identity" json:"identity" binding:""`
		//Prop   string `form:"prop" json:"prop" binding:""`
		//Order  string `form:"order" json:"order" binding:""`
	}{})

	var res []struct {
		model.AdminUser
		IdentityName string `json:"identityName" gorm:"column:identityName;"`
	}
	var count int64
	query := global.App.DB.Table(model.TableAdminUser).LeftJoin(model.TableAdminIdentity, fmt.Sprintf("%s.id = %s.identityId", model.TableAdminIdentity, model.TableAdminUser))
	if form.Search != "" {
		query = query.Where(model.TableAdminUser+".name", "like", "%"+form.Search+"%")
	}
	if len(form.Identity) != 0 {
		query = query.WhereIn(model.TableAdminUser+".identityId", form.Identity)
	}

	err := query.Count(&count).Error
	if err != nil {
		response.Fail(c, 1001, err.Error())
		return
	}

	err = query.
		Order("id desc").
		Offset(form.Offset).
		Select("admin_user.*", "identityName").
		Limit(form.Limit).Scan(&res).Error
	if err != nil {
		response.Fail(c, 1001, err.Error())
		return
	}

	response.Success(c, gin.H{
		"data": map[string]interface{}{
			"list":  res,
			"count": count,
		},
	})
}

func AdminList(c *gin.Context) {
	var res []struct {
		ID   int    `json:"id" gorm:"not null;"`
		Name string `json:"name" gorm:"not null;"`
	}

	query := global.App.DB.Table(model.TableAdminUser)
	err := query.
		Order("id desc").
		Select("id", "name").
		Scan(&res).Error
	if err != nil {
		response.Fail(c, 1001, err.Error())
		return
	}

	response.Success(c, gin.H{
		"data": res,
	})
}

func DeleteAdminUser(c *gin.Context) {
	form := request.Check(c, &struct {
		UserId int `form:"userId" json:"userId" binding:"required"`
	}{})

	var d interface{}
	err := global.App.DB.Table(model.TableAdminUser).Where("id", form.UserId).Delete(d).Error
	if err != nil {
		response.Fail(c, 1001, err.Error())
		return
	}

	//记录操作
	//记录日志
	userId := c.GetInt("userId")
	err = service.SetActionLog("删除", userId, "管理员", map[string]interface{}{
		"userId": userId,
	})
	if err != nil {
		response.Fail(c, 500, err.Error())
		return
	}

	response.Success(c, gin.H{})

}

func UpdateUserPassword(c *gin.Context) {
	form := request.Check(c, &struct {
		UserId  int    `form:"userId" json:"userId" binding:"required"`
		NewPass string `form:"newPass" json:"newPass" binding:"required|max=20,min=6"`
	}{})

	var res model.AdminUser
	global.App.DB.Table(model.TableAdminUser).Where("id", form.UserId).Select("id").First(&res)
	if res.ID == 0 {
		response.Fail(c, 1001, "用户不存在")
		return
	}
	now := time.Now()

	err := global.App.DB.Table(model.TableAdminUser).Where("id", form.UserId).Updates(map[string]interface{}{
		"password":  form.NewPass,
		"updatedAt": now,
	}).Error
	if err != nil {
		response.Fail(c, 1002, err.Error())
		return
	}

	//记录日志
	userId := c.GetInt("userId")
	err = service.SetActionLog("修改", userId, "管理员", map[string]interface{}{
		"userId": userId,
	})
	if err != nil {
		response.Fail(c, 500, err.Error())
		return
	}

	response.Success(c, gin.H{})
}

func SetAdminUserPermission(c *gin.Context) {
	form := request.Check(c, &struct {
		UserId   int `form:"userId" json:"userId" binding:"required"`
		Identity int `json:"identity" binding:"required"`
	}{})

	var res model.AdminUser
	global.App.DB.Table(model.TableAdminUser).Where("id", form.UserId).Select("id").First(&res)
	if res.ID == 0 {
		response.Fail(c, 1001, "用户不存在")
		return
	}
	now := time.Now()

	err := global.App.DB.Table(model.TableAdminUser).Where("id", form.UserId).Updates(map[string]interface{}{
		"identity":  form.Identity,
		"updatedAt": now,
	}).Error
	if err != nil {
		response.Fail(c, 1002, err.Error())
		return
	}

	//记录日志
	userId := c.GetInt("userId")
	err = service.SetActionLog("修改", userId, "管理员", map[string]interface{}{
		"userId": userId,
	})
	if err != nil {
		response.Fail(c, 500, err.Error())
		return
	}

	response.Success(c, gin.H{})

}

func SetIdentity(c *gin.Context) {
	form := request.Check(c, &struct {
		IdentityName string `form:"identityName" json:"identityName" binding:"required"`
		Permissions  []int  `form:"permissions" json:"permissions" binding:""`
	}{})

	var data model.AdminIdentity
	global.App.DB.Table(model.TableAdminIdentity).Where("identityName", form.IdentityName).Select("id").First(&data)

	if data.ID != 0 {
		response.Fail(c, 1001, "identityName 重复")
		return
	}

	now := model.XTime{
		Time: time.Now(),
	}
	data = model.AdminIdentity{
		IdentityName: form.IdentityName,
		Permissions:  utils.ArrayToString(form.Permissions),
		CreatedAt:    now,
		UpdatedAt:    now,
	}

	err := global.App.DB.Table(model.TableAdminIdentity).Create(&data).Error
	if err != nil {
		response.Fail(c, 1001, "AdminIdentity 写入数据失败"+err.Error())
		return
	}

	//记录日志
	userId := c.GetInt("userId")
	err = service.SetActionLog("新增", userId, "身份", data)
	if err != nil {
		response.Fail(c, 500, err.Error())
		return
	}

	response.Success(c, gin.H{})
}

func DeleteIdentity(c *gin.Context) {
	form := request.Check(c, &struct {
		IdentityId int `form:"identityId" json:"identityId" binding:"required"`
	}{})

	//如果这个身份已经有用户关联，无法删除
	var res model.AdminUser
	global.App.DB.Table(model.TableAdminUser).Where("identityId", form.IdentityId).Select("id").First(&res)
	if res.ID != 0 {
		response.Fail(c, 1001, "该身份已经有用户使用，无法删除")
		return
	}
	var d interface{}
	err := global.App.DB.Table(model.TableAdminIdentity).Where("id", form.IdentityId).Delete(d).Error
	if err != nil {
		response.Fail(c, 1001, "AdminIdentity 写入数据失败")
		return
	}

	//记录日志
	userId := c.GetInt("userId")
	err = service.SetActionLog("删除", userId, "身份", map[string]interface{}{
		"identityId": form.IdentityId,
	})
	if err != nil {
		response.Fail(c, 500, err.Error())
		return
	}
	response.Success(c, gin.H{})
}

func GetIdentityList(c *gin.Context) {
	form := request.Check(c, &struct {
		Limit  int    `form:"limit" json:"limit" binding:"required"`
		Offset int    `form:"offset" json:"offset" binding:""`
		Search string `form:"search" json:"search" binding:""`
	}{})

	var count int64
	query := global.App.DB.Table(model.TableAdminIdentity)

	if form.Search != "" {
		query = query.Where("identityName", "like", "%"+form.Search+"%")
	}
	err := query.Count(&count).Error
	if err != nil {
		response.Fail(c, 1001, err.Error())
		return
	}

	var adminIdentity []struct {
		model.AdminIdentity
		PermissionList *[]string `json:"permissions"`
	}
	err = query.Order("id desc").Offset(form.Offset).Limit(form.Limit).Scan(&adminIdentity).Error
	if err != nil {
		response.Fail(c, 1001, err.Error())
		return
	}

	//var res
	for k, v := range adminIdentity {
		per := strings.Split(v.Permissions, ",")

		adminIdentity[k].PermissionList = &per
	}
	response.Success(c, gin.H{
		"data": map[string]interface{}{
			"list":  adminIdentity,
			"count": count,
		},
	})

}

func GetIdentity(c *gin.Context) {
	query := global.App.DB.Table(model.TableAdminIdentity)

	var adminIdentity []struct {
		ID           int    `json:"id" gorm:"not null;"`
		IdentityName string `json:"identityName" gorm:"column:identityName;"`
	}
	err := query.Order("id desc").Select("id", "identityName").Scan(&adminIdentity).Error
	if err != nil {
		response.Fail(c, 1001, err.Error())
		return
	}

	response.Success(c, gin.H{
		"data": adminIdentity,
	})

}

func PermissionList(c *gin.Context) {
	response.Success(c, gin.H{
		"data": permissions,
	})
}

func UpdateIdentityPermission(c *gin.Context) {
	form := request.Check(c, &struct {
		IdentityId  int   `form:"identityId" json:"identityId" binding:"required"`
		Permissions []int `form:"permissions" json:"permissions" binding:""`
	}{})

	var data model.AdminIdentity
	global.App.DB.Table(model.TableAdminIdentity).Where("id", form.IdentityId).Select("id").First(&data)

	if data.ID == 0 {
		response.Fail(c, 1001, "identity不存在")
		return
	}

	err := global.App.DB.Table(model.TableAdminIdentity).Where("id", form.IdentityId).Updates(map[string]interface{}{
		"permissions": utils.ArrayToString(form.Permissions),
		"updatedAt":   time.Now(),
	}).Error
	if err != nil {
		response.Fail(c, 1002, err.Error())
		return
	}

	//记录日志
	userId := c.GetInt("userId")
	err = service.SetActionLog("删除", userId, "权限", map[string]interface{}{
		"permissions": utils.ArrayToString(form.Permissions),
		"identityId":  form.IdentityId,
	})
	if err != nil {
		response.Fail(c, 500, err.Error())
		return
	}

	response.Success(c, gin.H{})
}