package pick

import (
	"fmt"
	"github.com/gin-gonic/gin"
	"github.com/gogf/gf/v2/util/gconv"
	"zhiyuan/models"
	"zhiyuan/models/final"
	"zhiyuan/pkg/app"
	"zhiyuan/pkg/db"
	"zhiyuan/pkg/param/material"
	"zhiyuan/pkg/utils"
	"zhiyuan/services/form"
	"zhiyuan/services/material/item"
	"zhiyuan/services/material/pick"
	"zhiyuan/services/structs"
)

func PickListback(c *gin.Context) {
	pkgID := utils.StrTo(c.Query("site_id")).MustInt()
	if pkgID <= 0 {
		app.Error(c, "工地id有误")
		return
	}

	itemList := make([]*structs.MaterialPickList, 0)
	if _, err := pick.GetPicks(map[string]interface{}{"pkg_id": pkgID}, nil, app.Page{}, &itemList); err != nil {
		app.Error(c, err.Error())
		return
	}
	typeListMap := item.GetTypeMapByCache()
	itemRoomTypeList := make(map[int][]*structs.MaterialPickList, 0)
	for _, v := range itemList {
		v.ItemTypeName = typeListMap[v.ItemType]
		itemRoomTypeList[v.RoomType] = append(itemRoomTypeList[v.RoomType], v)
	}
	type PkgItemList struct {
		RoomType int                         `json:"room_type"`
		RoomName string                      `json:"room_name"`
		Items    []*structs.MaterialPickList `json:"items"`
	}
	pkgItemListGroup := make([]PkgItemList, 0)
	for _, v := range material.Params.RoomType {
		if itemRoomTypeList[v.ID] == nil {
			itemRoomTypeList[v.ID] = make([]*structs.MaterialPickList, 0)
		}
		pkgItemListGroup = append(pkgItemListGroup, PkgItemList{
			RoomName: v.Name,
			RoomType: v.ID,
			Items:    itemRoomTypeList[v.ID],
		})
	}
	pkgItemList := make([]map[string]interface{}, 0)
	for _, v := range pkgItemListGroup {
		pkgItemList = append(pkgItemList, map[string]interface{}{
			"room_type": v.RoomType,
			"room_name": v.RoomName,
			"rowspan":   len(v.Items) + 1,
			"colspan":   1,
		})

		for _, sub := range v.Items {
			pkgItemList = append(pkgItemList, map[string]interface{}{
				"id":             sub.ID,
				"room_type":      sub.RoomType,
				"pick_name":      sub.PickName,
				"level":          sub.Level,
				"standard":       sub.Standard,
				"cycle":          sub.Cycle,
				"confirm_type":   sub.ConfirmType,
				"rowspan":        0,
				"colspan":        0,
				"item_type":      sub.ItemType,
				"item_type_name": sub.ItemTypeName,
			})
		}
	}
	app.Success(c, map[string]interface{}{"sub_list": pkgItemList})
}

func PickList(c *gin.Context) {
	siteID := utils.StrTo(c.Query("site_id")).MustInt()
	if siteID <= 0 {
		app.Error(c, "工地id有误")
		return
	}

	var site final.FinalSite
	db.GetModel(map[string]interface{}{
		"id":         siteID,
		"deleted_at": 0,
	}, &site)
	if site.ID == 0 {
		app.Error(c, "工地不存在")
		return
	}

	var workList []*final.MatPickWork
	db.GetModel(map[string]interface{}{
		"site_id":    site.ID,
		"deleted_at": 0,
	}, &workList)

	itemRoomTypeList := make(map[int][]*final.MatPickWork)
	var oneLevel []int
	for _, v := range workList {
		fmt.Println(v.PickName)
		oneLevel = utils.AppendUniqueInt(oneLevel, gconv.Int(v.RoomType))
		itemRoomTypeList[gconv.Int(v.RoomType)] = append(itemRoomTypeList[gconv.Int(v.RoomType)], v)
	}
	type PkgItemList struct {
		RoomType int                  `json:"room_type"`
		RoomName string               `json:"room_name"`
		Items    []*final.MatPickWork `json:"items"`
	}

	pkgItemListGroup := make([]PkgItemList, 0)

	//获取当前工地的一级目录
	var accepts []models.WorkQualityAccept
	db.GetModel(map[string]interface{}{"id in": oneLevel}, &accepts)

	for _, v := range accepts {
		if itemRoomTypeList[gconv.Int(v.ID)] == nil {
			itemRoomTypeList[gconv.Int(v.ID)] = make([]*final.MatPickWork, 0)
		}
		pkgItemListGroup = append(pkgItemListGroup, PkgItemList{
			RoomName: v.Name,
			RoomType: gconv.Int(v.ID),
			Items:    itemRoomTypeList[gconv.Int(v.ID)],
		})
	}

	pkgItemList := make([]map[string]interface{}, 0)
	for _, v := range pkgItemListGroup {
		pkgItemList = append(pkgItemList, map[string]interface{}{
			"room_type": v.RoomType,
			"room_name": v.RoomName,
			"rowspan":   len(v.Items) + 1,
			"colspan":   1,
		})

		for _, sub := range v.Items {
			pkgItemList = append(pkgItemList, map[string]interface{}{
				"id":          sub.ID,
				"room_type":   sub.RoomType,
				"pick_name":   sub.PickName,
				"photograph":  sub.Photograph,
				"cycle":       sub.Cycle,
				"worker_id":   sub.WorkerId,
				"worker_name": sub.WorkerName,
				"pictures":    sub.Pictures,
				"rowspan":     0,
				"colspan":     0,
				//"item_type":      sub.ItemType,
				//"item_type_name": sub.ItemTypeName,
			})
		}
	}

	app.Success(c, map[string]interface{}{"sub_list": pkgItemList, "site_info": site})
}

func PickAdd(c *gin.Context) {
	var form form.WorkItemAdd
	if app.Bind(c, &form) != nil {
		return
	}

	if id, err := pick.AddPickWork(form); err != nil {
		app.Error(c, err.Error())
		return
	} else {
		app.Success(c, gin.H{"id": id})
	}
}

func PickEdit(c *gin.Context) {
	id := utils.StrTo(c.Param("id")).MustInt()
	if id <= 0 {
		app.Error(c, "id有误")
		return
	}
	var form form.WorkItemAdd
	if app.Bind(c, &form) != nil {
		return
	}
	if _, err := pick.EditPickWork(form, id); err != nil {
		app.ErrorMsg(c, err.Error(), nil)
		return
	}
	app.Success(c, nil)
}

func PickDel(c *gin.Context) {
	siteId := utils.StrTo(c.Param("site_id")).MustInt()
	if siteId <= 0 {
		app.Error(c, "site_id有误")
		return
	}
	Id := utils.StrTo(c.Param("id")).MustInt()
	if Id <= 0 {
		app.Error(c, "id有误")
		return
	}
	if _, err := pick.DelPickWork(Id, siteId); err != nil {
		app.ErrorMsg(c, err.Error(), nil)
		return
	}
	app.Success(c, nil)
}