package bid

import (
	"zhiyuan/models"
	"zhiyuan/pkg/app"
	"zhiyuan/pkg/db"
	"zhiyuan/pkg/param/material"
	bidParam "zhiyuan/pkg/param/material/bid"
	"zhiyuan/pkg/utils"
	"zhiyuan/services/form"
	"zhiyuan/services/structs"
	"zhiyuan/services/structs/calc"
	"zhiyuan/services/user"
)

var MatBidOrder models.MatBidOrder

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

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

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

func CountRaw(where string, param map[string]interface{}) (int64, error) {
	query := "`zy_mat_bid_order` left join `zy_admin` on `zy_admin`.`id` = `zy_mat_bid_order`.`admin_id` WHERE " + where
	return db.CountRaw(query, param)
}

func GetOrdersRaw(where map[string]string, param map[string]interface{}, retVal interface{}) error {
	field := "SELECT `zy_mat_bid_order`.*, `zy_admin`.`username` as `admin_name` FROM `zy_mat_bid_order` left join `zy_admin` on `zy_admin`.`id` = `zy_mat_bid_order`.`admin_id` "
	return db.GetMultiRaw(field, where, param, retVal)
}

func OutputPriceDetail(id int) error {
	var orderInfo *structs.MaterialBidOrderList
	if _, err := GetOrder(map[string]interface{}{"id": id}, nil, &orderInfo); err != nil {
		return err
	}
	bidList := make([]*structs.MaterialBidList, 0)
	if _, err := GetBidList(map[string]interface{}{"pkg_id": orderInfo.PkgID}, nil, app.Page{}, &bidList); err != nil {
		return err
	}
	bidListMap := make(map[int][]*structs.MaterialBidList)
	bidMap := make(map[int]*structs.MaterialBidList)
	for _, v := range material.Params.RoomType {
		bidListMap[v.ID] = make([]*structs.MaterialBidList, 0)
	}
	for _, v := range bidList {
		bidMap[v.ID] = v
	}
	return nil
}

func GetTransportRate(baseRate float64, isElevator int, floorNum int) float64 {
	if isElevator == 0 && floorNum > 2 {
		baseRate = utils.FloatAdd(baseRate, utils.FloatMul(float64(floorNum-2), 0.005, -1), 4)
	}
	return baseRate
}

func CalcToilet(form1 form.MaterialBidDetailCalc1) (calc.PriceReturn, error) {
	var pkg models.MatPkg
	pkgInfo, _ := pkg.GetOne(map[string]interface{}{"id": form1.PkgID}, nil, nil)
	bidList := make([]*structs.MaterialBidList, 0)
	if _, err := GetBidList(map[string]interface{}{"pkg_id": form1.PkgID}, nil, app.Page{}, &bidList); err != nil {
		return calc.PriceReturn{}, err
	}
	bidListMap := make(map[int][]*structs.MaterialBidList)
	bidMap := make(map[int]*structs.MaterialBidList)
	for _, v := range material.Params.RoomType {
		bidListMap[v.ID] = make([]*structs.MaterialBidList, 0)
	}
	for _, v := range bidList {
		if v.CalcParam != "" {
			utils.JsonDecode(v.CalcParam).To(&v.CalcParamDecode)
		}
		bidMap[v.ID] = v
		bidListMap[v.RoomType] = append(bidListMap[v.RoomType], v)
	}

	transportRate := GetTransportRate(pkgInfo.TransportRate, 0, 0)

	// 套餐内
	var packagePrice calc.PackagePrice
	calcSetting := structs.MaterialBidCalcSetting{RoomNum: 0, ToiletNum: 1, RestaurantNum: 0, KitchenNum: 0}
	param := []structs.MaterialBidOrderParam{{RoomType: 4, RoomName: "卫生间", Area: form1.Area, Round: form1.Round, Hole: 0, Window: 0}}
	for _, v := range param {
		if v.RoomType == 4 {
			holeArea := utils.FloatMul(v.Hole, 2, -1)
			wallArea := utils.FloatMul(v.Round, 2.4, -1)
			calcSetting.ToiletWallArea = wallArea - holeArea
		}
	}
	var inclusivePrice calc.InclusivePrice
	var inclusiveCost calc.InclusiveCost

	formCalc := form.MaterialBidDetailCalc{}

	for k, v := range param {
		bidItems := bidListMap[0]
		//fmt.Println(v.RoomName+ " 面积："+utils.ToStr(v.Area)+ " 周长："+utils.ToStr(v.Round)+ " 门洞："+utils.ToStr(v.Hole)+ " 窗宽："+utils.ToStr(v.Window))
		//fmt.Println("====================================================")
		v.Items = make([]structs.MaterialBidOrderItem, 0)
		for _, bidItem := range bidItems {
			price := CalcBidItemMoney(v, bidItem, calcSetting, formCalc)
			if bidItem.Category == 30 || bidItem.Category == 31 {
				switch bidItem.Category {
				case 30:
					//fmt.Println("施工—-"+bidItem.BidName+"："+utils.ToStr(price))
					packagePrice.BuildPrice.Direct = utils.FloatAdd(packagePrice.BuildPrice.Direct, price, 4)
				case 31:
					//fmt.Println("主材—-"+bidItem.BidName+"："+utils.ToStr(price))
					packagePrice.Material = utils.FloatAdd(packagePrice.Material, price, 4)
				}
				v.Items = append(v.Items, structs.MaterialBidOrderItem{
					Price:   price,
					ID:      bidItem.ID,
					BidName: bidItem.BidName,
				})
			}
		}
		param[k] = v
		//fmt.Println("")
	}
	//packagePrice.BuildPrice.Transport = utils.FloatMul(packagePrice.BuildPrice.Direct, transportRate, 4)
	//packagePrice.BuildPrice.Manage = utils.FloatMul(utils.FloatAddSlice([]float64{packagePrice.BuildPrice.Direct, packagePrice.BuildPrice.Sanitation, packagePrice.BuildPrice.Transport}, -1), pkgInfo.ManageRate, 4)
	//packagePrice.BuildPrice.CementExtra = utils.FloatMul(houseParam.Area, 10, -1)
	//packagePrice.BuildPrice.Design = utils.FloatMul(houseParam.Area, pkgInfo.DesignFee, 4)
	packagePrice.BuildPrice.Total = packagePrice.BuildPrice.Direct
	packagePrice.BuildPrice.TotalCost = utils.FloatMul(pkgInfo.PackageRate, packagePrice.BuildPrice.Total, 4)
	packagePrice.BuildPrice.TotalCost = utils.FloatMul(1.15, packagePrice.BuildPrice.TotalCost, 4)

	// 套餐补贴成本
	//packagePrice.CostExtra = CalcPackageCostExtra(calcSetting)
	packagePrice.CostExtra = 0

	// 完工补贴
	packagePrice.FinishExtra = 0

	// 套餐总报价
	packagePrice.Cost = utils.FloatAddSlice([]float64{packagePrice.BuildPrice.TotalCost, packagePrice.Material, packagePrice.CostExtra, packagePrice.FinishExtra}, -1)
	packagePrice.Total = utils.FloatDiv(packagePrice.Cost, utils.FloatSub(1, pkgInfo.ToiletRate, -1), -1)
	//packagePrice.Total = utils.FloatDiv(packagePrice.Total, pkgInfo.DiscountRate, 4)

	//fmt.Println("定制品总金额："+ utils.ToStr(inclusivePrice.Total))
	//fmt.Println("------------")
	money := utils.FloatAddSlice([]float64{packagePrice.Total, 0, inclusivePrice.Total}, 0)
	//fmt.Println("总报价："+ utils.ToStr(money))
	//fmt.Println("------------")
	/*baseDiscount := utils.FloatDiv(utils.FloatSub(utils.FloatAdd(packagePrice.Total, inclusivePrice.Total, -1), inclusiveCost.Total, -1), packagePrice.Total, -1)
	if baseDiscount < pkgInfo.MinDiscount {
		total := utils.FloatSub(inclusiveCost.Total, utils.FloatMul(utils.FloatSub(1, pkgInfo.MinDiscount, -1), packagePrice.Total, -1), -1)
		inclusivePrice.Discount = utils.FloatSub(total, inclusivePrice.Total, -1)
		inclusivePrice.Total = total
		baseDiscount = pkgInfo.MinDiscount
		money = utils.FloatAddSlice([]float64{packagePrice.Total, 0, inclusivePrice.Total}, 0)
	}
	baseInterestRate := utils.FloatSub(1, utils.FloatDiv(packagePrice.Cost, utils.FloatSub(utils.FloatAdd(packagePrice.Total, inclusivePrice.Total, -1), inclusiveCost.Total, -1), -1), -1)
	interestRate := utils.FloatSub(1, utils.FloatDiv(utils.FloatSub(utils.FloatAdd(packagePrice.Cost, 0, -1), 0, -1), utils.FloatSubSlice([]float64{utils.FloatAddSlice([]float64{packagePrice.Total, inclusivePrice.Total, 0}, -1), inclusiveCost.Total, 0}, -1), -1), -1)*/
	return calc.PriceReturn{
		PackagePrice:         packagePrice.Total,
		PackagePriceDetail:   utils.JsonEncode(packagePrice),
		CustomizePrice:       0,
		CustomizePriceDetail: "",
		InclusivePrice:       inclusivePrice.Total,
		InclusivePriceDetail: utils.JsonEncode(inclusivePrice),
		InclusiveCost:        inclusiveCost.Total,
		InclusiveCostDetail:  utils.JsonEncode(inclusiveCost),
		BaseDiscount:         0,
		BaseInterestRate:     0,
		InterestRate:         0,
		HouseArea:            form1.Area,
		TotalPrice:           money,
		Customize:            "",
		Param:                utils.JsonEncode(param),
		TransportRate:        transportRate,
		IsElevator:           0,
		FloorNum:             0,
	}, nil
}

func Calc(form form.MaterialBidDetailCalc) (calc.PriceReturn, error) {
	var pkg models.MatPkg
	pkgInfo, _ := pkg.GetOne(map[string]interface{}{"id": form.PkgID}, nil, nil)
	if form.Type == 1 {
		var outline calc.Outline
		utils.JsonDecode(pkgInfo.Outline).To(&outline)
		var outlinePrice calc.OutlinePrice

		roomNum := float64(0)       // 房间数量
		kitchenNum := float64(0)    // 厨房数量
		toiletNum := float64(0)     // 卫生间数量
		addRoomNum := float64(0)    // 附加房间数量
		addKitchenNum := float64(0) // 附加厨房数量
		addToiletNum := float64(0)  // 附加卫生间数量
		for _, v := range form.HouseStyle {
			if v.Type == 1 {
				roomNum = utils.ToFloat64(v.Num)
			} else if v.Type == 3 {
				kitchenNum = utils.ToFloat64(v.Num)
			} else if v.Type == 4 {
				toiletNum = utils.ToFloat64(v.Num)
			}
		}
		if roomNum > outline.RoomNum {
			addRoomNum = roomNum - outline.RoomNum
		}
		if kitchenNum > outline.KitchenNum {
			addKitchenNum = kitchenNum - outline.KitchenNum
		}
		if toiletNum > outline.ToiletNum {
			addToiletNum = toiletNum - outline.ToiletNum
		}
		outlinePrice.Area = utils.FloatMul(form.Area, outline.InsideScale, -1)
		outlinePrice.RoomPrice = utils.FloatMul(addRoomNum, outline.RoomPrice, -1)
		outlinePrice.KitchenPrice = utils.FloatMul(addKitchenNum, outline.KitchenPrice, -1)
		outlinePrice.ToiletPrice = utils.FloatMul(addToiletNum, outline.ToiletPrice, -1)
		areaMax := float64(0)
		areaPrice := float64(0)
		areaMin := float64(0)
		areaPriceMin := float64(0)
		for _, v := range outline.AreaPrice {
			if v.Area <= outlinePrice.Area && v.Area > areaMax {
				areaMax = v.Area
				areaPrice = v.Price
			}
			if areaMin == 0 || areaMin > v.Area {
				areaMin = v.Area
				areaPriceMin = v.Price
			}
		}
		if areaMax == 0 {
			outlinePrice.Area = areaMin
			areaPrice = areaPriceMin
		}

		//outlinePrice.AreaPrice = utils.FloatMul(outlinePrice.Area, areaPrice, -1)
		outlinePrice.AreaPrice = areaPrice
		outlinePrice.DiscountPrice = utils.FloatAddSlice([]float64{outlinePrice.AreaPrice, outlinePrice.RoomPrice, outlinePrice.KitchenPrice, outlinePrice.ToiletPrice}, -1)

		for _, v := range outline.ExtraItem {
			extraMoney := float64(0)
			switch v.Type {
			case 0:
				extraMoney = v.Price
			case 1:
				extraMoney = utils.FloatMul(outlinePrice.Area, v.Price, -1)
			case 2:
				extraMoney = utils.FloatMul(roomNum, v.Price, -1)
			case 3:
				extraMoney = utils.FloatMul(kitchenNum, v.Price, -1)
			case 4:
				extraMoney = utils.FloatMul(toiletNum, v.Price, -1)
			case 5:
				extraMoney = utils.FloatMul(addRoomNum, v.Price, -1)
			case 6:
				extraMoney = utils.FloatMul(addKitchenNum, v.Price, -1)
			case 7:
				extraMoney = utils.FloatMul(addToiletNum, v.Price, -1)
			}
			outlinePrice.ExtraItemPrice = append(outlinePrice.ExtraItemPrice, calc.ExtraItemPrice{
				Name:  v.Name,
				Price: extraMoney,
			})
			outlinePrice.DiscountPrice = utils.FloatAdd(outlinePrice.DiscountPrice, extraMoney, -1)
		}

		outlinePrice.Total = utils.FloatDiv(outlinePrice.DiscountPrice, outline.DiscountScale, -1)

		/*compute1 := utils.FloatAddSlice([]float64{5218.1, utils.FloatMul(roomNum, 1570.3, -1), 9696.4, 5094.1, utils.FloatMul(5344.1, utils.FloatSub(toiletNum, 1, -1), -1)}, -1)
		compute2 := utils.FloatMul(utils.FloatSubSlice([]float64{Area, 5.4, utils.FloatMul(toiletNum, 3.6, -1)}, -1), 572, -1)
		compute3 := utils.FloatAdd(utils.FloatMul(5.4, 960.17, -1), utils.FloatMulSlice([]float64{toiletNum, 3.6, 960.17}, -1), -1)
		compute4 := utils.FloatAddSlice([]float64{compute1, compute2, compute3}, -1)
		compute5 := utils.FloatSub(compute4, utils.FloatMulSlice([]float64{Area, 0.4, 490}, -1), -1)
		compute5 = utils.FloatDiv(compute5, 0.546, -1)
		money := utils.FloatAdd(compute5, 69923, 0)*/
		return calc.PriceReturn{
			HouseArea:          form.Area,
			PackagePrice:       outlinePrice.DiscountPrice,
			PackagePriceDetail: utils.JsonEncode(outlinePrice),
			TotalPrice:         outlinePrice.Total,
			OutlinePrice:       outlinePrice,
		}, nil
	}
	bidList := make([]*structs.MaterialBidList, 0)
	if _, err := GetBidList(map[string]interface{}{"pkg_id": form.PkgID}, nil, app.Page{}, &bidList); err != nil {
		return calc.PriceReturn{}, err
	}
	bidListMap := make(map[int][]*structs.MaterialBidList)
	bidMap := make(map[int]*structs.MaterialBidList)
	for _, v := range material.Params.RoomType {
		bidListMap[v.ID] = make([]*structs.MaterialBidList, 0)
	}
	for _, v := range bidList {
		if v.CalcParam != "" {
			utils.JsonDecode(v.CalcParam).To(&v.CalcParamDecode)
		}
		bidMap[v.ID] = v
		bidListMap[v.RoomType] = append(bidListMap[v.RoomType], v)
	}

	transportRate := GetTransportRate(pkgInfo.TransportRate, form.IsElevator, form.FloorNum)

	// 套餐内
	var packagePrice calc.PackagePrice
	var toiletPrice calc.PackagePrice
	calcSetting := GetCalcSetting(form.HouseStyle)
	houseParam := structs.MaterialBidOrderParam{RoomType: 0, RoomName: "全房", Area: 0, Round: 0, Hole: 0, Window: 0}
	for _, v := range form.Param {
		if v.RoomType == 3 {
			calcSetting.KitchenHole = v.Hole
			holeArea := utils.FloatMul(v.Hole, 2, -1)
			wallArea := utils.FloatMul(v.Round, 2.4, -1)
			calcSetting.KitchenWallArea = wallArea - holeArea
		} else if v.RoomType == 4 {
			holeArea := utils.FloatMul(v.Hole, 2, -1)
			wallArea := utils.FloatMul(v.Round, 2.4, -1)
			calcSetting.ToiletWallArea = wallArea - holeArea
		} else if v.RoomType == 5 {
			calcSetting.BalconyArea = v.Area
			calcSetting.BalconyHole = v.Hole
			calcSetting.BalconyRound = v.Round
			calcSetting.BalconyWindow = v.Window
		}
		houseParam.Area = utils.FloatAdd(houseParam.Area, v.Area, 2)
	}
	if form.Area != 0 {
		houseParam.Area = form.Area
	}
	form.Param = append(form.Param, houseParam)
	var inclusivePrice calc.InclusivePrice
	var inclusiveCost calc.InclusiveCost
	for k, v := range form.Param {
		if v.RoomType == 4 && v.RoomName != "卫生间1" {
			bidItems := bidListMap[0]
			//fmt.Println(v.RoomName+ " 面积："+utils.ToStr(v.Area)+ " 周长："+utils.ToStr(v.Round)+ " 门洞："+utils.ToStr(v.Hole)+ " 窗宽："+utils.ToStr(v.Window))
			//fmt.Println("====================================================")
			v.Items = make([]structs.MaterialBidOrderItem, 0)
			for _, bidItem := range bidItems {
				price := CalcBidItemMoney(v, bidItem, calcSetting, form)
				if bidItem.Category == 30 || bidItem.Category == 31 {
					switch bidItem.Category {
					case 30:
						//fmt.Println("施工—-"+bidItem.BidName+"："+utils.ToStr(price))
						toiletPrice.BuildPrice.Direct = utils.FloatAdd(toiletPrice.BuildPrice.Direct, price, 4)
					case 31:
						//fmt.Println("主材—-"+bidItem.BidName+"："+utils.ToStr(price))
						toiletPrice.Material = utils.FloatAdd(toiletPrice.Material, price, 4)
					}
					v.Items = append(v.Items, structs.MaterialBidOrderItem{
						Price:   price,
						ID:      bidItem.ID,
						BidName: bidItem.BidName,
					})
				}
			}
		} else {
			bidItems := bidListMap[v.RoomType]
			//fmt.Println(v.RoomName+ " 面积："+utils.ToStr(v.Area)+ " 周长："+utils.ToStr(v.Round)+ " 门洞："+utils.ToStr(v.Hole)+ " 窗宽："+utils.ToStr(v.Window))
			//fmt.Println("====================================================")
			v.Items = make([]structs.MaterialBidOrderItem, 0)
			for _, bidItem := range bidItems {
				price := CalcBidItemMoney(v, bidItem, calcSetting, form)
				if bidItem.Level == 1 || bidItem.Level == 3 {
					switch bidItem.Category {
					case 1:
						packagePrice.BuildPrice.Direct = utils.FloatAdd(packagePrice.BuildPrice.Direct, price, 4)
					case 2:
						packagePrice.Material = utils.FloatAdd(packagePrice.Material, price, 4)
					case 12:
						inclusivePrice.Diy = utils.FloatAdd(inclusivePrice.Diy, price, 4)
					case 13:
						inclusivePrice.Furniture = utils.FloatAdd(inclusivePrice.Furniture, price, 4)
					case 14:
						inclusivePrice.Lamp = utils.FloatAdd(inclusivePrice.Lamp, price, 4)
					case 15:
						inclusivePrice.Curtain = utils.FloatAdd(inclusivePrice.Curtain, price, 4)
					case 21:
						inclusiveCost.Diy = utils.FloatAdd(inclusiveCost.Diy, price, 4)
					case 22:
						inclusiveCost.Furniture = utils.FloatAdd(inclusiveCost.Furniture, price, 4)
					case 23:
						inclusiveCost.Lamp = utils.FloatAdd(inclusiveCost.Lamp, price, 4)
					case 24:
						inclusiveCost.Curtain = utils.FloatAdd(inclusiveCost.Curtain, price, 4)
					case 25:
						inclusiveCost.Prize = utils.FloatAdd(inclusiveCost.Prize, price, 4)
					case 26:
						inclusiveCost.Deposit = utils.FloatAdd(inclusiveCost.Deposit, price, 4)
					case 27:
						inclusiveCost.Appliances = utils.FloatAdd(inclusiveCost.Appliances, price, 4)
					}
					v.Items = append(v.Items, structs.MaterialBidOrderItem{
						Price:   price,
						ID:      bidItem.ID,
						BidName: bidItem.BidName,
					})
				}
			}
		}
		form.Param[k] = v
		//fmt.Println("")
	}
	packagePrice.BuildPrice.Sanitation = utils.FloatMul(packagePrice.BuildPrice.Direct, transportRate, 4)
	packagePrice.BuildPrice.Transport = utils.FloatMul(packagePrice.BuildPrice.Direct, transportRate, 4)
	packagePrice.BuildPrice.Manage = utils.FloatMul(utils.FloatAddSlice([]float64{packagePrice.BuildPrice.Direct, packagePrice.BuildPrice.Sanitation, packagePrice.BuildPrice.Transport}, -1), pkgInfo.ManageRate, 4)
	packagePrice.BuildPrice.CementExtra = utils.FloatMul(houseParam.Area, 10, -1)
	packagePrice.BuildPrice.Design = utils.FloatMul(houseParam.Area, pkgInfo.DesignFee, 4)
	packagePrice.BuildPrice.Total = utils.FloatAddSlice([]float64{packagePrice.BuildPrice.Direct, packagePrice.BuildPrice.Manage, packagePrice.BuildPrice.Sanitation, packagePrice.BuildPrice.Transport, packagePrice.BuildPrice.Design, packagePrice.BuildPrice.CementExtra}, 4)
	packagePrice.BuildPrice.TotalCost = utils.FloatMul(pkgInfo.PackageRate, packagePrice.BuildPrice.Total, 4)

	// 套餐补贴成本
	//packagePrice.CostExtra = CalcPackageCostExtra(calcSetting)
	packagePrice.CostExtra = utils.FloatAddSlice([]float64{2000, utils.FloatMul(12, houseParam.Area, 4)}, 4)

	// 完工补贴
	packagePrice.FinishExtra = 500 + 1500 + 350

	// 套餐总报价
	packagePrice.Cost = utils.FloatAddSlice([]float64{packagePrice.BuildPrice.TotalCost, packagePrice.Material, packagePrice.CostExtra, packagePrice.FinishExtra}, -1)
	packagePrice.Total = utils.FloatDiv(packagePrice.Cost, utils.FloatSub(1, pkgInfo.ProfitRate, -1), -1)
	if form.Area > 100 {
		packagePrice.Total = utils.FloatDiv(packagePrice.Total, pkgInfo.DiscountRate100, 4)
	} else {
		packagePrice.Total = utils.FloatDiv(packagePrice.Total, pkgInfo.DiscountRate, 4)
	}
	toiletPrice.BuildPrice.Total = toiletPrice.BuildPrice.Direct
	toiletPrice.BuildPrice.TotalCost = utils.FloatMul(pkgInfo.PackageRate, toiletPrice.BuildPrice.Total, 4)
	toiletPrice.BuildPrice.TotalCost = utils.FloatMul(1.15, toiletPrice.BuildPrice.TotalCost, 4)
	toiletPrice.CostExtra = 0
	toiletPrice.FinishExtra = 0
	toiletPrice.Cost = utils.FloatAddSlice([]float64{toiletPrice.BuildPrice.TotalCost, toiletPrice.Material, toiletPrice.CostExtra, toiletPrice.FinishExtra}, -1)
	toiletPrice.Total = utils.FloatDiv(toiletPrice.Cost, utils.FloatSub(1, pkgInfo.ToiletRate, -1), -1)

	//fmt.Println("总面积："+ utils.ToStr(houseParam.Area))
	//fmt.Println("套餐内施工直接费："+ utils.ToStr(packagePrice.BuildPrice.Direct))
	//fmt.Println("套餐内施工制图费："+ utils.ToStr(packagePrice.BuildPrice.Design))
	//fmt.Println("套餐内施工搬运费："+ utils.ToStr(packagePrice.BuildPrice.Transport))
	//fmt.Println("套餐内施工卫生费："+ utils.ToStr(packagePrice.BuildPrice.Sanitation))
	//fmt.Println("套餐内施工管理费："+ utils.ToStr(packagePrice.BuildPrice.Manage))
	//fmt.Println("套餐内水泥补贴："+ utils.ToStr(packagePrice.BuildPrice.CementExtra))
	//fmt.Println("套餐内施工总价："+ utils.ToStr(packagePrice.BuildPrice.Total))
	//fmt.Println("套餐内施工成本："+ utils.ToStr(packagePrice.BuildPrice.TotalCost))
	//fmt.Println("套餐内主材成本："+ utils.ToStr(packagePrice.Material))
	//fmt.Println("套餐内补贴成本："+ utils.ToStr(packagePrice.CostExtra))
	//fmt.Println("套餐内完工补贴："+ utils.ToStr(packagePrice.FinishExtra))
	//fmt.Println("套餐内总报价："+ utils.ToStr(packagePrice.Total)+"（施工成本+主材成本+补贴成本+完工补贴）/ "+utils.ToStr(1-pkgInfo.ProfitRate)+"）/ 0.88")

	// 个性化
	var customizePrice calc.CustomizePrice
	for category, items := range form.Customize {
		money := float64(0)
		for k, v := range items {
			if v.Num <= 0 {
				continue
			}
			bidItem := bidMap[v.ID]
			if bidItem != nil {
				price := CalcBidCustomizeMoney(v.Num, bidItem)
				money = utils.FloatAdd(money, price, 4)
				v.Total = price
				items[k] = v
			}
		}
		switch category {
		case 3:
			customizePrice.BuildPrice.Direct = money
		case 4:
			customizePrice.MaterialAdd = money
		case 5:
			customizePrice.MaterialDel = 0 - money
		case 6:
			customizePrice.MaterialUpgrade = money
		case 11:
			customizePrice.Design = money
		}
	}
	//customizePrice.BuildPrice.Transport = utils.FloatMul(customizePrice.BuildPrice.Direct, pkgInfo.TransportRate, 4)
	//customizePrice.BuildPrice.Sanitation= utils.FloatMul(customizePrice.BuildPrice.Direct, pkgInfo.SanitationRate, 4)
	//customizePrice.BuildPrice.Manage = utils.FloatMul(utils.FloatAddSlice([]float64{customizePrice.BuildPrice.Direct, customizePrice.BuildPrice.Transport, customizePrice.BuildPrice.Sanitation}, -1), pkgInfo.ManageRate, 4)
	//customizePrice.BuildPrice.Total = utils.FloatAddSlice([]float64{customizePrice.BuildPrice.Direct, customizePrice.BuildPrice.Manage,customizePrice.BuildPrice.Sanitation, customizePrice.BuildPrice.Transport}, 4)
	customizePrice.BuildPrice.Total = customizePrice.BuildPrice.Direct
	customizePrice.Build = customizePrice.BuildPrice.Total
	customizePriceRate := utils.FloatAddSlice([]float64{customizePrice.BuildPrice.Direct, customizePrice.MaterialAdd, customizePrice.MaterialUpgrade}, -1)
	customizePrice.Transport = utils.FloatMul(customizePriceRate, transportRate, 4)
	customizePrice.Sanitation = utils.FloatMul(customizePriceRate, transportRate, 4)
	customizePrice.Manage = utils.FloatMul(utils.FloatAddSlice([]float64{customizePriceRate, customizePrice.Transport, customizePrice.Sanitation}, -1), pkgInfo.ManageRate, 4)
	customizePrice.Total = utils.FloatAddSlice([]float64{customizePrice.MaterialAdd, customizePrice.MaterialDel, customizePrice.MaterialUpgrade, customizePrice.Build, customizePrice.Design}, -1)
	customizePrice.Total = utils.FloatAddSlice([]float64{customizePrice.Total, customizePrice.Transport, customizePrice.Sanitation, customizePrice.Manage}, 4)
	customizePrice.Cost = utils.FloatAddSlice([]float64{utils.FloatMul(customizePrice.Build, utils.FloatSub(1, pkgInfo.BuildCustomizeRate, -1), -1), utils.FloatMul(utils.FloatAddSlice([]float64{customizePrice.MaterialAdd, customizePrice.MaterialDel, customizePrice.MaterialUpgrade}, -1), utils.FloatSub(1, pkgInfo.MaterialCustomizeRate, -1), -1), customizePrice.Design}, -1)

	//fmt.Println("------------")
	//fmt.Println("个性化施工增项报价："+ utils.ToStr(customizePrice.Build))
	//fmt.Println("个性化主材增项报价："+ utils.ToStr(customizePrice.MaterialAdd))
	//fmt.Println("个性化主材减项报价："+ utils.ToStr(customizePrice.MaterialDel))
	//fmt.Println("个性化主材升级报价："+ utils.ToStr(customizePrice.MaterialUpgrade))
	//fmt.Println("个性化设计费："+ utils.ToStr(customizePrice.Design))
	//fmt.Println("个性化总报价："+ utils.ToStr(customizePrice.Total))
	//fmt.Println("------------")
	//fmt.Println("定制品："+ utils.ToStr(inclusivePrice.Diy))
	//fmt.Println("家具："+ utils.ToStr(inclusivePrice.Furniture))
	//fmt.Println("灯具："+ utils.ToStr(inclusivePrice.Lamp))
	//fmt.Println("窗帘："+ utils.ToStr(inclusivePrice.Curtain))
	if true || form.IsInclusive == 1 {
		inclusivePrice.Total = utils.FloatAddSlice([]float64{inclusivePrice.Diy, inclusivePrice.Furniture, inclusivePrice.Lamp, inclusivePrice.Curtain}, -1)
		inclusiveCost.Total = utils.FloatAddSlice([]float64{inclusiveCost.Diy, inclusiveCost.Furniture, inclusiveCost.Lamp, inclusiveCost.Curtain, inclusiveCost.Prize, inclusiveCost.Deposit, inclusiveCost.Appliances}, -1)
	} else {
		inclusivePrice.Total = 0
		inclusiveCost.Total = 0
	}
	//fmt.Println("定制品总金额："+ utils.ToStr(inclusivePrice.Total))
	//fmt.Println("------------")
	money := utils.FloatAddSlice([]float64{packagePrice.Total, customizePrice.Total, inclusivePrice.Total, toiletPrice.Total}, 0)
	//fmt.Println("总报价："+ utils.ToStr(money))
	//fmt.Println("------------")
	baseDiscount := utils.FloatDiv(utils.FloatSub(utils.FloatAdd(packagePrice.Total, inclusivePrice.Total, -1), inclusiveCost.Total, -1), packagePrice.Total, -1)
	if baseDiscount < pkgInfo.MinDiscount {
		//total := utils.FloatSub(inclusiveCost.Total, utils.FloatMul(utils.FloatSub(1, pkgInfo.MinDiscount, -1), packagePrice.Total, -1), -1)
		//inclusivePrice.Discount = utils.FloatSub(total, inclusivePrice.Total, -1)
		//inclusivePrice.Total = total
		baseDiscount = pkgInfo.MinDiscount
		money = utils.FloatAddSlice([]float64{packagePrice.Total, customizePrice.Total, inclusivePrice.Total}, 0)
	}
	baseInterestRate := utils.FloatSub(1, utils.FloatDiv(packagePrice.Cost, utils.FloatSub(utils.FloatAdd(packagePrice.Total, inclusivePrice.Total, -1), inclusiveCost.Total, -1), -1), -1)
	interestRate := utils.FloatSub(1, utils.FloatDiv(utils.FloatSub(utils.FloatAdd(packagePrice.Cost, customizePrice.Cost, -1), customizePrice.Design, -1), utils.FloatSubSlice([]float64{utils.FloatAddSlice([]float64{packagePrice.Total, inclusivePrice.Total, customizePrice.Total}, -1), inclusiveCost.Total, customizePrice.Design}, -1), -1), -1)
	if form.PkgID == 45 || form.PkgID == 50 {
		if form.Area == 80 {
			if form.HouseStyle[0].Num == 2 && form.HouseStyle[1].Num <= 2 && form.HouseStyle[2].Num == 1 && form.HouseStyle[3].Num == 1 && form.HouseStyle[4].Num == 1 {
				money = 99980
			}
		}
	}
	if form.PkgID == 48 {
		if form.Area == 100 {
			if form.HouseStyle[0].Num == 2 && form.HouseStyle[1].Num <= 2 && form.HouseStyle[2].Num == 1 && form.HouseStyle[3].Num == 1 && form.HouseStyle[4].Num == 1 {
				money = 99980
			}
		}
	}
	if form.PkgID == 47 {
		if form.Area == 100 {
			if form.HouseStyle[0].Num == 2 && form.HouseStyle[1].Num <= 2 && form.HouseStyle[2].Num == 1 && form.HouseStyle[3].Num == 1 && form.HouseStyle[4].Num == 1 {
				money = 121800
			}
		}
	}
	return calc.PriceReturn{
		PackagePrice:         packagePrice.Total,
		PackagePriceDetail:   utils.JsonEncode(packagePrice),
		CustomizePrice:       customizePrice.Total,
		CustomizePriceDetail: utils.JsonEncode(customizePrice),
		InclusivePrice:       inclusivePrice.Total,
		InclusivePriceDetail: utils.JsonEncode(inclusivePrice),
		InclusiveCost:        inclusiveCost.Total,
		InclusiveCostDetail:  utils.JsonEncode(inclusiveCost),
		ToiletPrice:          toiletPrice.Total,
		ToiletPriceDetail:    utils.JsonEncode(toiletPrice),
		BaseDiscount:         baseDiscount,
		BaseInterestRate:     baseInterestRate,
		InterestRate:         interestRate,
		HouseArea:            houseParam.Area,
		TotalPrice:           money,
		Customize:            utils.JsonEncode(form.Customize),
		Param:                utils.JsonEncode(form.Param),
		TransportRate:        transportRate,
		IsElevator:           form.IsElevator,
		FloorNum:             form.FloorNum,
	}, nil
}

func getOrderMap(f form.MaterialBidOrderAdd) (map[string]interface{}, error) {
	res, err := Calc(form.MaterialBidDetailCalc{
		PkgID:         f.PkgID,
		Type:          f.Type,
		Area:          f.Area,
		Param:         f.Param,
		HouseStyle:    f.HouseStyle,
		Customize:     f.Customize,
		IsElevator:    f.IsElevator,
		InclusiveArea: f.InclusiveArea,
		FloorNum:      f.FloorNum,
	})
	if err != nil {
		return nil, err
	}
	orderMap := map[string]interface{}{
		"pkg_id":                 f.PkgID,
		"type":                   f.Type,
		"customer_name":          f.CustomerName,
		"customer_phone":         f.CustomerPhone,
		"house_address":          f.HouseAddress,
		"house_area":             res.HouseArea,
		"house_style":            utils.JsonEncode(f.HouseStyle),
		"param":                  res.Param,
		"customize":              res.Customize,
		"user_id":                user.CreateNewUser(f.CustomerName, f.CustomerPhone),
		"package_price":          res.PackagePrice,
		"package_price_detail":   res.PackagePriceDetail,
		"customize_price":        res.CustomizePrice,
		"customize_price_detail": res.CustomizePriceDetail,
		"inclusive_price":        res.InclusivePrice,
		"inclusive_price_detail": res.InclusivePriceDetail,
		"inclusive_cost":         res.InclusiveCost,
		"inclusive_cost_detail":  res.InclusiveCostDetail,
		"toilet_price":           res.ToiletPrice,
		"toilet_price_detail":    res.ToiletPriceDetail,
		"total_price":            res.TotalPrice,
		"base_discount":          res.BaseDiscount,
		"base_interest_rate":     res.BaseInterestRate,
		"interest_rate":          res.InterestRate,
		"profit_rate":            res.ProfitRate,
		"is_elevator":            res.IsElevator,
		"floor_num":              res.FloorNum,
		"inclusive_area":         f.InclusiveArea,
		"transport_rate":         res.TransportRate,
	}
	return orderMap, nil
}

func EditOrder(f form.MaterialBidOrderAdd, id int) (int64, error) {
	orderMap, err := getOrderMap(f)
	if err != nil {
		return 0, err
	}
	return db.Update(MatBidOrder.TableName(), map[string]interface{}{"id": id}, orderMap)
}

func UpdateOrder(id int) (int64, error) {
	var orderInfo structs.MaterialBidOrderList
	if _, err := GetOrder(map[string]interface{}{"id": id}, nil, &orderInfo); err != nil {
		return 0, err
	}
	var houseStyle []structs.HouseStyle
	utils.JsonDecode(orderInfo.HouseStyle).To(&houseStyle)
	utils.JsonDecode(orderInfo.Param).To(&orderInfo.ParamDecode)
	utils.JsonDecode(orderInfo.Customize).To(&orderInfo.CustomizeDecode)
	orderInfo.ParamDecode = orderInfo.ParamDecode[:len(orderInfo.ParamDecode)-1]

	addForm := form.MaterialBidOrderAdd{
		PkgID:         orderInfo.PkgID,
		AdminID:       orderInfo.AdminID,
		CustomerPhone: orderInfo.CustomerPhone,
		CustomerName:  orderInfo.CustomerName,
		HouseStyle:    houseStyle,
		HouseAddress:  orderInfo.HouseAddress,
		Param:         orderInfo.ParamDecode,
		Customize:     orderInfo.CustomizeDecode,
	}
	return EditOrder(addForm, id)
}

func AddOrder(f form.MaterialBidOrderAdd) (int64, error) {
	orderMap, err := getOrderMap(f)
	if err != nil {
		return 0, err
	}
	orderMap["admin_id"] = f.AdminID
	return db.InsertOne(MatBidOrder.TableName(), orderMap)
}

func RemarkOrder(form form.OrderRemark, id int) error {
	db.Update(MatBidOrder.TableName(), map[string]interface{}{"id": id}, map[string]interface{}{"remarks": form.Content})
	return nil
}

func FinishOrder(id int) error {
	_, err := db.Update(MatBidOrder.TableName(), map[string]interface{}{"id": id}, map[string]interface{}{"state": bidParam.OrderState.Finished})
	return err
}

func DelOrder(id int) error {
	_, err := db.DeleteSoft(MatBidOrder.TableName(), map[string]interface{}{"id": id})
	return err
}