pm/services/budget2/pkg2024/pkgitem.go

package pkg2024

import (
	"errors"
	"math"
	"zhiyuan/models/final"
	"zhiyuan/pkg/db"
	"zhiyuan/pkg/utils"
)

var PkgItems = map[int][]PkgItemObject{
	-1: {
		{
			Item: "水电基础",
			NumberCalc: func(context *ItemContext) (float64, error) {
				return context.Pkg.RoomData.Pkg.Area, nil
			},
		},
		{
			Item: "水电安装", Number: 1,
		},
		{
			Item: "粉线槽",
			NumberCalc: func(context *ItemContext) (float64, error) {
				return context.Pkg.RoomData.Pkg.Area, nil
			},
		},
		{
			Item: "天棚、墙面批嵌",
			NumberCalc: func(context *ItemContext) (float64, error) {
				return utils.FloatMul(context.Pkg.RoomData.Pkg.Area, 2.5, 2), nil
			},
		},
		{
			Item: "天棚、墙面乳胶漆",
			NumberCalc: func(context *ItemContext) (float64, error) {
				return utils.FloatMul(context.Pkg.RoomData.Pkg.Area, 2.5, 2), nil
			},
		},
		{
			Item: "封包管道(单管或双管)",
			NumberCalc: func(context *ItemContext) (float64, error) {
				return float64(context.Pkg.RoomData.Pkg.Layout[2] + context.Pkg.RoomData.Pkg.Layout[3] + context.Pkg.RoomData.Pkg.Layout[4]), nil
			},
		},
		{
			Region: "地漏",
			NumberCalc: func(context *ItemContext) (float64, error) {
				num := context.Pkg.RoomData.Pkg.Layout[3] * 2
				if context.Pkg.RoomData.Pkg.Layout[4] > 0 {
					num += 1
				}
				return float64(num), nil
			},
			Unit:           "个",
			ControlPrice:   map[int]float64{A10: 21, A8: 28, A5: 21, ZZ1_0: 28},
			DeductionPrice: map[int]float64{A10: 20, A8: 20, A5: 20, ZZ1_0: 20},
		},
		{
			Region: "角阀",
			NumberCalc: func(context *ItemContext) (float64, error) {
				return float64(context.Pkg.RoomData.Pkg.Layout[2]*4 + context.Pkg.RoomData.Pkg.Layout[3]*3 + context.Pkg.RoomData.Pkg.Layout[4]*2), nil
			},
			Unit:           "个",
			ControlPrice:   map[int]float64{A10: 17, A8: 17, A5: 17, ZZ1_0: 17},
			DeductionPrice: map[int]float64{A10: 16, A8: 16, A5: 16, ZZ1_0: 16},
		},
		{
			Item:   "开关面板控额",
			Region: "开关面板",
			NumberCalc: func(context *ItemContext) (float64, error) {
				return 1, nil
			},
			ControlPriceCalc: func(context *ItemContext) (float64, error) {
				prices := map[int]float64{A10: 9.8, A8: 8, A5: 5.5, ZZ1_0: 8}
				num := 65
				if context.Pkg.RoomData.Pkg.Layout[0] > 2 {
					num += (context.Pkg.RoomData.Pkg.Layout[0] - 2) * 13
				}
				if context.Pkg.RoomData.Pkg.Layout[3] > 1 {
					num += (context.Pkg.RoomData.Pkg.Layout[3] - 1) * 4
				}
				if context.Pkg.RoomData.Pkg.Layout[4] > 1 {
					num += (context.Pkg.RoomData.Pkg.Layout[4] - 1) * 3
				}

				return utils.FloatMul(prices[context.Pkg.RoomData.Pkg.Type], float64(num), -1), nil
			},
			DeductionPriceCalc: func(context *ItemContext) (float64, error) {
				deductions := map[int]float64{A10: 700, A8: 550, A5: 400, ZZ1_0: 550}
				add := map[int]float64{A10: 150, A8: 110, A5: 100, ZZ1_0: 110}
				price := deductions[context.Pkg.RoomData.Pkg.Type]
				if context.Pkg.RoomData.Pkg.Layout[0] > 2 {
					price += float64(context.Pkg.RoomData.Pkg.Layout[0]-2) * add[context.Pkg.RoomData.Pkg.Type]
				}

				return price, nil
			},
		},
	},
	0: {
		{
			Region:         "木门",
			Number:         1,
			Unit:           "樘",
			ControlPrice:   map[int]float64{A10: 1300, A8: 850, A5: 700, ZZ1_0: 850},
			DeductionPrice: map[int]float64{A10: 1050, A8: 820, A5: 700, ZZ1_0: 820},
			MaterialAdditionalItemCalc: func(context *ItemContext) ([]PersonalItem, error) {
				items := make([]PersonalItem, 0)
				mat := context.GetMat(context.Region.Material)
				if mat != nil {
					if context.Space.DoorwayHeight > 2.2 {
						number := math.Ceil(utils.FloatMul(utils.FloatSub(context.Space.DoorwayHeight, 2.2, -1), 100, -1))
						total := math.Round(utils.FloatMul(15, number, 3))
						items = append(items, PersonalItem{
							Name:   context.GetSpaceName() + " 木门(" + mat.Brand + " " + mat.Series + " " + mat.Model + " " + mat.Specs + " " + mat.Color + ") 超高度",
							Unit:   "cm",
							Number: number,
							Price:  15,
							Total:  total,
							Index:  -1,
						})
					}
					if context.Space.DoorwayWidth > 0.9 {
						number := math.Ceil(utils.FloatMul(utils.FloatSub(context.Space.DoorwayWidth, 0.9, -1), 100, -1))
						total := math.Round(utils.FloatMul(15, number, 3))
						items = append(items, PersonalItem{
							Name:   context.GetSpaceName() + " 木门(" + mat.Brand + " " + mat.Series + " " + mat.Model + " " + mat.Specs + " " + mat.Color + ") 超宽度",
							Unit:   "cm",
							Number: number,
							Price:  15,
							Total:  total,
							Index:  -1,
						})
					}
					if context.Space.DoorwayWallThickness > 0.28 {
						number := math.Ceil(utils.FloatMul(utils.FloatSub(context.Space.DoorwayWallThickness, 0.28, -1), 100, -1))
						total := math.Round(utils.FloatMul(25, number, 3))
						items = append(items, PersonalItem{
							Name:   context.GetSpaceName() + " 木门(" + mat.Brand + " " + mat.Series + " " + mat.Model + " " + mat.Specs + " " + mat.Color + ") 超墙厚",
							Unit:   "cm",
							Number: number,
							Price:  25,
							Total:  total,
							Index:  -1,
						})
					}
				}
				return items, nil
			},
		},
		{
			Item: "安装门槛石",
			NumberCalc: func(context *ItemContext) (float64, error) {
				return context.Space.DoorwayWidth, nil
			},
		},
		{
			Region: "门槛石",
			NumberCalc: func(context *ItemContext) (float64, error) {
				return context.Space.DoorwayWidth, nil
			},
			ConvertCalc: func(context *ItemContext) (float64, error) {
				return float64(context.Space.DoorwayWallThickness), nil
			},
			Unit:         "m",
			ControlPrice: map[int]float64{A10: 89, A8: 89, A5: 0, ZZ1_0: 89},
			AdditionalMaterialCalc: func(context *ItemContext) ([]MaterialItem, error) {
				mat := context.GetMat(1610)
				if mat == nil {
					return nil, errors.New("找不到材料: " + db.ToString(1610))
				}
				typ, ok := context.MatTypeCache[mat.TypeId]
				if !ok {
					return nil, errors.New("找不到材料类型: " + db.ToString(mat.TypeId))
				}
				total := utils.FloatMul(mat.Price, context.Space.DoorwayWidth, 3)
				materials := []MaterialItem{{
					Material:   1610,
					Name:       mat.Brand + " " + mat.Series + " " + mat.Model + " " + mat.Specs + " " + mat.Color,
					Type:       "门槛石",
					Unit:       typ.Unit,
					Number:     context.Space.DoorwayWidth,
					Price:      mat.Price,
					Total:      total,
					CostNumber: context.Space.DoorwayWidth,
					CostTotal:  total,
					Index:      -1,
				}}
				if context.Region.Material == 52 || context.Region.Material == 53 || context.Region.Material == 54 {
					mat := context.GetMat(55)
					if mat == nil {
						return nil, errors.New("找不到材料: " + db.ToString(55))
					}
					typ, ok := context.MatTypeCache[mat.TypeId]
					if !ok {
						return nil, errors.New("找不到材料类型: " + db.ToString(mat.TypeId))
					}
					number := utils.FloatMul(8, context.Space.DoorwayWidth, 3)
					total := utils.FloatMul(mat.Price, number, 3)
					materials = append(materials, MaterialItem{
						Material:   55,
						Name:       mat.Brand + " " + mat.Series + " " + mat.Model + " " + mat.Specs + " " + mat.Color,
						Type:       "钢筋成本",
						Unit:       typ.Unit,
						Number:     number,
						Price:      mat.Price,
						Total:      total,
						CostNumber: number,
						CostTotal:  total,
						Index:      -1,
					})
				}
				return materials, nil
			},
			NoUpgrade: true,
		},
		{
			Item: "小窗台大理石安装",
			NumberCalc: func(context *ItemContext) (float64, error) {
				num := float64(0)
				if context.Space.Windows != nil {
					for _, window := range context.Space.Windows {
						if window.Width <= 0.2 {
							num = utils.FloatAdd(num, window.Length, -1)
						}
					}
				}
				return num, nil
			},
		},
		{
			Item: "窗台大理石安装 宽度>200MM<700MM",
			NumberCalc: func(context *ItemContext) (float64, error) {
				num := float64(0)
				if context.Space.Windows != nil {
					for _, window := range context.Space.Windows {
						if window.Width > 0.2 && window.Width < 0.7 {
							num = utils.FloatAdd(num, window.Length, -1)
						}
					}
				}
				return num, nil
			},
		},
		{
			Item: "窗台大理石安装 宽度≥700MM",
			NumberCalc: func(context *ItemContext) (float64, error) {
				num := float64(0)
				if context.Space.Windows != nil {
					for _, window := range context.Space.Windows {
						if window.Width >= 0.7 {
							num = utils.FloatAdd(num, window.Length, -1)
						}
					}
				}
				return num, nil
			},
		},
		{
			Region: "窗台石",
			NumberCalc: func(context *ItemContext) (float64, error) {
				num := float64(0)
				if context.Space.Windows != nil {
					for _, window := range context.Space.Windows {
						if window.Width > 0 {
							num = utils.FloatAdd(num, utils.FloatAdd(window.Length, 0.1, -1), -1)
						}
					}
				}
				return num, nil
			},
			ConvertCalc: func(context *ItemContext) (float64, error) {
				num := float64(0)
				if context.Space.Windows != nil {
					for _, window := range context.Space.Windows {
						if window.Width > 0 {
							num = utils.FloatAdd(num, utils.FloatAdd(window.Length, 0.1, -1), -1)
						}
					}
				}
				mnum := float64(0)
				if context.Space.Windows != nil {
					for _, window := range context.Space.Windows {
						if window.Width > 0 {
							mnum = utils.FloatAdd(num, utils.FloatMul(utils.FloatAdd(window.Length, 0.1, -1), window.Width, -1), -1)
						}
					}
				}
				return utils.FloatDiv(num, mnum, -1), nil
			},
			MaterialNumberCalc: func(context *ItemContext) (float64, error) {
				num := float64(0)
				if context.Space.Windows != nil {
					for _, window := range context.Space.Windows {
						if window.Length > 0 {
							num = utils.FloatAdd(num, utils.FloatMul(utils.FloatAdd(window.Length, 0.1, -1), window.Width, -1), -1)
						}
					}
				}
				return num, nil
			},
			Unit:         "m",
			ControlPrice: map[int]float64{A10: 143, A8: 143, A5: 143, ZZ1_0: 143},
			AdditionalMaterialCalc: func(context *ItemContext) ([]MaterialItem, error) {
				num := float64(0)
				if context.Space.Windows != nil {
					for _, window := range context.Space.Windows {
						if window.Width > 0 {
							num = utils.FloatAdd(num, utils.FloatAdd(window.Length, 0.1, -1), -1)
						}
					}
				}
				mat := context.GetMat(1609)
				if mat == nil {
					return nil, errors.New("找不到材料: " + db.ToString(1609))
				}
				typ, ok := context.MatTypeCache[mat.TypeId]
				if !ok {
					return nil, errors.New("找不到材料类型: " + db.ToString(mat.TypeId))
				}
				total := utils.FloatMul(mat.Price, num, 3)
				return []MaterialItem{{
					Material:   1609,
					Name:       mat.Brand + " " + mat.Series + " " + mat.Model + " " + mat.Specs + " " + mat.Color,
					Type:       "窗台石",
					Unit:       typ.Unit,
					Number:     num,
					Price:      mat.Price,
					Total:      total,
					CostNumber: num,
					CostTotal:  total,
					Index:      -1,
				}}, nil
			},
			NoUpgrade: true,
		},
		{
			ItemSelect: func(context *ItemContext) (string, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return "", nil
				}
				if mat.TypeId == 110 {
					return "地面找平", nil
				}
				if mat.TypeId == 6 {
					return "地面贴砖（600*1200mm）", nil
				}
				if mat.TypeId == 7 {
					return "地面贴砖（750*1500mm）", nil
				}
				return "地面贴砖（300*300mm-800*800mm）", nil
			},
			Region: "地面",
			NumberCalc: func(context *ItemContext) (float64, error) {
				return context.Space.Area, nil
			},
			MaterialNumberCalc: func(context *ItemContext) (float64, error) {
				return 0, nil
			},
			DiffPriceCalc: func(context *ItemContext) (float64, error) {
				price, err := context.Item.GetPrice(context)
				if err != nil {
					return 0, err
				}
				if price < 38 {
					return 0, nil
				}
				return utils.FloatSub(price, 38, -1), nil
			},
		},
		{
			Region: "地面",
			NumberCalc: func(context *ItemContext) (float64, error) {
				return context.Space.Area, nil
			},
			LossCalc: func(context *ItemContext) (float64, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return 1, nil
				}
				loss := map[int64]float64{
					110: 1, 10: 1.08, 9: 1.08, 7: 1.1, 6: 1.1, 5: 1.1, 4: 1.08, 3: 1.08,
				}
				return loss[mat.TypeId], nil
			},
			ConvertCalc: func(context *ItemContext) (float64, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return 1, nil
				}
				area := map[int64]float64{
					110: 1, 10: 0.09, 9: 0.18, 7: 1.125, 6: 0.72, 5: 0.64, 4: 0.16, 3: 0.32,
				}
				return utils.FloatDiv(1, area[mat.TypeId], -1), nil
			},
			CostLossCalc: func(context *ItemContext) (float64, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return 1, nil
				}
				loss := map[int64]float64{
					110: 1.1, 10: 1.2, 9: 1.2, 7: 1.2, 6: 1.2, 5: 1.2, 4: 1.2, 3: 1.2,
				}
				return loss[mat.TypeId], nil
			},
			Unit:           "m²",
			MaterialRound:  true,
			ControlPrice:   map[int]float64{A10: 92, A8: 84, A5: 70, ZZ1_0: 84},
			DeductionPrice: map[int]float64{A10: 85, A8: 70, A5: 55, ZZ1_0: 70},
		},
	},
	1: {
		{
			Region: "入户门套",
			NumberCalc: func(context *ItemContext) (float64, error) {
				if context.Pkg.RoomData.Pkg.Type == A5 {
					return 0, nil
				}
				return utils.FloatAdd(context.Space.DoorwayWidth, utils.FloatMul(context.Space.DoorwayHeight, 2, -1), -1), nil
			},
			PkgNumber:      6,
			Unit:           "m",
			ControlPrice:   map[int]float64{A10: 90, A8: 90, A5: 0, ZZ1_0: 90},
			DeductionPrice: map[int]float64{A10: 85, A8: 70, A5: 0, ZZ1_0: 75},
		},
		{
			Item: "安装门槛石",
			NumberCalc: func(context *ItemContext) (float64, error) {
				return context.Space.DoorwayWidth, nil
			},
		},
		{
			Region: "门槛石",
			NumberCalc: func(context *ItemContext) (float64, error) {
				return context.Space.DoorwayWidth, nil
			},
			ConvertCalc: func(context *ItemContext) (float64, error) {
				return float64(context.Space.DoorwayWallThickness), nil
			},
			Unit:         "m",
			ControlPrice: map[int]float64{A10: 89, A8: 89, A5: 0, ZZ1_0: 89},
			AdditionalMaterialCalc: func(context *ItemContext) ([]MaterialItem, error) {
				mat := context.GetMat(1610)
				if mat == nil {
					return nil, errors.New("找不到材料: " + db.ToString(1610))
				}
				typ, ok := context.MatTypeCache[mat.TypeId]
				if !ok {
					return nil, errors.New("找不到材料类型: " + db.ToString(mat.TypeId))
				}
				total := utils.FloatMul(mat.Price, context.Space.DoorwayWidth, 3)
				materials := []MaterialItem{{
					Material:   1610,
					Name:       mat.Brand + " " + mat.Series + " " + mat.Model + " " + mat.Specs + " " + mat.Color,
					Type:       "门槛石",
					Unit:       typ.Unit,
					Number:     context.Space.DoorwayWidth,
					Price:      mat.Price,
					Total:      total,
					CostNumber: context.Space.DoorwayWidth,
					CostTotal:  total,
					Index:      -1,
				}}
				if context.Region.Material == 52 || context.Region.Material == 53 || context.Region.Material == 54 {
					mat := context.GetMat(55)
					if mat == nil {
						return nil, errors.New("找不到材料: " + db.ToString(55))
					}
					typ, ok := context.MatTypeCache[mat.TypeId]
					if !ok {
						return nil, errors.New("找不到材料类型: " + db.ToString(mat.TypeId))
					}
					number := utils.FloatMul(8, context.Space.DoorwayWidth, 3)
					total := utils.FloatMul(mat.Price, number, 3)
					materials = append(materials, MaterialItem{
						Material:   55,
						Name:       mat.Brand + " " + mat.Series + " " + mat.Model + " " + mat.Specs + " " + mat.Color,
						Type:       "钢筋成本",
						Unit:       typ.Unit,
						Number:     number,
						Price:      mat.Price,
						Total:      total,
						CostNumber: number,
						CostTotal:  total,
						Index:      -1,
					})
				}
				return materials, nil
			},
			NoUpgrade: true,
		},
		{
			Item: "小窗台大理石安装",
			NumberCalc: func(context *ItemContext) (float64, error) {
				num := float64(0)
				if context.Space.Windows != nil {
					for _, window := range context.Space.Windows {
						if window.Width <= 0.2 {
							num = utils.FloatAdd(num, window.Length, -1)
						}
					}
				}
				return num, nil
			},
		},
		{
			Item: "窗台大理石安装 宽度>200MM<700MM",
			NumberCalc: func(context *ItemContext) (float64, error) {
				num := float64(0)
				if context.Space.Windows != nil {
					for _, window := range context.Space.Windows {
						if window.Width > 0.2 && window.Width < 0.7 {
							num = utils.FloatAdd(num, window.Length, -1)
						}
					}
				}
				return num, nil
			},
		},
		{
			Item: "窗台大理石安装 宽度≥700MM",
			NumberCalc: func(context *ItemContext) (float64, error) {
				num := float64(0)
				if context.Space.Windows != nil {
					for _, window := range context.Space.Windows {
						if window.Width >= 0.7 {
							num = utils.FloatAdd(num, window.Length, -1)
						}
					}
				}
				return num, nil
			},
		},
		{
			Region: "窗台石",
			NumberCalc: func(context *ItemContext) (float64, error) {
				num := float64(0)
				if context.Space.Windows != nil {
					for _, window := range context.Space.Windows {
						if window.Width > 0 {
							num = utils.FloatAdd(num, utils.FloatAdd(window.Length, 0.1, -1), -1)
						}
					}
				}
				return num, nil
			},
			ConvertCalc: func(context *ItemContext) (float64, error) {
				num := float64(0)
				if context.Space.Windows != nil {
					for _, window := range context.Space.Windows {
						if window.Width > 0 {
							num = utils.FloatAdd(num, utils.FloatAdd(window.Length, 0.1, -1), -1)
						}
					}
				}
				mnum := float64(0)
				if context.Space.Windows != nil {
					for _, window := range context.Space.Windows {
						if window.Width > 0 {
							mnum = utils.FloatAdd(num, utils.FloatMul(utils.FloatAdd(window.Length, 0.1, -1), window.Width, -1), -1)
						}
					}
				}
				return utils.FloatDiv(mnum, num, -1), nil
			},
			MaterialNumberCalc: func(context *ItemContext) (float64, error) {
				num := float64(0)
				if context.Space.Windows != nil {
					for _, window := range context.Space.Windows {
						if window.Length > 0 {
							num = utils.FloatAdd(num, utils.FloatMul(utils.FloatAdd(window.Length, 0.1, -1), window.Width, -1), -1)
						}
					}
				}
				return num, nil
			},
			Unit:         "m",
			ControlPrice: map[int]float64{A10: 143, A8: 143, A5: 143, ZZ1_0: 143},
			AdditionalMaterialCalc: func(context *ItemContext) ([]MaterialItem, error) {
				num := float64(0)
				if context.Space.Windows != nil {
					for _, window := range context.Space.Windows {
						if window.Width > 0 {
							num = utils.FloatAdd(num, utils.FloatAdd(window.Length, 0.1, -1), -1)
						}
					}
				}
				mat := context.GetMat(1609)
				if mat == nil {
					return nil, errors.New("找不到材料: " + db.ToString(1609))
				}
				typ, ok := context.MatTypeCache[mat.TypeId]
				if !ok {
					return nil, errors.New("找不到材料类型: " + db.ToString(mat.TypeId))
				}
				total := utils.FloatMul(mat.Price, num, 3)
				return []MaterialItem{{
					Material:   1609,
					Name:       mat.Brand + " " + mat.Series + " " + mat.Model + " " + mat.Specs + " " + mat.Color,
					Type:       "窗台石",
					Unit:       typ.Unit,
					Number:     num,
					Price:      mat.Price,
					Total:      total,
					CostNumber: num,
					CostTotal:  total,
					Index:      -1,
				}}, nil
			},
			NoUpgrade: true,
		},
		{
			ItemSelect: func(context *ItemContext) (string, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return "", nil
				}
				if mat.TypeId == 110 {
					return "地面找平", nil
				}
				if mat.TypeId == 6 {
					return "地面贴砖（600*1200mm）", nil
				}
				if mat.TypeId == 7 {
					return "地面贴砖（750*1500mm）", nil
				}
				return "地面贴砖（300*300mm-800*800mm）", nil
			},
			Region: "地面",
			NumberCalc: func(context *ItemContext) (float64, error) {
				return context.Space.Area, nil
			},
			MaterialNumberCalc: func(context *ItemContext) (float64, error) {
				return 0, nil
			},
			DiffPriceCalc: func(context *ItemContext) (float64, error) {
				price, err := context.Item.GetPrice(context)
				if err != nil {
					return 0, err
				}
				if price < 68 {
					return 0, nil
				}
				return utils.FloatSub(price, 68, -1), nil
			},
		},
		{
			Region:       "地面",
			MaterialType: "地面",
			NumberCalc: func(context *ItemContext) (float64, error) {
				return context.Space.Area, nil
			},
			LossCalc: func(context *ItemContext) (float64, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return 1, nil
				}
				loss := map[int64]float64{
					110: 1, 10: 1.08, 9: 1.08, 7: 1.1, 6: 1.1, 5: 1.1, 4: 1.08, 3: 1.08,
				}
				return loss[mat.TypeId], nil
			},
			ConvertCalc: func(context *ItemContext) (float64, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return 1, nil
				}
				area := map[int64]float64{
					110: 1, 10: 0.09, 9: 0.18, 7: 1.125, 6: 0.72, 5: 0.64, 4: 0.16, 3: 0.32,
				}
				return utils.FloatDiv(1, area[mat.TypeId], -1), nil
			},
			CostLossCalc: func(context *ItemContext) (float64, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return 1, nil
				}
				loss := map[int64]float64{
					110: 1.1, 10: 1.2, 9: 1.2, 7: 1.2, 6: 1.2, 5: 1.2, 4: 1.2, 3: 1.2,
				}
				return loss[mat.TypeId], nil
			},
			Unit:           "m²",
			MaterialRound:  true,
			ControlPrice:   map[int]float64{A10: 81, A8: 56, A5: 36, ZZ1_0: 56},
			DeductionPrice: map[int]float64{A10: 55, A8: 40, A5: 30, ZZ1_0: 40},
		},
		{
			Item: "地砖铺贴后成品保护",
			NumberCalc: func(context *ItemContext) (float64, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return 0, nil
				}
				if mat.TypeId == 110 {
					return 0, nil
				}
				return context.Space.Area, nil
			},
		},
		{
			Item:   "踢脚线铺贴（明贴）",
			Region: "地面",
			NumberCalc: func(context *ItemContext) (float64, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return 0, nil
				}
				if mat.TypeId == 110 {
					return 0, nil
				}
				KitchenHole := context.Pkg.RoomData.Space[2][0].DoorwayWidth
				BalconyHole := float64(0)
				if len(context.Pkg.RoomData.Space[4]) != 0 {
					BalconyHole = context.Pkg.RoomData.Space[4][0].DoorwayWidth
				}
				RoomHole := float64(0)
				for _, space := range context.Pkg.RoomData.Space[0] {
					RoomHole = utils.FloatAdd(RoomHole, space.DoorwayWidth, -1)
				}
				number := utils.FloatSubSlice([]float64{context.Space.Perimeter, context.Space.DoorwayWidth, KitchenHole, BalconyHole, RoomHole}, -1)
				if number < 0 {
					return 0, nil
				}
				return number, nil
			},
			MaterialNumberCalc: func(context *ItemContext) (float64, error) {
				return 0, nil
			},
		},
		{
			Region:       "地面",
			MaterialType: "瓷砖地脚线",
			NumberCalc: func(context *ItemContext) (float64, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return 0, nil
				}
				if mat.TypeId == 110 {
					return 0, nil
				}
				KitchenHole := context.Pkg.RoomData.Space[2][0].DoorwayWidth
				BalconyHole := float64(0)
				if len(context.Pkg.RoomData.Space[4]) != 0 {
					BalconyHole = context.Pkg.RoomData.Space[4][0].DoorwayWidth
				}
				RoomHole := float64(0)
				for _, space := range context.Pkg.RoomData.Space[0] {
					RoomHole = utils.FloatAdd(RoomHole, space.DoorwayWidth, -1)
				}
				number := utils.FloatSubSlice([]float64{context.Space.Perimeter, context.Space.DoorwayWidth, KitchenHole, BalconyHole, RoomHole}, -1)
				if number < 0 {
					return 0, nil
				}
				return number, nil
			},
			ConvertCalc: func(context *ItemContext) (float64, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return 1, nil
				}
				lineArea := map[int64]float64{
					10: 0.6, 9: 1.2, 7: 11.25, 6: 7.2, 5: 6.4, 4: 0.8, 3: 1.6,
				}
				return utils.FloatDiv(1, lineArea[mat.TypeId], -1), nil
			},
			Unit:           "m",
			MaterialRound:  true,
			ControlPrice:   map[int]float64{A10: 16, A8: 12, A5: 8, ZZ1_0: 12},
			DeductionPrice: map[int]float64{A10: 12, A8: 8, A5: 6, ZZ1_0: 8},
			AdditionalMaterialCalc: func(context *ItemContext) ([]MaterialItem, error) {
				KitchenHole := context.Pkg.RoomData.Space[2][0].DoorwayWidth
				BalconyHole := float64(0)
				if len(context.Pkg.RoomData.Space[4]) != 0 {
					BalconyHole = context.Pkg.RoomData.Space[4][0].DoorwayWidth
				}
				number := utils.FloatSubSlice([]float64{context.Space.Perimeter, context.Space.DoorwayWidth, KitchenHole, BalconyHole}, -1)
				if number < 0 {
					number = 0
				}
				number = utils.FloatMul(number, 2, 3)
				ymat := context.GetMat(context.Region.Material)
				if ymat == nil {
					return nil, errors.New("找不到材料: " + db.ToString(context.Region.Material))
				}
				var mat final.FinalMat
				db.GetModel(map[string]interface{}{
					"supplier_id": ymat.SupplierId,
					"model":       "其他费用",
					"deleted_at":  0,
				}, &mat)
				if mat.ID == 0 {
					return []MaterialItem{}, nil
				}

				typ, ok := context.MatTypeCache[mat.TypeId]
				if !ok {
					return nil, errors.New("找不到材料类型: " + db.ToString(mat.TypeId))
				}
				total := utils.FloatMul(mat.Price, number, 3)
				return []MaterialItem{{
					Material:   mat.ID,
					Name:       mat.Brand + " " + mat.Series + " " + mat.Model + " " + mat.Specs + " " + mat.Color,
					Type:       "瓷砖地脚线",
					Unit:       typ.Unit,
					Number:     number,
					Price:      mat.Price,
					Total:      total,
					CostNumber: number,
					CostTotal:  total,
					Index:      -1,
				}}, nil
			},
		},
		{
			Region: "筒灯或灯带",
			NumberCalc: func(context *ItemContext) (float64, error) {
				if context.Pkg.RoomData.Pkg.Type != ZZ1_0 {
					return 0, nil
				}
				return 15, nil
			},
			Unit:           "套",
			ControlPrice:   map[int]float64{A10: 0, A8: 0, A5: 0, ZZ1_0: 8},
			DeductionPrice: map[int]float64{A10: 0, A8: 0, A5: 0, ZZ1_0: 8},
		},
		{
			Item: "直线造型吊顶（二级)",
			NumberCalc: func(context *ItemContext) (float64, error) {
				if context.Pkg.RoomData.Pkg.Type != ZZ1_0 {
					return 0, nil
				}
				return utils.FloatMul(context.Space.Area, 0.8, -1), nil
			},
		},
	},
	2: {
		{
			Region: "铝合金门",
			NumberCalc: func(context *ItemContext) (float64, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return 0, nil
				}
				if mat.TypeId == 105 {
					return 1, nil
				}
				return utils.FloatMul(context.Space.DoorwayWidth, context.Space.DoorwayHeight, -1), nil
			},
			PkgNumberCalc: func(context *ItemContext) (float64, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return 0, nil
				}
				if mat.TypeId == 105 {
					return 1, nil
				}
				return 3.52, nil
			},
			Unit: "m",
			UnitCalc: func(context *ItemContext) (string, error) {
				mat := context.GetMat(context.Region.Material)
				if mat != nil && mat.TypeId == 105 {
					return "樘", nil
				}
				return "m", nil
			},
			ControlPriceCalc: func(context *ItemContext) (float64, error) {
				mat := context.GetMat(context.Region.Material)
				controls := map[int]float64{A10: 430, A8: 403, A5: 700, ZZ1_0: 403}
				if mat != nil && mat.TypeId == 105 {
					if context.Pkg.RoomData.Pkg.Type == A5 {
						return controls[context.Pkg.RoomData.Pkg.Type], nil
					}
					return utils.FloatMul(controls[context.Pkg.RoomData.Pkg.Type], 3.52, -1), nil
				}
				if context.Pkg.RoomData.Pkg.Type == A5 {
					return utils.FloatDiv(controls[context.Pkg.RoomData.Pkg.Type], 3.52, -1), nil
				}
				return controls[context.Pkg.RoomData.Pkg.Type], nil
			},
			DeductionPriceCalc: func(context *ItemContext) (float64, error) {
				mat := context.GetMat(context.Region.Material)
				deductions := map[int]float64{A10: 410, A8: 360, A5: 500, ZZ1_0: 360}
				if mat != nil && mat.TypeId == 105 {
					if context.Pkg.RoomData.Pkg.Type == A5 {
						return deductions[context.Pkg.RoomData.Pkg.Type], nil
					}
					return utils.FloatMul(deductions[context.Pkg.RoomData.Pkg.Type], 3.52, -1), nil
				}
				if context.Pkg.RoomData.Pkg.Type == A5 {
					return utils.FloatDiv(deductions[context.Pkg.RoomData.Pkg.Type], 3.52, -1), nil
				}
				return deductions[context.Pkg.RoomData.Pkg.Type], nil
			},
			MaterialAdditionalItemCalc: func(context *ItemContext) ([]PersonalItem, error) {
				items := make([]PersonalItem, 0)
				mat := context.GetMat(context.Region.Material)
				if mat != nil && mat.TypeId == 105 && context.Pkg.RoomData.Pkg.Type == A5 {
					if context.Space.DoorwayHeight > 2 {
						//number := math.Ceil(utils.FloatMul(utils.FloatSub(context.Space.DoorwayHeight, 2, -1), 100, -1))
						//total := math.Round(utils.FloatMul(15, number, 3))
						items = append(items, PersonalItem{
							Name:   context.GetSpaceName() + " 铝合金门(" + mat.Brand + " " + mat.Series + " " + mat.Model + " " + mat.Specs + " " + mat.Color + ") 超高度",
							Unit:   "套",
							Number: 1,
							Price:  60,
							Total:  60,
							Index:  -1,
						})
					}
					if context.Space.DoorwayWidth > 0.8 {
						//number := math.Ceil(utils.FloatMul(utils.FloatSub(context.Space.DoorwayWidth, 0.8, -1), 100, -1))
						//total := math.Round(utils.FloatMul(15, number, 3))
						items = append(items, PersonalItem{
							Name:   context.GetSpaceName() + " 铝合金门(" + mat.Brand + " " + mat.Series + " " + mat.Model + " " + mat.Specs + " " + mat.Color + ") 超宽度",
							Unit:   "套",
							Number: 1,
							Price:  60,
							Total:  60,
							Index:  -1,
						})
					}
					if context.Space.DoorwayWallThickness > 0.28 {
						//number := math.Ceil(utils.FloatMul(utils.FloatSub(context.Space.DoorwayWallThickness, 0.28, -1), 100, -1))
						//total := math.Round(utils.FloatMul(25, number, 3))
						items = append(items, PersonalItem{
							Name:   context.GetSpaceName() + " 铝合金门(" + mat.Brand + " " + mat.Series + " " + mat.Model + " " + mat.Specs + " " + mat.Color + ") 超墙厚",
							Unit:   "套",
							Number: 1,
							Price:  60,
							Total:  60,
							Index:  -1,
						})
					}
				}
				return items, nil
			},
		},
		{
			Region: "门套",
			NumberCalc: func(context *ItemContext) (float64, error) {
				if context.Pkg.RoomData.Pkg.Type == A5 {
					return 0, nil
				}
				return utils.FloatAdd(context.Space.DoorwayWidth, utils.FloatMul(context.Space.DoorwayHeight, 2, -1), -1), nil
			},
			PkgNumber:      6,
			Unit:           "m",
			ControlPrice:   map[int]float64{A10: 90, A8: 90, A5: 0, ZZ1_0: 90},
			DeductionPrice: map[int]float64{A10: 90, A8: 90, A5: 0, ZZ1_0: 90},
		},
		{
			Item: "安装门槛石",
			NumberCalc: func(context *ItemContext) (float64, error) {
				if context.Space.WideBed {
					return 0, nil
				}
				return context.Space.DoorwayWidth, nil
			},
		},
		{
			Region: "门槛石",
			NumberCalc: func(context *ItemContext) (float64, error) {
				if context.Space.WideBed {
					return 0, nil
				}
				return context.Space.DoorwayWidth, nil
			},
			ConvertCalc: func(context *ItemContext) (float64, error) {
				return float64(context.Space.DoorwayWallThickness), nil
			},
			Unit:         "m",
			ControlPrice: map[int]float64{A10: 89, A8: 89, A5: 0, ZZ1_0: 89},
			AdditionalMaterialCalc: func(context *ItemContext) ([]MaterialItem, error) {
				mat := context.GetMat(1610)
				if mat == nil {
					return nil, errors.New("找不到材料: " + db.ToString(1610))
				}
				typ, ok := context.MatTypeCache[mat.TypeId]
				if !ok {
					return nil, errors.New("找不到材料类型: " + db.ToString(mat.TypeId))
				}
				total := utils.FloatMul(mat.Price, context.Space.DoorwayWidth, 3)
				materials := []MaterialItem{{
					Material:   1610,
					Name:       mat.Brand + " " + mat.Series + " " + mat.Model + " " + mat.Specs + " " + mat.Color,
					Type:       "门槛石",
					Unit:       typ.Unit,
					Number:     context.Space.DoorwayWidth,
					Price:      mat.Price,
					Total:      total,
					CostNumber: context.Space.DoorwayWidth,
					CostTotal:  total,
					Index:      -1,
				}}
				if context.Region.Material == 52 || context.Region.Material == 53 || context.Region.Material == 54 {
					mat := context.GetMat(55)
					if mat == nil {
						return nil, errors.New("找不到材料: " + db.ToString(55))
					}
					typ, ok := context.MatTypeCache[mat.TypeId]
					if !ok {
						return nil, errors.New("找不到材料类型: " + db.ToString(mat.TypeId))
					}
					number := utils.FloatMul(8, context.Space.DoorwayWidth, 3)
					total := utils.FloatMul(mat.Price, number, 3)
					materials = append(materials, MaterialItem{
						Material:   55,
						Name:       mat.Brand + " " + mat.Series + " " + mat.Model + " " + mat.Specs + " " + mat.Color,
						Type:       "钢筋成本",
						Unit:       typ.Unit,
						Number:     number,
						Price:      mat.Price,
						Total:      total,
						CostNumber: number,
						CostTotal:  total,
						Index:      -1,
					})
				}
				return materials, nil
			},
			NoUpgrade: true,
		},
		{
			ItemSelect: func(context *ItemContext) (string, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return "", nil
				}
				if mat.TypeId == 6 {
					return "地面贴砖（600*1200mm）", nil
				}
				if mat.TypeId == 7 {
					return "地面贴砖（750*1500mm）", nil
				}
				return "地面贴砖（300*300mm-800*800mm）", nil
			},
			Region: "地砖",
			NumberCalc: func(context *ItemContext) (float64, error) {
				number := context.Space.Area
				if context.Space.WideBed {
					number = utils.FloatAdd(number, utils.FloatMul(context.Space.DoorwayWidth, context.Space.DoorwayWallThickness, -1), -1)
				}
				return number, nil
			},
			MaterialNumberCalc: func(context *ItemContext) (float64, error) {
				return 0, nil
			},
			DiffPriceCalc: func(context *ItemContext) (float64, error) {
				price, err := context.Item.GetPrice(context)
				if err != nil {
					return 0, err
				}
				if price < 68 {
					return 0, nil
				}
				return utils.FloatSub(price, 68, -1), nil
			},
		},
		{
			Region: "地砖",
			NumberCalc: func(context *ItemContext) (float64, error) {
				number := context.Space.Area
				if context.Space.WideBed {
					number = utils.FloatAdd(number, utils.FloatMul(context.Space.DoorwayWidth, context.Space.DoorwayWallThickness, -1), -1)
				}
				return number, nil
			},
			LossCalc: func(context *ItemContext) (float64, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return 1, nil
				}
				loss := map[int64]float64{
					10: 1.08, 9: 1.08, 7: 1.1, 6: 1.1, 5: 1.1, 4: 1.08, 3: 1.08,
				}
				return loss[mat.TypeId], nil
			},
			ConvertCalc: func(context *ItemContext) (float64, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return 1, nil
				}
				area := map[int64]float64{
					10: 0.09, 9: 0.18, 7: 1.125, 6: 0.72, 5: 0.64, 4: 0.16, 3: 0.32,
				}
				return utils.FloatDiv(1, area[mat.TypeId], -1), nil
			},
			CostLossCalc: func(context *ItemContext) (float64, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return 1, nil
				}
				loss := map[int64]float64{
					110: 1.1, 10: 1.2, 9: 1.2, 7: 1.2, 6: 1.2, 5: 1.2, 4: 1.2, 3: 1.2,
				}
				return loss[mat.TypeId], nil
			},
			Unit:           "m²",
			MaterialRound:  true,
			ControlPrice:   map[int]float64{A10: 81, A8: 56, A5: 36, ZZ1_0: 56},
			DeductionPrice: map[int]float64{A10: 55, A8: 40, A5: 30, ZZ1_0: 40},
		},
		{
			Item: "地砖铺贴后成品保护",
			NumberCalc: func(context *ItemContext) (float64, error) {
				number := context.Space.Area
				if context.Space.WideBed {
					number = utils.FloatAdd(number, utils.FloatMul(context.Space.DoorwayWidth, context.Space.DoorwayWallThickness, -1), -1)
				}
				return number, nil
			},
		},
		{
			ItemSelect: func(context *ItemContext) (string, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return "", nil
				}
				if mat.TypeId == 6 {
					return "墙面贴砖（600*1200mm）", nil
				}
				if mat.TypeId == 7 {
					return "墙面贴砖（750*1500mm）", nil
				}
				if mat.TypeId == 4 || mat.TypeId == 3 {
					return "墙面贴砖（400*800mm)", nil
				}
				return "墙面贴砖（300*300mm-300*600mm)", nil
			},
			Region: "墙砖",
			NumberCalc: func(context *ItemContext) (float64, error) {
				number := utils.FloatSub(utils.FloatMul(context.Space.Perimeter, 2.4, -1), utils.FloatMul(context.Space.DoorwayWidth, context.Space.DoorwayHeight, -1), -1)
				if context.Space.Windows != nil {
					for _, window := range context.Space.Windows {
						number = utils.FloatSub(number, utils.FloatMul(window.Length, window.Height, -1), -1)
						number = utils.FloatAdd(number, utils.FloatMul(utils.FloatMul(utils.FloatAdd(window.Length, window.Height, -1), 2, -1), window.Width, -1), -1)
					}
				}
				return number, nil
			},
			MaterialNumberCalc: func(context *ItemContext) (float64, error) {
				return 0, nil
			},
		},
		{
			Region: "墙砖",
			NumberCalc: func(context *ItemContext) (float64, error) {
				number := utils.FloatSub(utils.FloatMul(context.Space.Perimeter, 2.4, -1), utils.FloatMul(context.Space.DoorwayWidth, context.Space.DoorwayHeight, -1), -1)
				if context.Space.Windows != nil {
					for _, window := range context.Space.Windows {
						number = utils.FloatSub(number, utils.FloatMul(window.Length, window.Height, -1), -1)
						number = utils.FloatAdd(number, utils.FloatMul(utils.FloatMul(utils.FloatAdd(window.Length, window.Height, -1), 2, -1), window.Width, -1), -1)
					}
				}
				return number, nil
			},
			LossCalc: func(context *ItemContext) (float64, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return 1, nil
				}
				loss := map[int64]float64{
					10: 1.08, 9: 1.08, 7: 1.1, 6: 1.1, 5: 1.1, 4: 1.08, 3: 1.08,
				}
				return loss[mat.TypeId], nil
			},
			ConvertCalc: func(context *ItemContext) (float64, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return 1, nil
				}
				area := map[int64]float64{
					10: 0.09, 9: 0.18, 7: 1.125, 6: 0.72, 5: 0.64, 4: 0.16, 3: 0.32,
				}
				return utils.FloatDiv(1, area[mat.TypeId], -1), nil
			},
			CostLossCalc: func(context *ItemContext) (float64, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return 1, nil
				}
				loss := map[int64]float64{
					110: 1.1, 10: 1.2, 9: 1.2, 7: 1.2, 6: 1.2, 5: 1.2, 4: 1.2, 3: 1.2,
				}
				return loss[mat.TypeId], nil
			},
			Unit:           "m²",
			MaterialRound:  true,
			ControlPrice:   map[int]float64{A10: 81, A8: 56, A5: 31, ZZ1_0: 56},
			DeductionPrice: map[int]float64{A10: 55, A8: 40, A5: 30, ZZ1_0: 40},
		},
		{
			Region: "橱柜地柜",
			NumberCalc: func(context *ItemContext) (float64, error) {
				number := utils.FloatSub(utils.FloatDiv(context.Space.Perimeter, 2, -1), 0.6, -1)
				if number < 4.5 {
					number = 4.5
				}
				return number, nil
			},
			Unit:           "m",
			ControlPrice:   map[int]float64{A10: 592, A8: 460, A5: 306, ZZ1_0: 460},
			DeductionPrice: map[int]float64{A10: 450, A8: 410, A5: 410, ZZ1_0: 410},
		},
		{
			Region: "橱柜吊柜",
			NumberCalc: func(context *ItemContext) (float64, error) {
				number := utils.FloatSub(utils.FloatDiv(context.Space.Perimeter, 2, -1), 1.6, -1)
				if number < 3.5 {
					number = 3.5
				}
				return number, nil
			},
			Unit:           "m",
			ControlPrice:   map[int]float64{A10: 343, A8: 170, A5: 294, ZZ1_0: 170},
			DeductionPrice: map[int]float64{A10: 320, A8: 170, A5: 170, ZZ1_0: 170},
		},
		{
			Region: "橱柜台面",
			NumberCalc: func(context *ItemContext) (float64, error) {
				number := utils.FloatSub(utils.FloatDiv(context.Space.Perimeter, 2, -1), 0.6, -1)
				if number < 4.5 {
					number = 4.5
				}
				return number, nil
			},
			Unit:           "m",
			ControlPrice:   map[int]float64{A10: 515, A8: 450, A5: 380, ZZ1_0: 450},
			DeductionPrice: map[int]float64{A10: 420, A8: 392, A5: 320, ZZ1_0: 390},
		},
		{
			Region:         "燃气包管",
			Number:         1,
			Unit:           "根",
			ControlPrice:   map[int]float64{A10: 120, A8: 120, A5: 120, ZZ1_0: 120},
			DeductionPrice: map[int]float64{A10: 120, A8: 120, A5: 120, ZZ1_0: 120},
		},
		{
			Region:         "洗菜盆及龙头",
			Number:         1,
			Unit:           "套",
			ControlPrice:   map[int]float64{A10: 468, A8: 468, A5: 468, ZZ1_0: 468},
			DeductionPrice: map[int]float64{A10: 420, A8: 420, A5: 420, ZZ1_0: 420},
		},
		{
			Region: "集成吊顶",
			NumberCalc: func(context *ItemContext) (float64, error) {
				return context.Space.Area, nil
			},
			Loss: 1.08,
			ConvertCalc: func(context *ItemContext) (float64, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return 1, nil
				}
				area := map[int64]float64{
					128: 1, 188: 0.18, 187: 0.09,
				}
				return utils.FloatDiv(1, area[mat.TypeId], -1), nil
			},
			Unit:           "m²",
			MaterialRound:  true,
			ControlPrice:   map[int]float64{A10: 90, A8: 90, A5: 75, ZZ1_0: 90},
			DeductionPrice: map[int]float64{A10: 80, A8: 80, A5: 70, ZZ1_0: 80},
		},
		{
			Region:         "吊顶灯",
			Number:         1,
			Unit:           "个",
			ControlPrice:   map[int]float64{A10: 38, A8: 38, A5: 38, ZZ1_0: 38},
			DeductionPrice: map[int]float64{A10: 40, A8: 40, A5: 40, ZZ1_0: 40},
		},
		{
			Item:   "烟道挂网加固",
			Number: 1,
		},
	},
	3: {
		{
			Region: "平开门",
			NumberCalc: func(context *ItemContext) (float64, error) {
				return 1, nil
			},
			Unit:           "樘",
			ControlPrice:   map[int]float64{A10: 865, A8: 780, A5: 780, ZZ1_0: 900},
			DeductionPrice: map[int]float64{A10: 850, A8: 750, A5: 700, ZZ1_0: 750},
			MaterialAdditionalItemCalc: func(context *ItemContext) ([]PersonalItem, error) {
				items := make([]PersonalItem, 0)
				mat := context.GetMat(context.Region.Material)
				if mat != nil && mat.TypeId == 105 {
					if context.Space.DoorwayHeight > 2 {
						//number := math.Ceil(utils.FloatMul(utils.FloatSub(context.Space.DoorwayHeight, 2, -1), 100, -1))
						//total := math.Round(utils.FloatMul(15, number, 3))
						items = append(items, PersonalItem{
							Name:   context.GetSpaceName() + " 平开门(" + mat.Brand + " " + mat.Series + " " + mat.Model + " " + mat.Specs + " " + mat.Color + ") 超高度",
							Unit:   "套",
							Number: 1,
							Price:  60,
							Total:  60,
							Index:  -1,
						})
					}
					if context.Space.DoorwayWidth > 0.8 {
						//number := math.Ceil(utils.FloatMul(utils.FloatSub(context.Space.DoorwayWidth, 0.8, -1), 100, -1))
						//total := math.Round(utils.FloatMul(15, number, 3))
						items = append(items, PersonalItem{
							Name:   context.GetSpaceName() + " 平开门(" + mat.Brand + " " + mat.Series + " " + mat.Model + " " + mat.Specs + " " + mat.Color + ") 超宽度",
							Unit:   "套",
							Number: 1,
							Price:  60,
							Total:  60,
							Index:  -1,
						})
					}
					if context.Space.DoorwayWallThickness > 0.28 {
						//number := math.Ceil(utils.FloatMul(utils.FloatSub(context.Space.DoorwayWallThickness, 0.28, -1), 100, -1))
						//total := math.Round(utils.FloatMul(25, number, 3))
						items = append(items, PersonalItem{
							Name:   context.GetSpaceName() + " 平开门(" + mat.Brand + " " + mat.Series + " " + mat.Model + " " + mat.Specs + " " + mat.Color + ") 超墙厚",
							Unit:   "套",
							Number: 1,
							Price:  60,
							Total:  60,
							Index:  -1,
						})
					}
				}
				return items, nil
			},
		},
		{
			Item: "安装门槛石",
			NumberCalc: func(context *ItemContext) (float64, error) {
				if context.Space.WideBed {
					return 0, nil
				}
				return context.Space.DoorwayWidth, nil
			},
		},
		{
			Region: "门槛石",
			NumberCalc: func(context *ItemContext) (float64, error) {
				if context.Space.WideBed {
					return 0, nil
				}
				return context.Space.DoorwayWidth, nil
			},
			ConvertCalc: func(context *ItemContext) (float64, error) {
				return float64(context.Space.DoorwayWallThickness), nil
			},
			Unit:         "m",
			ControlPrice: map[int]float64{A10: 89, A8: 89, A5: 0, ZZ1_0: 89},
			AdditionalMaterialCalc: func(context *ItemContext) ([]MaterialItem, error) {
				mat := context.GetMat(1610)
				if mat == nil {
					return nil, errors.New("找不到材料: " + db.ToString(1610))
				}
				typ, ok := context.MatTypeCache[mat.TypeId]
				if !ok {
					return nil, errors.New("找不到材料类型: " + db.ToString(mat.TypeId))
				}
				total := utils.FloatMul(mat.Price, context.Space.DoorwayWidth, 3)
				materials := []MaterialItem{{
					Material:   1610,
					Name:       mat.Brand + " " + mat.Series + " " + mat.Model + " " + mat.Specs + " " + mat.Color,
					Type:       "门槛石",
					Unit:       typ.Unit,
					Number:     context.Space.DoorwayWidth,
					Price:      mat.Price,
					Total:      total,
					CostNumber: context.Space.DoorwayWidth,
					CostTotal:  total,
					Index:      -1,
				}}
				if context.Region.Material == 52 || context.Region.Material == 53 || context.Region.Material == 54 {
					mat := context.GetMat(55)
					if mat == nil {
						return nil, errors.New("找不到材料: " + db.ToString(55))
					}
					typ, ok := context.MatTypeCache[mat.TypeId]
					if !ok {
						return nil, errors.New("找不到材料类型: " + db.ToString(mat.TypeId))
					}
					number := utils.FloatMul(8, context.Space.DoorwayWidth, 3)
					total := utils.FloatMul(mat.Price, number, 3)
					materials = append(materials, MaterialItem{
						Material:   55,
						Name:       mat.Brand + " " + mat.Series + " " + mat.Model + " " + mat.Specs + " " + mat.Color,
						Type:       "钢筋成本",
						Unit:       typ.Unit,
						Number:     number,
						Price:      mat.Price,
						Total:      total,
						CostNumber: number,
						CostTotal:  total,
						Index:      -1,
					})
				}
				return materials, nil
			},
			NoUpgrade: true,
		},
		{
			ItemSelect: func(context *ItemContext) (string, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return "", nil
				}
				if mat.TypeId == 6 {
					return "地面贴砖（600*1200mm）", nil
				}
				if mat.TypeId == 7 {
					return "地面贴砖（750*1500mm）", nil
				}
				return "地面贴砖（300*300mm-800*800mm）", nil
			},
			Region: "地砖",
			NumberCalc: func(context *ItemContext) (float64, error) {
				if context.Space.DryWetSeparation {
					return 0, nil
				}
				number := context.Space.Area
				if context.Space.WideBed {
					number = utils.FloatAdd(number, utils.FloatMul(context.Space.DoorwayWidth, context.Space.DoorwayWallThickness, -1), -1)
				}
				return number, nil
			},
			MaterialNumberCalc: func(context *ItemContext) (float64, error) {
				return 0, nil
			},
			DiffPriceCalc: func(context *ItemContext) (float64, error) {
				price, err := context.Item.GetPrice(context)
				if err != nil {
					return 0, err
				}
				if price < 68 {
					return 0, nil
				}
				return utils.FloatSub(price, 68, -1), nil
			},
		},
		{
			ItemSelect: func(context *ItemContext) (string, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return "", nil
				}
				if mat.TypeId == 6 {
					return "地面贴砖（600*1200mm）", nil
				}
				if mat.TypeId == 7 {
					return "地面贴砖（750*1500mm）", nil
				}
				return "地面贴砖（300*300mm-800*800mm）", nil
			},
			Region: "干区地砖",
			NumberCalc: func(context *ItemContext) (float64, error) {
				if context.Space.DryWetSeparation {
					return context.Space.Area, nil
				}
				return 0, nil
			},
			MaterialNumberCalc: func(context *ItemContext) (float64, error) {
				return 0, nil
			},
			DiffPriceCalc: func(context *ItemContext) (float64, error) {
				price, err := context.Item.GetPrice(context)
				if err != nil {
					return 0, err
				}
				if price < 68 {
					return 0, nil
				}
				return utils.FloatSub(price, 68, -1), nil
			},
		},
		{
			ItemSelect: func(context *ItemContext) (string, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return "", nil
				}
				if mat.TypeId == 6 {
					return "地面贴砖（600*1200mm）", nil
				}
				if mat.TypeId == 7 {
					return "地面贴砖（750*1500mm）", nil
				}
				return "地面贴砖（300*300mm-800*800mm）", nil
			},
			Region: "湿区地砖",
			NumberCalc: func(context *ItemContext) (float64, error) {
				if context.Space.DryWetSeparation {
					return context.Space.WetArea, nil
				}
				return 0, nil
			},
			MaterialNumberCalc: func(context *ItemContext) (float64, error) {
				return 0, nil
			},
			DiffPriceCalc: func(context *ItemContext) (float64, error) {
				price, err := context.Item.GetPrice(context)
				if err != nil {
					return 0, err
				}
				if price < 68 {
					return 0, nil
				}
				return utils.FloatSub(price, 68, -1), nil
			},
		},
		{
			Region: "地砖",
			NumberCalc: func(context *ItemContext) (float64, error) {
				if context.Space.DryWetSeparation {
					return 0, nil
				}
				number := context.Space.Area
				if context.Space.WideBed {
					number = utils.FloatAdd(number, utils.FloatMul(context.Space.DoorwayWidth, context.Space.DoorwayWallThickness, -1), -1)
				}
				return number, nil
			},
			LossCalc: func(context *ItemContext) (float64, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return 1, nil
				}
				loss := map[int64]float64{
					10: 1.08, 9: 1.08, 7: 1.1, 6: 1.1, 5: 1.1, 4: 1.08, 3: 1.08,
				}
				return loss[mat.TypeId], nil
			},
			ConvertCalc: func(context *ItemContext) (float64, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return 1, nil
				}
				area := map[int64]float64{
					10: 0.09, 9: 0.18, 7: 1.125, 6: 0.72, 5: 0.64, 4: 0.16, 3: 0.32,
				}
				return utils.FloatDiv(1, area[mat.TypeId], -1), nil
			},
			CostLossCalc: func(context *ItemContext) (float64, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return 1, nil
				}
				loss := map[int64]float64{
					110: 1.1, 10: 1.2, 9: 1.2, 7: 1.2, 6: 1.2, 5: 1.2, 4: 1.2, 3: 1.2,
				}
				return loss[mat.TypeId], nil
			},
			Unit:           "m²",
			MaterialRound:  true,
			ControlPrice:   map[int]float64{A10: 81, A8: 56, A5: 36, ZZ1_0: 56},
			DeductionPrice: map[int]float64{A10: 55, A8: 40, A5: 30, ZZ1_0: 40},
		},
		{
			Region: "干区地砖",
			NumberCalc: func(context *ItemContext) (float64, error) {
				if context.Space.DryWetSeparation {
					return context.Space.Area, nil
				}
				return 0, nil
			},
			LossCalc: func(context *ItemContext) (float64, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return 1, nil
				}
				loss := map[int64]float64{
					10: 1.08, 9: 1.08, 7: 1.1, 6: 1.1, 5: 1.1, 4: 1.08, 3: 1.08,
				}
				return loss[mat.TypeId], nil
			},
			ConvertCalc: func(context *ItemContext) (float64, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return 1, nil
				}
				area := map[int64]float64{
					10: 0.09, 9: 0.18, 7: 1.125, 6: 0.72, 5: 0.64, 4: 0.16, 3: 0.32,
				}
				return utils.FloatDiv(1, area[mat.TypeId], -1), nil
			},
			CostLossCalc: func(context *ItemContext) (float64, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return 1, nil
				}
				loss := map[int64]float64{
					110: 1.1, 10: 1.2, 9: 1.2, 7: 1.2, 6: 1.2, 5: 1.2, 4: 1.2, 3: 1.2,
				}
				return loss[mat.TypeId], nil
			},
			Unit:           "m²",
			MaterialRound:  true,
			ControlPrice:   map[int]float64{A10: 81, A8: 56, A5: 36, ZZ1_0: 56},
			DeductionPrice: map[int]float64{A10: 55, A8: 40, A5: 30, ZZ1_0: 40},
		},
		{
			Region: "湿区地砖",
			NumberCalc: func(context *ItemContext) (float64, error) {
				if context.Space.DryWetSeparation {
					return context.Space.WetArea, nil
				}
				return 0, nil
			},
			LossCalc: func(context *ItemContext) (float64, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return 1, nil
				}
				loss := map[int64]float64{
					10: 1.08, 9: 1.08, 7: 1.1, 6: 1.1, 5: 1.1, 4: 1.08, 3: 1.08,
				}
				return loss[mat.TypeId], nil
			},
			ConvertCalc: func(context *ItemContext) (float64, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return 1, nil
				}
				area := map[int64]float64{
					10: 0.09, 9: 0.18, 7: 1.125, 6: 0.72, 5: 0.64, 4: 0.16, 3: 0.32,
				}
				return utils.FloatDiv(1, area[mat.TypeId], -1), nil
			},
			CostLossCalc: func(context *ItemContext) (float64, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return 1, nil
				}
				loss := map[int64]float64{
					110: 1.1, 10: 1.2, 9: 1.2, 7: 1.2, 6: 1.2, 5: 1.2, 4: 1.2, 3: 1.2,
				}
				return loss[mat.TypeId], nil
			},
			Unit:           "m²",
			MaterialRound:  true,
			ControlPrice:   map[int]float64{A10: 81, A8: 56, A5: 36, ZZ1_0: 56},
			DeductionPrice: map[int]float64{A10: 55, A8: 40, A5: 30, ZZ1_0: 40},
		},
		{
			Item: "地面找平",
			NumberCalc: func(context *ItemContext) (float64, error) {
				number := context.Space.Area
				if context.Space.DryWetSeparation {
					number = utils.FloatAdd(number, context.Space.WetArea, -1)
				}
				if context.Space.WideBed {
					number = utils.FloatAdd(number, utils.FloatMul(context.Space.DoorwayWidth, context.Space.DoorwayWallThickness, -1), -1)
				}
				return number, nil
			},
		},
		{
			Item: "地砖铺贴后成品保护",
			NumberCalc: func(context *ItemContext) (float64, error) {
				number := context.Space.Area
				if context.Space.DryWetSeparation {
					number = utils.FloatAdd(number, context.Space.WetArea, -1)
				}
				if context.Space.WideBed {
					number = utils.FloatAdd(number, utils.FloatMul(context.Space.DoorwayWidth, context.Space.DoorwayWallThickness, -1), -1)
				}
				return number, nil
			},
		},
		{
			Item: "卫生间地面防水",
			NumberCalc: func(context *ItemContext) (float64, error) {
				number := context.Space.Area
				if context.Space.DryWetSeparation {
					number = utils.FloatAdd(number, context.Space.WetArea, -1)
				}
				if context.Space.WideBed {
					number = utils.FloatAdd(number, utils.FloatMul(context.Space.DoorwayWidth, context.Space.DoorwayWallThickness, -1), -1)
				}
				return number, nil
			},
		},
		{
			ItemSelect: func(context *ItemContext) (string, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return "", nil
				}
				if mat.TypeId == 6 {
					return "墙面贴砖（600*1200mm）", nil
				}
				if mat.TypeId == 7 {
					return "墙面贴砖（750*1500mm）", nil
				}
				if mat.TypeId == 4 || mat.TypeId == 3 {
					return "墙面贴砖（400*800mm)", nil
				}
				return "墙面贴砖（300*300mm-300*600mm)", nil
			},
			Region: "墙砖",
			NumberCalc: func(context *ItemContext) (float64, error) {
				number := utils.FloatSub(utils.FloatMul(context.Space.Perimeter, 2.4, -1), utils.FloatMul(context.Space.DoorwayWidth, context.Space.DoorwayHeight, -1), -1)
				if context.Space.Windows != nil {
					for _, window := range context.Space.Windows {
						number = utils.FloatSub(number, utils.FloatMul(window.Length, window.Height, -1), -1)
						number = utils.FloatAdd(number, utils.FloatMul(utils.FloatMul(utils.FloatAdd(window.Length, window.Height, -1), 2, -1), window.Width, -1), -1)
					}
				}
				return number, nil
			},
			MaterialNumberCalc: func(context *ItemContext) (float64, error) {
				return 0, nil
			},
		},
		{
			Region: "墙砖",
			NumberCalc: func(context *ItemContext) (float64, error) {
				number := utils.FloatSub(utils.FloatMul(context.Space.Perimeter, 2.4, -1), utils.FloatMul(context.Space.DoorwayWidth, context.Space.DoorwayHeight, -1), -1)
				if context.Space.Windows != nil {
					for _, window := range context.Space.Windows {
						number = utils.FloatSub(number, utils.FloatMul(window.Length, window.Height, -1), -1)
						number = utils.FloatAdd(number, utils.FloatMul(utils.FloatMul(utils.FloatAdd(window.Length, window.Height, -1), 2, -1), window.Width, -1), -1)
					}
				}
				return number, nil
			},
			LossCalc: func(context *ItemContext) (float64, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return 1, nil
				}
				loss := map[int64]float64{
					10: 1.08, 9: 1.08, 7: 1.1, 6: 1.1, 5: 1.1, 4: 1.08, 3: 1.08,
				}
				return loss[mat.TypeId], nil
			},
			ConvertCalc: func(context *ItemContext) (float64, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return 1, nil
				}
				area := map[int64]float64{
					10: 0.09, 9: 0.18, 7: 1.125, 6: 0.72, 5: 0.64, 4: 0.16, 3: 0.32,
				}
				return utils.FloatDiv(1, area[mat.TypeId], -1), nil
			},
			CostLossCalc: func(context *ItemContext) (float64, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return 1, nil
				}
				loss := map[int64]float64{
					110: 1.1, 10: 1.2, 9: 1.2, 7: 1.2, 6: 1.2, 5: 1.2, 4: 1.2, 3: 1.2,
				}
				return loss[mat.TypeId], nil
			},
			Unit:           "m²",
			MaterialRound:  true,
			ControlPrice:   map[int]float64{A10: 81, A8: 56, A5: 31, ZZ1_0: 56},
			DeductionPrice: map[int]float64{A10: 55, A8: 40, A5: 30, ZZ1_0: 40},
		},
		{
			Item: "卫生间墙面防水",
			NumberCalc: func(context *ItemContext) (float64, error) {
				return context.Space.Perimeter * 1.5, nil
			},
		},
		{
			Region:         "浴室柜（含龙头）",
			Number:         1,
			Unit:           "套",
			ControlPrice:   map[int]float64{A10: 1630, A8: 1000, A5: 960, ZZ1_0: 1000},
			DeductionPrice: map[int]float64{A10: 1500, A8: 1000, A5: 900, ZZ1_0: 1000},
		},
		{
			Region:         "淋浴花洒",
			Number:         1,
			Unit:           "套",
			ControlPrice:   map[int]float64{A10: 650, A8: 390, A5: 400, ZZ1_0: 400},
			DeductionPrice: map[int]float64{A10: 600, A8: 390, A5: 350, ZZ1_0: 390},
		},
		{
			Region:         "马桶蹲坑",
			Number:         1,
			Unit:           "套",
			ControlPrice:   map[int]float64{A10: 720, A8: 450, A5: 500, ZZ1_0: 460},
			DeductionPrice: map[int]float64{A10: 650, A8: 450, A5: 420, ZZ1_0: 450},
		},
		{
			Region: "集成吊顶",
			NumberCalc: func(context *ItemContext) (float64, error) {
				number := context.Space.Area
				if context.Space.DryWetSeparation {
					number = utils.FloatAdd(number, context.Space.WetArea, -1)
				}
				return number, nil
			},
			Loss: 1.08,
			ConvertCalc: func(context *ItemContext) (float64, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return 1, nil
				}
				area := map[int64]float64{
					128: 1, 188: 0.18, 187: 0.09,
				}
				return utils.FloatDiv(1, area[mat.TypeId], -1), nil
			},
			Unit:           "m²",
			MaterialRound:  true,
			ControlPrice:   map[int]float64{A10: 90, A8: 90, A5: 75, ZZ1_0: 90},
			DeductionPrice: map[int]float64{A10: 80, A8: 80, A5: 70, ZZ1_0: 80},
		},
		/*{
			Region:         "吊顶灯",
			Number:         1,
			Unit:           "个",
			ControlPrice:   map[int]float64{A10: 38, A8: 38, A5: 38},
			DeductionPrice: map[int]float64{A10: 40, A8: 40, A5: 40},
		},*/
		{
			Region: "浴霸",
			NumberCalc: func(context *ItemContext) (float64, error) {
				if context.Pkg.RoomData.Pkg.Type == ZZ1_0 {
					return 1, nil
				}
				return 0, nil
			},
			Unit:           "个",
			ControlPrice:   map[int]float64{A10: 0, A8: 0, A5: 0, ZZ1_0: 242},
			DeductionPrice: map[int]float64{A10: 0, A8: 0, A5: 0, ZZ1_0: 235},
		},
		{
			Region: "淋浴隔断",
			NumberCalc: func(context *ItemContext) (float64, error) {
				if context.Pkg.RoomData.Pkg.Type == ZZ1_0 {
					return 3.2, nil
				}
				return 0, nil
			},
			Unit:           "m²",
			ControlPrice:   map[int]float64{A10: 0, A8: 0, A5: 0, ZZ1_0: 285},
			DeductionPrice: map[int]float64{A10: 0, A8: 0, A5: 0, ZZ1_0: 850 / 3.2},
		},
		{
			Item:   "安装石基",
			Region: "石基",
			NumberCalc: func(context *ItemContext) (float64, error) {
				if context.Pkg.RoomData.Pkg.Type == ZZ1_0 {
					return 1.6, nil
				}
				return 0, nil
			},
			Unit:           "m",
			ControlPrice:   map[int]float64{A10: 0, A8: 0, A5: 0, ZZ1_0: 35},
			DeductionPrice: map[int]float64{A10: 0, A8: 0, A5: 0, ZZ1_0: 50 / 1.6},
		},
		{
			Region: "五金挂件",
			NumberCalc: func(context *ItemContext) (float64, error) {
				return 1, nil
			},
			Unit:           "套",
			ControlPrice:   map[int]float64{A10: 0, A8: 0, A5: 0, ZZ1_0: 238},
			DeductionPrice: map[int]float64{A10: 0, A8: 0, A5: 0, ZZ1_0: 190},
		},
	},
	4: {
		{
			Item: "安装门槛石",
			NumberCalc: func(context *ItemContext) (float64, error) {
				if context.Space.WideBed {
					return 0, nil
				}
				return context.Space.DoorwayWidth, nil
			},
		},
		{
			Region: "门槛石",
			NumberCalc: func(context *ItemContext) (float64, error) {
				if context.Space.WideBed {
					return 0, nil
				}
				return context.Space.DoorwayWidth, nil
			},
			ConvertCalc: func(context *ItemContext) (float64, error) {
				return float64(context.Space.DoorwayWallThickness), nil
			},
			Unit:         "m",
			ControlPrice: map[int]float64{A10: 89, A8: 89, A5: 0, ZZ1_0: 89},
			AdditionalMaterialCalc: func(context *ItemContext) ([]MaterialItem, error) {
				mat := context.GetMat(1610)
				if mat == nil {
					return nil, errors.New("找不到材料: " + db.ToString(1610))
				}
				typ, ok := context.MatTypeCache[mat.TypeId]
				if !ok {
					return nil, errors.New("找不到材料类型: " + db.ToString(mat.TypeId))
				}
				total := utils.FloatMul(mat.Price, context.Space.DoorwayWidth, 3)
				materials := []MaterialItem{{
					Material:   1610,
					Name:       mat.Brand + " " + mat.Series + " " + mat.Model + " " + mat.Specs + " " + mat.Color,
					Type:       "门槛石",
					Unit:       typ.Unit,
					Number:     context.Space.DoorwayWidth,
					Price:      mat.Price,
					Total:      total,
					CostNumber: context.Space.DoorwayWidth,
					CostTotal:  total,
					Index:      -1,
				}}
				if context.Region.Material == 52 || context.Region.Material == 53 || context.Region.Material == 54 {
					mat := context.GetMat(55)
					if mat == nil {
						return nil, errors.New("找不到材料: " + db.ToString(55))
					}
					typ, ok := context.MatTypeCache[mat.TypeId]
					if !ok {
						return nil, errors.New("找不到材料类型: " + db.ToString(mat.TypeId))
					}
					number := utils.FloatMul(8, context.Space.DoorwayWidth, 3)
					total := utils.FloatMul(mat.Price, number, 3)
					materials = append(materials, MaterialItem{
						Material:   55,
						Name:       mat.Brand + " " + mat.Series + " " + mat.Model + " " + mat.Specs + " " + mat.Color,
						Type:       "钢筋成本",
						Unit:       typ.Unit,
						Number:     number,
						Price:      mat.Price,
						Total:      total,
						CostNumber: number,
						CostTotal:  total,
						Index:      -1,
					})
				}
				return materials, nil
			},
			NoUpgrade: true,
		},
		{
			ItemSelect: func(context *ItemContext) (string, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return "", nil
				}
				if mat.TypeId == 6 {
					return "墙面贴砖（600*1200mm）", nil
				}
				if mat.TypeId == 7 {
					return "墙面贴砖（750*1500mm）", nil
				}
				if mat.TypeId == 4 || mat.TypeId == 3 {
					return "墙面贴砖（400*800mm)", nil
				}
				return "墙面贴砖（300*300mm-300*600mm)", nil
			},
			Region: "墙砖",
			NumberCalc: func(context *ItemContext) (float64, error) {
				if context.Pkg.RoomData.Pkg.Type != ZZ1_0 {
					return 0, nil
				}
				number := utils.FloatSub(utils.FloatMul(context.Space.Perimeter, 2.4, -1), utils.FloatMul(context.Space.DoorwayWidth, context.Space.DoorwayHeight, -1), -1)
				if context.Space.Windows != nil {
					for _, window := range context.Space.Windows {
						number = utils.FloatSub(number, utils.FloatMul(window.Length, window.Height, -1), -1)
						number = utils.FloatAdd(number, utils.FloatMul(utils.FloatMul(utils.FloatAdd(window.Length, window.Height, -1), 2, -1), window.Width, -1), -1)
					}
				}
				return number, nil
			},
			MaterialNumberCalc: func(context *ItemContext) (float64, error) {
				return 0, nil
			},
		},
		{
			Region: "墙砖",
			NumberCalc: func(context *ItemContext) (float64, error) {
				if context.Pkg.RoomData.Pkg.Type != ZZ1_0 {
					return 0, nil
				}
				number := utils.FloatSub(utils.FloatMul(context.Space.Perimeter, 2.4, -1), utils.FloatMul(context.Space.DoorwayWidth, context.Space.DoorwayHeight, -1), -1)
				if context.Space.Windows != nil {
					for _, window := range context.Space.Windows {
						number = utils.FloatSub(number, utils.FloatMul(window.Length, window.Height, -1), -1)
						number = utils.FloatAdd(number, utils.FloatMul(utils.FloatMul(utils.FloatAdd(window.Length, window.Height, -1), 2, -1), window.Width, -1), -1)
					}
				}
				return number, nil
			},
			LossCalc: func(context *ItemContext) (float64, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return 1, nil
				}
				loss := map[int64]float64{
					10: 1.08, 9: 1.08, 7: 1.1, 6: 1.1, 5: 1.1, 4: 1.08, 3: 1.08,
				}
				return loss[mat.TypeId], nil
			},
			ConvertCalc: func(context *ItemContext) (float64, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return 1, nil
				}
				area := map[int64]float64{
					10: 0.09, 9: 0.18, 7: 1.125, 6: 0.72, 5: 0.64, 4: 0.16, 3: 0.32,
				}
				return utils.FloatDiv(1, area[mat.TypeId], -1), nil
			},
			CostLossCalc: func(context *ItemContext) (float64, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return 1, nil
				}
				loss := map[int64]float64{
					110: 1.1, 10: 1.2, 9: 1.2, 7: 1.2, 6: 1.2, 5: 1.2, 4: 1.2, 3: 1.2,
				}
				return loss[mat.TypeId], nil
			},
			Unit:           "m²",
			MaterialRound:  true,
			ControlPrice:   map[int]float64{A10: 0, A8: 0, A5: 0, ZZ1_0: 56},
			DeductionPrice: map[int]float64{A10: 0, A8: 0, A5: 0, ZZ1_0: 40},
		},
		{
			ItemSelect: func(context *ItemContext) (string, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return "", nil
				}
				if mat.TypeId == 6 {
					return "地面贴砖（600*1200mm）", nil
				}
				if mat.TypeId == 7 {
					return "地面贴砖（750*1500mm）", nil
				}
				return "地面贴砖（300*300mm-800*800mm）", nil
			},
			Region: "地砖",
			NumberCalc: func(context *ItemContext) (float64, error) {
				number := context.Space.Area
				if context.Space.WideBed {
					number = utils.FloatAdd(number, utils.FloatMul(context.Space.DoorwayWidth, context.Space.DoorwayWallThickness, -1), -1)
				}
				return number, nil
			},
			MaterialNumberCalc: func(context *ItemContext) (float64, error) {
				return 0, nil
			},
			DiffPriceCalc: func(context *ItemContext) (float64, error) {
				price, err := context.Item.GetPrice(context)
				if err != nil {
					return 0, err
				}
				if price < 68 {
					return 0, nil
				}
				return utils.FloatSub(price, 68, -1), nil
			},
		},
		{
			Region:       "地砖",
			MaterialType: "地砖",
			NumberCalc: func(context *ItemContext) (float64, error) {
				number := context.Space.Area
				if context.Space.WideBed {
					number = utils.FloatAdd(number, utils.FloatMul(context.Space.DoorwayWidth, context.Space.DoorwayWallThickness, -1), -1)
				}
				return number, nil
			},
			LossCalc: func(context *ItemContext) (float64, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return 1, nil
				}
				loss := map[int64]float64{
					10: 1.08, 9: 1.08, 7: 1.1, 6: 1.1, 5: 1.1, 4: 1.08, 3: 1.08,
				}
				return loss[mat.TypeId], nil
			},
			ConvertCalc: func(context *ItemContext) (float64, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return 1, nil
				}
				area := map[int64]float64{
					10: 0.09, 9: 0.18, 7: 1.125, 6: 0.72, 5: 0.64, 4: 0.16, 3: 0.32,
				}
				return utils.FloatDiv(1, area[mat.TypeId], -1), nil
			},
			CostLossCalc: func(context *ItemContext) (float64, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return 1, nil
				}
				loss := map[int64]float64{
					110: 1.1, 10: 1.2, 9: 1.2, 7: 1.2, 6: 1.2, 5: 1.2, 4: 1.2, 3: 1.2,
				}
				return loss[mat.TypeId], nil
			},
			Unit:           "m²",
			MaterialRound:  true,
			ControlPrice:   map[int]float64{A10: 81, A8: 56, A5: 36, ZZ1_0: 56},
			DeductionPrice: map[int]float64{A10: 55, A8: 40, A5: 30, ZZ1_0: 40},
		},
		{
			Item: "地砖铺贴后成品保护",
			NumberCalc: func(context *ItemContext) (float64, error) {
				number := context.Space.Area
				if context.Space.WideBed {
					number = utils.FloatAdd(number, utils.FloatMul(context.Space.DoorwayWidth, context.Space.DoorwayWallThickness, -1), -1)
				}
				return number, nil
			},
		},
		{
			Item: "阳台地面防水",
			NumberCalc: func(context *ItemContext) (float64, error) {
				if context.Pkg.RoomData.Pkg.Type != ZZ1_0 {
					return 0, nil
				}
				number := utils.FloatAdd(context.Space.Area, utils.FloatMul(context.Space.Perimeter, 0.3, -1), -1)
				if context.Space.WideBed {
					number = utils.FloatAdd(number, utils.FloatMul(context.Space.DoorwayWidth, context.Space.DoorwayWallThickness, -1), -1)
				}
				return number, nil
			},
		},
		/*{
			Item: "踢脚线铺贴（明贴）",
			NumberCalc: func(context *ItemContext) (float64, error) {
				number := utils.FloatSubSlice([]float64{context.Space.Perimeter, context.Space.DoorwayWidth}, -1)
				if number < 0 {
					return 0, nil
				}
				return number, nil
			},
		},
		{
			Region:       "地砖",
			MaterialType: "瓷砖地脚线",
			NumberCalc: func(context *ItemContext) (float64, error) {
				number := utils.FloatSubSlice([]float64{context.Space.Perimeter, context.Space.DoorwayWidth}, -1)
				if number < 0 {
					return 0, nil
				}
				return number, nil
			},
			ConvertCalc: func(context *ItemContext) (float64, error) {
				mat := context.GetMat(context.Region.Material)
				if mat == nil {
					return 1, nil
				}
				lineArea := map[int64]float64{
					10: 0.6, 9: 1.2, 7: 11.25, 6: 7.2, 5: 6.4, 4: 0.8, 3: 1.6,
				}
				return utils.FloatDiv(1, lineArea[mat.TypeId], -1), nil
			},
			Unit:           "m",
			MaterialRound:  true,
			ControlPrice:   map[int]float64{A10: 16, A8: 12, A5: 8},
			DeductionPrice: map[int]float64{A10: 12, A8: 8, A5: 6},
			AdditionalMaterialCalc: func(context *ItemContext) ([]MaterialItem, error) {
				number := utils.FloatSubSlice([]float64{context.Space.Perimeter, context.Space.DoorwayWidth}, -1)
				if number < 0 {
					number = 0
				}
				number = utils.FloatMul(number, 2, 3)
				ymat := context.GetMat(context.Region.Material)
				if ymat == nil {
					return nil, errors.New("找不到材料: " + db.ToString(context.Region.Material))
				}
				var mat final.FinalMat
				db.GetModel(map[string]interface{}{
					"supplier_id": ymat.SupplierId,
					"model":       "其他费用",
					"deleted_at":  0,
				}, &mat)
				if mat.ID == 0 {
					return []MaterialItem{}, nil
				}

				typ, ok := context.MatTypeCache[mat.TypeId]
				if !ok {
					return nil, errors.New("找不到材料类型: " + db.ToString(mat.TypeId))
				}
				total := utils.FloatMul(mat.Price, number, 3)
				return []MaterialItem{{
					Material:   mat.ID,
					Name:       mat.Brand + " " + mat.Series + " " + mat.Model + " " + mat.Specs + " " + mat.Color,
					Type:       "瓷砖地脚线",
					Unit:       typ.Unit,
					Number:     number,
					Price:      mat.Price,
					Total:      total,
					CostNumber: number,
					CostTotal:  total,
					Index:      -1,
				}}, nil
			},
		},*/
		{
			Region: "洗衣机龙头",
			NumberCalc: func(context *ItemContext) (float64, error) {
				if context.SpaceIndex == 0 {
					return 1, nil
				}
				return 0, nil
			},
			Unit:           "套",
			ControlPrice:   map[int]float64{A10: 30, A8: 30, A5: 30, ZZ1_0: 30},
			DeductionPrice: map[int]float64{A10: 30, A8: 30, A5: 30, ZZ1_0: 30},
		},
	},
}

var SubsidyItems = []SubsidyItemObject{
	{
		Name:   "主材配合费",
		Unit:   "项",
		Number: 1,
		Price:  500,
	},
	{
		Name:   "人工、材料补差费",
		Unit:   "项",
		Number: 1,
		Price:  2000,
	},
	{
		Name: "23年增加补贴",
		Unit: "m²",
		NumberCalc: func(context *ItemContext) (float64, error) {
			return context.Pkg.RoomData.Pkg.Area, nil
		},
		Price: 12,
	},
	{
		Name: "2024年增加大砖铺贴补贴费",
		Unit: "m²",
		NumberCalc: func(context *ItemContext) (float64, error) {
			if context.Pkg.RoomData.Pkg.Type == A5 || context.Pkg.RoomData.Pkg.Type == ZZ1_0 {
				return 0, nil
			}
			number := float64(0)
			for _, typ := range []int{2, 3} {
				for _, space := range context.Pkg.RoomData.Space[typ] {
					numbers := utils.FloatSub(utils.FloatMul(space.Perimeter, 2.4, -1), utils.FloatMul(space.DoorwayWidth, space.DoorwayHeight, -1), -1)
					if numbers > 0 {
						number = utils.FloatAdd(number, numbers, -1)
					}
				}
			}
			return number, nil
		},
		Price: 25,
	},
	{
		Name:   "截止阀",
		Unit:   "个",
		Number: 1,
		Price:  39,
	},
	{
		Name:   "排气、空调打孔费",
		Unit:   "项",
		Number: 1,
		PriceCalc: func(context *ItemContext) (float64, error) {
			price := 170
			if context.Pkg.RoomData.Pkg.Layout[0] > 2 {
				price += 30 * (context.Pkg.RoomData.Pkg.Layout[0] - 2)
			}
			if context.Pkg.RoomData.Pkg.Layout[3] > 1 {
				price += 30 * (context.Pkg.RoomData.Pkg.Layout[3] - 1)
			}
			return float64(price), nil
		},
	},
	{
		Name: "水电卫生间走顶管工艺",
		Unit: "间",
		NumberCalc: func(context *ItemContext) (float64, error) {
			return float64(context.Pkg.RoomData.Pkg.Layout[3]), nil
		},
		Price: 200,
	},
	{
		Name: "厨房洗菜盆下水管",
		Unit: "个",
		NumberCalc: func(context *ItemContext) (float64, error) {
			return float64(context.Pkg.RoomData.Pkg.Layout[2]), nil
		},
		Price: 100,
	},
	{
		Name: "下沉式卫生间排水管",
		Unit: "个",
		NumberCalc: func(context *ItemContext) (float64, error) {
			number := 0
			for _, space := range context.Pkg.RoomData.Space[3] {
				if space.SinkBackfill {
					number++
				}
			}
			return float64(number), nil
		},
		Price: 50,
	},
}

func 瓷砖材料限选品牌(context *ItemContext) ([]PersonalItem, error) {
	items := make([]PersonalItem, 0)
	nums := map[int]int{A10: 2, A8: 1, A5: 1, ZZ1_0: 1}
	supplierMap := make(map[int64]int)
	for _, materialss := range context.Pkg.BuildBudget.Materials {
		for _, materials := range materialss {
			for _, material := range materials {
				mat := context.GetMat(material.Material)
				if mat != nil {
					typ := context.GetMatTopType(mat.TypeId)
					if typ != nil {
						if typ.ID == 2 {
							supplierMap[mat.SupplierId] = 1
						}
					}
				}
			}
		}
	}
	if len(supplierMap) > nums[context.Pkg.RoomData.Pkg.Type] {
		number := float64(len(supplierMap) - nums[context.Pkg.RoomData.Pkg.Type])
		total := utils.FloatMul(number, 200, 3)
		items = append(items, PersonalItem{
			Name:   "瓷砖材料增加品牌",
			Unit:   "套",
			Number: number,
			Price:  200,
			Total:  total,
			Index:  -1,
		})
	}
	return items, nil
}

func 地板材料限选品牌(context *ItemContext) ([]PersonalItem, error) {
	items := make([]PersonalItem, 0)
	supplierMap := make(map[int64]int)
	for _, materialss := range context.Pkg.BuildBudget.Materials {
		for _, materials := range materialss {
			for _, material := range materials {
				mat := context.GetMat(material.Material)
				if mat != nil {
					typ := context.GetMatTopType(mat.TypeId)
					if typ != nil {
						if typ.ID == 11 {
							supplierMap[mat.SupplierId] = 1
						}
					}
				}
			}
		}
	}
	if len(supplierMap) > 1 {
		number := float64(len(supplierMap) - 1)
		total := utils.FloatMul(number, 200, 3)
		items = append(items, PersonalItem{
			Name:   "地板材料增加品牌",
			Unit:   "套",
			Number: number,
			Price:  200,
			Total:  total,
			Index:  -1,
		})
	}
	return items, nil
}

func 卫浴材料限选品牌(context *ItemContext) ([]PersonalItem, error) {
	items := make([]PersonalItem, 0)
	supplierMap := make(map[int64]map[int]int)
	number := 0
	for _, materialss := range context.Pkg.BuildBudget.Materials {
		for _, materials := range materialss {
			spaceSupplierMap := make(map[int64]int)
			for _, material := range materials {
				mat := context.GetMat(material.Material)
				if mat != nil {
					if _, ok := supplierMap[mat.SupplierId]; !ok {
						supplierMap[mat.SupplierId] = make(map[int]int)
					}
					if mat.TypeId == 97 {
						spaceSupplierMap[mat.SupplierId] = 1
						supplierMap[mat.SupplierId][0] = 1
					}
					if mat.TypeId == 98 || mat.TypeId == 99 {
						spaceSupplierMap[mat.SupplierId] = 1
						supplierMap[mat.SupplierId][1] = 1
					}
					if mat.TypeId == 100 || mat.TypeId == 101 || mat.TypeId == 102 || mat.TypeId == 103 {
						spaceSupplierMap[mat.SupplierId] = 1
						supplierMap[mat.SupplierId][2] = 1
					}
				}
			}
			if len(spaceSupplierMap) > 1 {
				number += len(spaceSupplierMap) - 1
			}
		}
	}
	supplierNumber := 0
	for _, ss := range supplierMap {
		if len(ss) < 3 {
			supplierNumber++
		}
	}
	if number > supplierNumber {
		number = supplierNumber
	}
	if number > 0 {
		total := utils.FloatMul(float64(number), 200, 3)
		items = append(items, PersonalItem{
			Name:   "卫浴材料增加品牌",
			Unit:   "套",
			Number: float64(number),
			Price:  200,
			Total:  total,
			Index:  -1,
		})
	}
	return items, nil
}

var MaterialAdditionalItems = []ItemPersonalFunction{瓷砖材料限选品牌, 地板材料限选品牌, 卫浴材料限选品牌}

func 石材运费(context *ItemContext) ([]MaterialItem, error) {
	for _, materialss := range context.Pkg.BuildBudget.Materials {
		for _, materials := range materialss {
			for _, material := range materials {
				mat := context.GetMat(material.Material)
				if mat != nil {
					if mat.SupplierId == 23 {
						mat := context.GetMat(55)
						if mat == nil {
							return nil, errors.New("找不到材料: " + db.ToString(material.Material))
						}
						typ, ok := context.MatTypeCache[mat.TypeId]
						if !ok {
							return nil, errors.New("找不到材料类型: " + db.ToString(mat.TypeId))
						}
						total := utils.FloatMul(mat.Price, 100, 3)
						return []MaterialItem{{
							Material:   55,
							Name:       mat.Brand + " " + mat.Series + " " + mat.Model + " " + mat.Specs + " " + mat.Color,
							Type:       "石材运费",
							Unit:       typ.Unit,
							Number:     100,
							Price:      mat.Price,
							Total:      total,
							CostNumber: 100,
							CostTotal:  total,
							Index:      -1,
						}}, nil
					}
				}
			}
		}
	}
	return []MaterialItem{}, nil
}

var AdditionalMaterials = []ItemMaterialFunction{石材运费}