package svc

import (
	"applet/app/comm/e"
	"applet/app/comm/svc"
	"applet/app/comm/utils"
	"applet/app/store/md"
	"code.fnuoos.com/go_rely_warehouse/zyos_model.git/src/models"
	"encoding/json"
	"github.com/gin-gonic/gin"
	"time"
)

func AllProjectCate(c *gin.Context) {
	cateList := []map[string]string{
		{
			"name": "全部", "value": "",
		},
	}
	cate := make([]models.CampTaskProjectCate, 0)
	svc.MasterDb(c).Where("is_show=1").OrderBy("sort desc,id desc").Find(&cate)
	for _, v := range cate {
		tmp := map[string]string{
			"name": v.Name, "value": utils.IntToStr(v.Id),
		}
		cateList = append(cateList, tmp)
	}
	res := map[string]interface{}{
		"list": cateList,
	}
	e.OutSuc(c, res, nil)
}
func AllProjectList(c *gin.Context) {
	var args md.ProjectReq
	if err := c.ShouldBindJSON(&args); err != nil {
		e.OutErr(c, e.ERR_INVALID_ARGS)
		return
	}
	list := make([]map[string]interface{}, 0)
	var data = make([]models.CampTaskProject, 0)
	sess := svc.MasterDb(c).Where("state=?", 1)
	if args.Cid != "" {
		sess.And("cid=?", args.Cid)
	}
	count, _ := sess.Limit(utils.StrToInt(args.Size), (utils.StrToInt(args.P)-1)*utils.StrToInt(args.Size)).OrderBy("id desc").FindAndCount(&data)
	cate := make([]models.CampTaskProjectCate, 0)
	svc.MasterDb(c).Where("1=1").OrderBy("sort desc,id desc").Find(&cate)

	for _, v := range data {
		enterpriseInfo := make(map[string]string)
		json.Unmarshal([]byte(v.EnterpriseInfo), &enterpriseInfo)
		enterpriseInfo1 := map[string]string{
			"name":      enterpriseInfo["name"],
			"user_name": enterpriseInfo["user_name"],
			"address":   enterpriseInfo["address"],
		}
		img := make([]string, 0)
		json.Unmarshal([]byte(v.Img), &img)
		firstImg := ""
		if len(img) > 0 {
			firstImg = img[0]
		}
		detailInfo := make([]string, 0)
		json.Unmarshal([]byte(v.DetailInfo), &detailInfo)
		label := make([]string, 0)
		json.Unmarshal([]byte(v.Label), &label)
		tmp := map[string]interface{}{
			"year":            v.CreateTime.Format("2006") + "年",
			"id":              utils.IntToStr(v.Id),
			"name":            v.Name,
			"cid":             utils.IntToStr(v.Cid),
			"money":           utils.Comm(v.Money),
			"img":             firstImg,
			"video_info":      v.VideoInfo,
			"img_list":        img,
			"detail_info":     detailInfo,
			"create_time":     v.CreateTime.Format("2006-01-02 15:04:05"),
			"enterprise_info": enterpriseInfo1,
			"cate_name":       "",
			"adv_word":        v.AdvWord,
			"label":           label,
		}
		for _, v1 := range cate {
			if v1.Id == v.Cid {
				tmp["cate_name"] = v1.Name
			}
		}
		list = append(list, tmp)
	}

	res := map[string]interface{}{
		"list":  list,
		"total": count,
	}
	e.OutSuc(c, res, nil)
	return
}
func ProjectList(c *gin.Context) {
	var args md.ProjectReq
	if err := c.ShouldBindJSON(&args); err != nil {
		e.OutErr(c, e.ERR_INVALID_ARGS)
		return
	}
	storeId := svc.GetCampStoreId(c)
	list := make([]map[string]interface{}, 0)
	var data = make([]models.CampTaskProject, 0)
	sess := svc.MasterDb(c).Where("store_id=?", storeId)
	count, _ := sess.Limit(utils.StrToInt(args.Size), (utils.StrToInt(args.P)-1)*utils.StrToInt(args.Size)).OrderBy("id desc").FindAndCount(&data)
	cateList := make([]map[string]string, 0)
	cate := make([]models.CampTaskProjectCate, 0)
	svc.MasterDb(c).Where("1=1").OrderBy("sort desc,id desc").Find(&cate)
	for _, v := range cate {
		tmp := map[string]string{
			"name": v.Name, "value": utils.IntToStr(v.Id),
		}
		cateList = append(cateList, tmp)
	}
	for _, v := range data {
		enterpriseInfo := make(map[string]string)
		json.Unmarshal([]byte(v.EnterpriseInfo), &enterpriseInfo)
		img := make([]string, 0)
		json.Unmarshal([]byte(v.Img), &img)
		detailInfo := make([]string, 0)
		json.Unmarshal([]byte(v.DetailInfo), &detailInfo)
		label := make([]string, 0)
		json.Unmarshal([]byte(v.Label), &label)
		tmp := map[string]interface{}{
			"admin_name":      v.AdminName,
			"admin_phone":     v.AdminPhone,
			"id":              utils.IntToStr(v.Id),
			"name":            v.Name,
			"cid":             utils.IntToStr(v.Cid),
			"money":           v.Money,
			"money_str":       utils.Comm(v.Money),
			"logo":            v.Logo,
			"video_info":      v.VideoInfo,
			"img":             img,
			"detail_info":     detailInfo,
			"create_time":     v.CreateTime.Format("2006-01-02 15:04:05"),
			"enterprise_info": enterpriseInfo,
			"cate_name":       "",
			"is_must":         utils.IntToStr(v.IsMust),
			"adv_word":        v.AdvWord,
			"label":           label,
		}
		for _, v1 := range cate {
			if v1.Id == v.Cid {
				tmp["cate_name"] = v1.Name
			}
		}
		list = append(list, tmp)
	}

	res := map[string]interface{}{
		"list":      list,
		"cate_list": cateList,
		"total":     count,
	}
	e.OutSuc(c, res, nil)
	return
}
func ProjectSave(c *gin.Context) {
	var args md.ProjectSaveReq
	if err := c.ShouldBindJSON(&args); err != nil {
		e.OutErr(c, e.ERR_INVALID_ARGS)
		return
	}
	storeId := svc.GetCampStoreId(c)
	var data models.CampTaskProject
	if args.Id != "" {
		svc.MasterDb(c).Where("id=?", args.Id).Get(&data)
	} else {
		data = models.CampTaskProject{
			CreateTime: time.Now(),
			UpdateTime: time.Now(),
			StoreId:    storeId,
		}
		svc.MasterDb(c).Insert(&data)
	}
	data.UpdateTime = time.Now()
	data.Name = args.Name
	data.EnterpriseInfo = utils.SerializeStr(args.EnterpriseInfo)
	data.Cid = utils.StrToInt(args.Cid)
	data.IsMust = utils.StrToInt(args.IsMust)
	data.Money = args.Money
	data.Logo = args.Logo
	data.State = 1
	data.VideoInfo = args.VideoInfo
	data.Img = utils.SerializeStr(args.Img)
	data.DetailInfo = utils.SerializeStr(args.DetailInfo)
	data.Label = utils.SerializeStr(args.Label)
	data.AdvWord = args.AdvWord
	data.AdminName = args.AdminName
	data.AdminPhone = args.AdminPhone
	svc.MasterDb(c).Where("id=?", data.Id).Update(&data)
	e.OutSuc(c, "success", nil)
	return
}

func ProjectDel(c *gin.Context) {
	var args md.DirectorDelReq
	if err := c.ShouldBindJSON(&args); err != nil {
		e.OutErr(c, e.ERR_INVALID_ARGS)
		return
	}
	svc.MasterDb(c).In("id", args.Ids).Delete(&models.CampTaskProject{})
	e.OutSuc(c, "success", nil)
	return
}