package pick

import (
	"errors"
	"zhiyuan/models"
	"zhiyuan/pkg/app"
	"zhiyuan/pkg/db"
	"zhiyuan/pkg/param/material"
	"zhiyuan/pkg/param/material/pick"
	"zhiyuan/pkg/utils"
	"zhiyuan/services/form"
	"zhiyuan/services/material/brand"
	"zhiyuan/services/material/item"
	"zhiyuan/services/user"
)

var MatPickOrder models.MatPickOrder

func GetOrders(where map[string]interface{}, fields []string, page app.Page, retVal interface{}) ([]*models.MatPickOrder, error) {
	if page.PageNum > 0 && page.PageSize > 0 {
		where["_limit"] = db.GetOffset(uint(page.PageNum), uint(page.PageSize))
	}
	return MatPickOrder.GetMulti(where, fields, retVal)
}

func CountOrder(where map[string]interface{}) (int64, error) {
	return db.Count(MatPickOrder.TableName(), where)
}

func GetOrder(where map[string]interface{}, fields []string, dest interface{}) (*models.MatPickOrder, error) {
	return MatPickOrder.GetOne(where, fields, dest)
}

func GetOrderMap(form form.MaterialPickOrderAdd) (map[string]interface{}, error) {
	orderMap := map[string]interface{}{
		"admin_id":       form.AdminID,
		"pkg_id":         form.PkgID,
		"customer_name":  form.CustomerName,
		"customer_phone": form.CustomerPhone,
		"house_address":  form.HouseAddress,
		"house_area":     form.HouseArea,
		"state":          pick.OrderState.Finished.ID,
	}
	subGroup := make(map[int][]int, 0)
	subListMap := make(map[int]*models.MatPick)
	if pickList, err := GetPicks(map[string]interface{}{"pkg_id": form.PkgID}, nil, app.Page{}, nil); err == nil {
		for _, v := range pickList {
			subListMap[v.ID] = v
			subGroup[v.RoomType] = append(subGroup[v.RoomType], v.ID)
		}
	}
	itemIds := make([]int, 0)
	emptyNum := 0
	emptyNumMax := 2
	for _, v := range form.Item {
		for _, item := range v {
			if item.ID == 0 {
				emptyNum = emptyNum + 1
			} else {
				itemIds = append(itemIds, item.ID)
			}
		}
	}
	if emptyNum > emptyNumMax {
		orderMap["state"] = pick.OrderState.Unfinished.ID
	}

	itemListMap := make(map[int]*models.MatItem)
	if itemList, err := item.GetList(map[string]interface{}{"id in": itemIds}, nil, app.Page{}, nil); err == nil {
		for _, v := range itemList {
			itemListMap[v.ID] = v
		}
	}

	brandListMap := make(map[int]*models.MatBrand)
	if brandList, err := brand.GetList(map[string]interface{}{}, nil, app.Page{}, nil); err == nil {
		for _, v := range brandList {
			brandListMap[v.ID] = v
		}
	}

	// 主材，增项
	type PrimaryDataPick struct {
		PickID    int    `json:"pick_id"`
		PickName  string `json:"pick_name"`
		ItemID    int    `json:"item_id"`
		ItemName  string `json:"item_name"`
		BrandID   int    `json:"brand_id"`
		BrandName string `json:"brand_name"`
		Level     int    `json:"level"`
		Remarks   string `json:"remarks"`
		UnitName  string `json:"unit_name"`
		Color     string `json:"color"`
		Num       int    `json:"num"`
	}
	type PrimaryData struct {
		RoomType int               `json:"room_type"`
		RoomName string            `json:"room_name"`
		Picks    []PrimaryDataPick `json:"picks"`
	}
	roomTypes := utils.ParseSliceMap(material.Params.RoomType, "id")
	primaryData := make([]PrimaryData, 0)
	type Room struct {
		Type int    `json:"type"`
		Name string `json:"name"`
	}
	roomList := []Room{{Type: 0, Name: utils.ToStr(roomTypes["0"]["name"])}}
	for _, v := range form.HouseStyle {
		roomName := utils.ToStr(roomTypes[utils.ToStr(v.Type)]["name"])
		for i := 0; i < v.Num; i++ {
			roomName = roomName + utils.ToStr(i+1)
			roomList = append(roomList, Room{
				Type: v.Type,
				Name: roomName,
			})
		}
	}
	unitTypes := utils.ParseSliceMap(item.Params.Unit, "id")
	for k, v := range roomList {
		primaryItem := PrimaryData{
			RoomType: v.Type,
			RoomName: v.Name,
		}
		subList := make([]PrimaryDataPick, 0)
		for _, subID := range subGroup[v.Type] {
			item := form.Item[k][subID]
			if item.ID > 0 {
				subList = append(subList, PrimaryDataPick{
					PickID:    subID,
					PickName:  subListMap[subID].PickName,
					ItemID:    item.ID,
					Level:     itemListMap[item.ID].Level,
					ItemName:  itemListMap[item.ID].ItemName,
					BrandID:   itemListMap[item.ID].BrandID,
					BrandName: brandListMap[itemListMap[item.ID].BrandID].BrandName,
					Num:       item.Num,
					Remarks:   item.Remarks,
					Color:     item.Color,
					UnitName:  utils.ToStr(unitTypes[utils.ToStr(itemListMap[item.ID].Unit)]["name"]),
				})
			} else {
				subList = append(subList, PrimaryDataPick{
					PickID:    subID,
					PickName:  subListMap[subID].PickName,
					ItemID:    0,
					Level:     1,
					ItemName:  "",
					BrandID:   0,
					BrandName: "",
					Num:       1,
					Remarks:   "",
					Color:     "",
				})
			}
		}
		primaryItem.Picks = subList
		primaryData = append(primaryData, primaryItem)
	}
	orderMap["content"] = utils.JsonEncode(primaryData)
	orderMap["house_style"] = utils.JsonEncode(form.HouseStyle)
	return orderMap, nil
}

func AddOrder(form form.MaterialPickOrderAdd) (int64, error) {
	orderMap, err := GetOrderMap(form)
	if err != nil {
		return 0, err
	}

	// 添加用户
	if userInfo, _ := user.GetOne(map[string]interface{}{"phone": form.CustomerPhone}, nil, nil); userInfo == nil {
		userID, _ := user.InsertOne(map[string]interface{}{
			"name":  form.CustomerName,
			"phone": form.CustomerPhone,
		})
		orderMap["user_id"] = userID
	} else {
		orderMap["user_id"] = userInfo.ID
	}

	roleID, err := db.InsertOne(MatPickOrder.TableName(), orderMap)
	// return 0, errors.New("提交失败")
	if err != nil {
		return 0, errors.New("提交失败")
	}
	return roleID, nil
}

func EditOrder(form form.MaterialPickOrderAdd, id int) (int64, error) {
	if orderInfo, err := GetOrder(map[string]interface{}{"id": id}, nil, nil); err != nil {
		return 0, err
	} else if !utils.IsContain(pick.OrderAllow.Edit, orderInfo.State) {
		return 0, errors.New("该报价单不允许编辑")
	}
	orderMap, err := GetOrderMap(form)
	if err != nil {
		return 0, err
	}

	// 添加用户
	if userInfo, _ := user.GetOne(map[string]interface{}{"phone": form.CustomerPhone}, nil, nil); userInfo == nil {
		userID, _ := user.InsertOne(map[string]interface{}{
			"name":  form.CustomerName,
			"phone": form.CustomerPhone,
		})
		orderMap["user_id"] = userID
	} else {
		orderMap["user_id"] = userInfo.ID
	}
	roleID, err := db.Update(MatPickOrder.TableName(), map[string]interface{}{"id": id}, orderMap)

	// return 0, errors.New("提交失败")
	if err != nil {
		return 0, errors.New("提交失败")
	}
	return roleID, nil
}

func CheckOrder(form form.OrderCheck, id int) (int64, error) {
	orderInfo, err := GetOrder(map[string]interface{}{"id": id}, nil, nil)
	if err != nil {
		return 0, err
	}
	if !utils.IsContain(pick.OrderAllow.Check, orderInfo.State) {
		return 0, errors.New("状态有误")
	}
	return db.Update(MatPickOrder.TableName(), map[string]interface{}{"id": id}, map[string]interface{}{"state": pick.OrderState.Checked.ID})
}