package admin

import (
	"fmt"
	"net/http"
	"strconv"
	"strings"
	"time"
	"zhiyuan/models"
	"zhiyuan/models/raffle"
	"zhiyuan/pkg/app"
	"zhiyuan/pkg/config"
	"zhiyuan/pkg/db"
	"zhiyuan/pkg/errcode"
	adminParam "zhiyuan/pkg/param/admin"
	orderParam "zhiyuan/pkg/param/order"
	"zhiyuan/pkg/utils"
	"zhiyuan/services/admin"
	"zhiyuan/services/aftersale/order"
	"zhiyuan/services/dept"
	"zhiyuan/services/form"
	"zhiyuan/services/role"

	"github.com/gin-gonic/gin"
	"github.com/tealeg/xlsx/v3"
)

func Dashboard(c *gin.Context) {

	// 是否有缓存
	//cacheKey := "dashborad_data"
	//cacheData, err := redis.Get(cacheKey)
	//if err == nil {
	//	app.Success(c, utils.JsonDecode(cacheData).ToMap())
	//	return
	//}
	// 本月报修
	currentTime := time.Now()
	monthDate := utils.GetFirstDateOfMonth(currentTime).Unix()
	dayDate := utils.GetZeroTime(currentTime).Unix()

	orderBaseMap := map[string]interface{}{
		"deleted_at": 0,
	}
	eventBaseWhere := "o.deleted_at=0 AND e.event_type=1 AND e.created_at>" + utils.ToStr(dayDate)
	if adminInfo := admin.GetAdminCache(c.GetInt("adminID")); adminInfo.SiteID > 0 {
		orderBaseMap["site_id"] = adminInfo.SiteID
		eventBaseWhere = eventBaseWhere + " AND o.site_id=" + utils.ToStr(adminInfo.SiteID)
	}
	statisData := make(map[string]int64)
	statisData["month_num"], _ = order.Count(utils.MergeMap(map[string]interface{}{"created_at >": monthDate}, orderBaseMap))
	statisData["day_num"], _ = order.Count(utils.MergeMap(map[string]interface{}{"created_at >": dayDate}, orderBaseMap))

	statisData["day_repair_num"], _ = order.GetCountJoinOrder(eventBaseWhere+" AND order_state="+utils.ToStr(orderParam.State.Repaired.ID), nil)
	statisData["day_finish_num"], _ = order.GetCountJoinOrder(eventBaseWhere+" AND order_state="+utils.ToStr(orderParam.State.Confirmed.ID), nil)

	// 待办事项
	todoData := make(map[string]int64)

	// 待审核
	todoData["created"], _ = order.Count(utils.MergeMap(map[string]interface{}{"state": orderParam.State.Created.ID}, orderBaseMap))

	// 待分配
	todoData["checked"], _ = order.Count(utils.MergeMap(map[string]interface{}{"state": orderParam.State.Checked.ID}, orderBaseMap))

	// 待维修
	todoData["alloted"], _ = order.Count(utils.MergeMap(map[string]interface{}{"state": orderParam.State.Allotted.ID}, orderBaseMap))

	res := gin.H{
		"todo":   todoData,
		"statis": statisData,
	}
	//redis.Set(cacheKey, res, 60)
	app.Success(c, res)
}

func Login(c *gin.Context) {
	var form form.AdminLogin
	if app.Bind(c, &form) != nil {
		return
	}
	token, err := admin.Login(form.Phone, form.Password)
	if err != nil {
		app.ErrorMsg(c, err.Error(), nil)
		return
	}
	app.Success(c, map[string]string{
		"token": token,
	})
}

func Info(c *gin.Context) {
	type SettingInfo struct {
		ImgHost string `json:"img_host"`
	}
	type AdminInfo struct {
		ID       int         `json:"id"`
		UserName string      `json:"username"`
		RoleIds  string      `json:"role_ids"`
		ShopIds  string      `json:"shop_ids"`
		Auths    []string    `json:"auths"`
		Setting  SettingInfo `json:"setting"`
	}
	var adminInfo *AdminInfo
	_, err := admin.GetInfoByID(c.GetInt("adminID"), []string{"id", "username", "shop_ids"}, &adminInfo)
	if adminInfo == nil {
		app.Response(c, http.StatusUnauthorized, errcode.TokenInvalid, nil)
		return
	}
	adminInfo.Auths, err = admin.GetAuth(adminInfo.ID)
	if err != nil {
		app.ErrorMsg(c, err.Error(), nil)
		return
	}
	adminInfo.Setting = SettingInfo{
		ImgHost: config.Cfg.App.ImgHost,
	}
	app.Success(c, adminInfo)
}

func Logout(c *gin.Context) {
	err := admin.Logout(c.GetInt("adminID"))
	if err != nil {
		app.ErrorMsg(c, err.Error(), nil)
		return
	}
	app.Success(c, nil)
}

func AdminAdd(c *gin.Context) {
	var addForm form.AdminAdd
	if app.Bind(c, &addForm) != nil {
		return
	}
	id, err := admin.Add(addForm)
	if err != nil {
		app.Error(c, err.Error())
		return
	}
	app.Success(c, gin.H{"id": id})
}

func AdminEdit(c *gin.Context) {
	id := utils.ToInt(c.Param("id"))
	if id <= 0 {
		app.ErrorMsg(c, "admin id must be a number", nil)
		return
	}

	var addForm form.AdminAdd
	if app.Bind(c, &addForm) != nil {
		return
	}

	err := admin.EditByID(addForm, id)
	if err != nil {
		app.ErrorMsg(c, err.Error(), nil)
		return
	}
	app.Success(c, nil)
}

func AdminEditState(c *gin.Context) {
	id := utils.ToInt(c.Param("id"))
	if id <= 0 {
		app.ErrorMsg(c, "admin id must be a number", nil)
		return
	}

	state := utils.ToInt(c.Param("state"))
	if state != 1 && state != -1 {
		app.ErrorMsg(c, "状态有误", nil)
		return
	}
	if err := admin.EditStateByID(id, state); err != nil {
		app.ErrorMsg(c, err.Error(), nil)
		return
	}
	app.Success(c, nil)
}

func AdminList(c *gin.Context) {
	isSelect := utils.ToInt(c.Query("is_select"))
	if isSelect == 1 {
		AdminListSelect(c)
		return
	}

	page := app.HandlePageNums(c)
	where := map[string]string{
		"where":     "id>1 AND deleted_at=0",
		"_order_by": "id desc",
	}
	if page.PageSize != 0 {
		where["_page_size"] = utils.ToStr(page.PageSize)
		where["_page_num"] = utils.ToStr(page.PageNum)
	}
	param := make(map[string]interface{})

	// deptID
	deptID := utils.ToInt(c.Query("dept_id"))
	if deptID > 0 {
		where["where"] = where["where"] + " AND dept_id IN {{dept_id}}"
		param["dept_id"] = dept.GetSubDeptIds(deptID, []int{deptID})
	}

	// deptID
	ids := c.Query("ids")
	if ids != "" {
		Ids := make([]int, 0)
		for _, v := range strings.Split(ids, ",") {
			i, err := strconv.Atoi(v)
			if err == nil {
				Ids = append(Ids, i)
			}
		}
		where["where"] = where["where"] + " AND id IN {{ids}}"
		param["ids"] = Ids
	}

	// state
	state := utils.ToInt(c.Query("state"))
	if state != 0 {
		where["where"] = where["where"] + " AND state={{state}}"
		param["state"] = state
	}

	roleId := c.Query("role_id")
	if roleId != "" {
		where["where"] = where["where"] + " AND FIND_IN_SET({{role_id}}, role_ids)"
		param["role_id"] = roleId
	}

	shopId := c.Query("shop_id")
	if shopId != "" {
		where["where"] = where["where"] + " AND FIND_IN_SET({{shop_id}}, shop_ids)"
		param["shop_id"] = shopId
	}

	// user
	user := c.Query("user")
	if user != "" {
		where["where"] = where["where"] + " AND (username LIKE {{user}} OR phone LIKE {{user}})"
		param["user"] = "%" + user + "%"
	}

	total, err := admin.CountRaw(where["where"], param)
	if err != nil {
		app.Error(c, err.Error())
		return
	}
	type AdminList struct {
		ID          int    `json:"id"`
		UserName    string `json:"username"`
		Phone       string `json:"phone"`
		RoleIds     string `json:"role_ids"`
		RoleNames   string `json:"role_names"`
		DeptID      int    `json:"dept_id"`
		DeptName    string `json:"dept_name"`
		Headimgurl  string `json:"headimgurl"`
		Nickname    string `json:"nickname"`
		SiteID      int    `json:"site_id"`
		State       int    `json:"state"`
		StateName   string `json:"state_name"`
		StateColor  string `json:"state_color"`
		AccountName string `json:"account_name"`
		AccountBank string `json:"account_bank"`
		AccountNo   string `json:"account_no"`
		CreatedAt   string `json:"created_at"`
		ShopIds     string `json:"shop_ids"`
		EntryDate   int    `json:"entry_date"`
		RestDay     string `json:"rest_day"`
		LogIds      string `json:"log_ids"`
	}
	adminList := make([]AdminList, 0)
	if _, err = admin.GetAdminsRaw(where, param, &adminList); err != nil {
		app.Error(c, err.Error())
		return
	}

	adminIds := make([]int, 0)
	for _, v := range adminList {
		adminIds = append(adminIds, v.ID)
	}
	roleListMap := make(map[int]string)
	if roleList, err := role.GetList(nil, []string{"id, name"}, app.Page{}, nil); err == nil {
		for _, v := range roleList {
			roleListMap[v.ID] = v.Name
		}
	}
	stateMap := adminParam.GetStateMap()
	for k, v := range adminList {
		roleNames := ""
		roleSlice := strings.Split(v.RoleIds, ",")
		for _, vv := range roleSlice {
			roleNames += "," + roleListMap[utils.ToInt(vv)]
		}
		if stateObj, ok := stateMap[v.State]; ok {
			v.StateName = stateObj.Name
			v.StateColor = stateObj.Color
		}
		v.RoleNames = strings.TrimLeft(roleNames, ",")
		v.DeptName = dept.GetDeptFullName(v.DeptID, "-")
		v.CreatedAt = utils.DateS(v.CreatedAt, "YYYY-MM-DD HH:mm")
		adminList[k] = v
	}
	data := gin.H{
		"list":  adminList,
		"total": total,
		"limit": page.PageSize,
	}
	app.Success(c, data)
}

func AdminExport(c *gin.Context) {
	wb := xlsx.NewFile()
	time := utils.ToStr(time.Now().UnixNano())
	filename := "员工信息-" + time + ".xlsx"
	fullPath := config.Cfg.App.ExportPath + filename
	sh, err := wb.AddSheet("Sheet1")
	if err != nil {
		app.Error(c, err.Error())
		return
	}
	sh.SetColWidth(1, 1, 20)
	sh.SetColWidth(2, 2, 30)
	sh.SetColWidth(3, 3, 20)
	var row *xlsx.Row
	var cell *xlsx.Cell
	rowHeader := sh.AddRow()
	rowHeader.SetHeight(48)
	cell = rowHeader.AddCell()
	cell.Value = "名称"
	cell = rowHeader.AddCell()
	cell.Value = "活动链接"
	adminList, err := admin.GetAdmins(map[string]interface{}{"deleted_at": 0}, nil, app.Page{}, nil)
	for _, v := range adminList {
		row = sh.AddRow()
		row.SetHeight(30)
		cell = row.AddCell()
		cell.Value = v.Username
		cell = row.AddCell()
		cell.Value = "https://jz.nczyzs.com/activity/one#?ref_id=" + utils.ToStr(v.ID)
	}
	if err := wb.Save(fullPath); err != nil {
		app.Error(c, err.Error())
		return
	}
	app.Success(c, gin.H{"path": "export/" + filename, "filename": filename})
}

func AdminListSelect(c *gin.Context) {
	type AdminList struct {
		ID       int    `json:"id"`
		UserName string `json:"username"`
	}
	adminList := make([]AdminList, 0)
	where := map[string]string{
		"where":     "id>1",
		"_order_by": "id desc",
	}
	if c.Query("show_all") == "" {
		where["where"] = where["where"] + " AND deleted_at=0"
	}
	if c.Query("limit") != "" {
		page := app.HandlePageNum(c)
		where["_page_size"] = utils.ToStr(page.PageSize)
		where["_page_num"] = utils.ToStr(page.PageNum)
	}
	param := make(map[string]interface{})

	// site_id
	//if adminInfo := admin.GetAdminCache(c.GetInt("adminID")); adminInfo.SiteID > 0 {
	//	where["where"] += " AND (site_id={{site_id}} or site_id=0)"
	//	param["site_id"] = adminInfo.SiteID
	//}
	username := c.Query("username")
	if username != "" {
		where["where"] = where["where"] + " AND username LIKE {{username}}"
		param["username"] = "%" + username + "%"
	}
	adminIds := c.Query("admin_ids")
	if adminIds != "" {
		where["where"] = where["where"] + " AND id IN {{ids}}"
		param["ids"] = strings.Split(adminIds, ",")
	}
	roleId := c.Query("role_id")
	if roleId != "" {
		where["where"] = where["where"] + " AND FIND_IN_SET({{role_id}}, role_ids)"
		param["role_id"] = roleId
	}
	if _, err := admin.GetAdminsRaw(where, param, &adminList); err != nil {
		app.Error(c, err.Error())
	}
	app.Success(c, adminList)
}

func AdminDel(c *gin.Context) {
	id := utils.ToInt(c.Param("id"))
	if id <= 0 {
		app.ErrorMsg(c, "admin id must be a number", nil)
		return
	}
	err := admin.DeleteByID(id)
	if err != nil {
		app.Error(c, err.Error())
		return
	}
	app.Success(c, nil)
}

func AdminInfo(c *gin.Context) {
	id := utils.StrTo(c.Param("id")).MustInt()
	if id <= 0 {
		app.ErrorMsg(c, "department id must be a number", nil)
		return
	}
	type AdminInfo struct {
		ID        int    `json:"id"`
		UserName  string `json:"username"`
		Phone     string `json:"phone"`
		RoleIds   string `json:"role_ids"`
		DeptID    int    `json:"dept_id"`
		SiteID    int    `json:"site_id"`
		State     int    `json:"state"`
		CreatedAt string `json:"created_at"`
	}
	var admininfo AdminInfo
	_, err := admin.GetInfoByID(id, nil, &admininfo)
	if err != nil {
		app.Error(c, err.Error())
		return
	}
	app.Success(c, admininfo)
}

func SalesmanAdd(c *gin.Context) {
	var addForm form.SalesmanAdd
	if app.Bind(c, &addForm) != nil {
		return
	}
	id, err := admin.AddSalesman(addForm)
	if err != nil {
		app.Error(c, err.Error())
		return
	}
	app.Success(c, gin.H{"id": id})
}

func Password(c *gin.Context) {
	var form form.Password
	if app.Bind(c, &form) != nil {
		return
	}
	if err := admin.Password(c.GetInt("adminID"), form); err != nil {
		app.ErrorMsg(c, err.Error(), nil)
		return
	}
	app.Success(c, nil)
}

func GetRaffleInfo(c *gin.Context) {

	id := utils.StrTo(c.Param("id")).MustInt()
	if id <= 0 {
		app.ErrorMsg(c, "抽奖id有误", nil)
		return
	}
	var raffles *raffle.Raffle
	db.GetModel(map[string]interface{}{
		"id":         id,
		"deleted_at": 0,
	}, &raffles)
	if raffles == nil || raffles.DeletedAt != 0 {
		app.ErrorMsg(c, "抽奖活动不存在", nil)
		return
	}

	raffleItems := make([]raffle.RaffleItem, 0)
	db.GetModel(map[string]interface{}{
		"raffle_id":  raffles.ID,
		"deleted_at": 0,
	}, &raffleItems)
	items := make([]gin.H, 0)
	itemMap := map[int64]raffle.RaffleItem{}
	for _, item := range raffleItems {
		items = append(items, gin.H{
			"id":      item.ID,
			"name":    item.Name,
			"picture": item.Picture,
			"weight":  item.Weight,
			"winning": item.Winning,
		})
		itemMap[item.ID] = item
	}

	ret := gin.H{
		"state": 0,
		"items": items,
		"raffle": gin.H{
			"name": raffles.Name,
		},
	}

	app.Success(c, ret)
}

func WorkArrangeItemImport(c *gin.Context) {
	file, err := c.FormFile("file")
	if err != nil {
		app.Error(c, fmt.Sprintf("get form err: %s", err.Error()))
		return
	}
	fileExt := utils.FileExt(file.Filename)
	attachKey := utils.RandomStr() + fileExt
	file.Filename = "data/" + attachKey
	if err := c.SaveUploadedFile(file, file.Filename); err != nil {
		app.Error(c, fmt.Sprintf("上传文件失败%s", err.Error()))
		return
	}
	wb, err := xlsx.OpenFile(file.Filename)
	if err != nil {
		app.Error(c, err.Error())
		return
	}

	arrangeId, _ := db.ToInt64(c.PostForm("arrange_id"))
	if arrangeId <= 0 {
		app.ErrorMsg(c, "导入错误", nil)
		return
	}

	for _, sh := range wb.Sheet {
		datas := make([]map[string]interface{}, 0)
		headers := make([]string, 0)
		err := sh.ForEachRow(func(r *xlsx.Row) error {
			if r.GetCoordinate() <= 0 {
				err := r.ForEachCell(func(c *xlsx.Cell) error {
					headers = append(headers, c.String())
					return nil
				})
				if err != nil {
					return err
				}
			} else {
				var data models.WorkArrangeItem
				for i, header := range headers {
					value := r.GetCell(i).String()
					switch header {
					case "天数":
						data.Day, _ = db.ToInt64(value)
					case "时间":
						if value == "下午" {
							data.Type = 1
						}
					case "内容":
						data.Content = value
					case "培训老师":
						data.Teacher = value
					case "考核内容":
						data.Examine = value
					default:
					}
				}
				if data.Day < 0 || data.Content == "" && data.Teacher == "" && data.Examine == "" {
					return nil
				}
				var item models.WorkArrangeItem
				db.GetModel(map[string]interface{}{
					"arrange_id": arrangeId,
					"day":        data.Day,
					"type":       data.Type,
					"deleted_at": 0,
				}, &item)
				da := map[string]interface{}{
					"arrange_id": arrangeId,
					"day":        data.Day,
					"type":       data.Type,
					"content":    data.Content,
					"teacher":    data.Teacher,
					"examine":    data.Examine,
				}
				if item.ID == 0 {
					datas = append(datas, da)
				} else {
					err := db.UpdateModel(db.Type(item), item.ID, da)
					if err != nil {
						return err
					}
				}
			}
			return nil
		})
		if err != nil {
			app.Error(c, err.Error())
			return
		}
		db.InsertModels(db.Type(models.WorkArrangeItem{}), datas)
	}
	app.Success(c, nil)
}