package models

import (
	"fmt"
	"github.com/shopspring/decimal"
	"gorm.io/gorm"
	"silkserver/pkg/mysqlx"
)

type ProductionItemsType int

const (
	ProductionItemsTypeSilk    ProductionItemsType = iota + 1 // 正常纤
	ProductionItemsTypeBadSilk                                // 野纤
)

type (
	// PayrollProductionCar 工资计算-车台每天的产量统计
	PayrollProductionCar struct {
		BaseModelInt
		Cycle          string `json:"cycle" gorm:"index;size:20;not null;comment:统计周期（年月日）"` //统计周期（年月日）
		WorkshopId     uint   `json:"workshopId" gorm:"type:int(11);comment:车间Id"`
		WorkshopNumber string `json:"workshopNumber" gorm:"size:255;not null;comment:车间编号"` // 车间编号
		GroupNumber    int    `json:"groupNumber" gorm:"size:11;not null;comment:组别"`       // 组别
		CarNumber      int    `json:"carNumber"  gorm:"size:11;not null;comment:车台号"`       // 车台号

		CarWorkQuantity int    `json:"carWorkQuantity"  gorm:"size:11;default:1;comment:车台关联人员数量"` // 车台关联人员数量
		CarWorkIds      string `json:"carWorkIds"  gorm:"size:255;comment:车台关联挡车工ID"`              // 车台关联挡车工ID

		MarketId          uint            `json:"marketId" gorm:"type:int(11);not null;comment:庄口ID" `      //庄口编号
		MarketNumber      string          `json:"marketNumber" gorm:"size:50;not null;comment:庄口编号" `       //庄口编号
		MarketName        string          `json:"marketName" gorm:"size:255;comment:庄口名称" `                 //庄口名称
		FallingSilkBucket decimal.Decimal `json:"fallingSilkBucket" gorm:"type:decimal(12,2);comment:落丝桶数"` // 落丝桶数
		Spec              string          `json:"spec" gorm:"size:50;not null;comment:规格" `                 //规格

		DesiredLevel       string          `json:"desiredLevel" gorm:"size:50;comment:期望等级"`                     // 期望等级
		FinishLevel        string          `json:"finishLevel" gorm:"size:50;not null;comment:成品等级"`             // 成品等级
		SilkQuantity       decimal.Decimal `json:"silkQuantity" gorm:"type:decimal(12,4);comment:丝量"`            // 丝量
		SilkAvgQuantity    decimal.Decimal `json:"silkAvgQuantity" gorm:"type:decimal(12,4);comment:人平均丝量"`      // 人平均丝量
		SilkUnitAmount     decimal.Decimal `json:"silkUnitAmount" gorm:"type:decimal(12,2);comment:丝单价"`         // 丝单价
		SilkTotalAmount    decimal.Decimal `json:"silkTotalAmount" gorm:"type:decimal(12,4);comment:丝量总价"`       // 丝量总价
		SilkTotalAvgAmount decimal.Decimal `json:"silkTotalAvgAmount" gorm:"type:decimal(12,4);comment:丝量人平均总价"` // 丝量人平均总价

		BadSilkType           string          `json:"badSilkType" gorm:"size:50;comment:野纤类型"`                         // 野纤类型
		BadSilkQuantity       decimal.Decimal `json:"badSilkQuantity" gorm:"type:decimal(12,4);comment:野纤数量"`          // 野纤数量
		BadSilkAvgQuantity    decimal.Decimal `json:"badSilkAvgQuantity" gorm:"type:decimal(12,4);comment:野纤平均数量"`     // 野纤平均数量
		BadSilkUnitAmount     decimal.Decimal `json:"badSilkUnitAmount" gorm:"type:decimal(12,2);comment:野纤单价"`        // 野纤单价
		BadSilkTotalAmount    decimal.Decimal `json:"badSilkTotalAmount" gorm:"type:decimal(12,4);comment:野纤总价"`       // 野纤总价
		BadSilkTotalAvgAmount decimal.Decimal `json:"badSilkTotalAvgAmount" gorm:"type:decimal(12,4);comment:野纤人平均总价"` // 野纤人平均总价
		FinishTotalAvgAmount  decimal.Decimal `json:"finishTotalAvgAmount" gorm:"type:decimal(12,4);comment:成品人平均金额"`  // 成品人平均金额

		FinishTotalAmount decimal.Decimal `json:"finishTotalAmount" gorm:"type:decimal(12,4);comment:成品金额"` // 成品金额
	}

	SilkItem struct {
		Type       string          `json:"badSilkType" gorm:"size:50;not null;comment:类型"`           // 类型
		Quantity   decimal.Decimal `json:"badSilkQuantity" gorm:"type:decimal(12,4);comment:野纤数量"`   // 数量
		UnitAmount decimal.Decimal `json:"badSilkUnitAmount" gorm:"type:decimal(12,2);comment:野纤单价"` // 单价
	}

	PayrollProductionCarSearch struct {
		PayrollProductionCar
		Monthly  string
		Order    string
		PageNum  int
		PageSize int
		Orm      *gorm.DB
	}
)

func (slf PayrollProductionCar) TableName() string {
	return "silk_payroll_production_car"
}

// NewPayrollProductionCarSearch 车台每天的产量统计
func NewPayrollProductionCarSearch() *PayrollProductionCarSearch {
	return &PayrollProductionCarSearch{Orm: mysqlx.GetDB()}
}

func (slf *PayrollProductionCarSearch) SetOrm(tx *gorm.DB) *PayrollProductionCarSearch {
	slf.Orm = tx
	return slf
}

func (slf *PayrollProductionCarSearch) SetPage(page, size int) *PayrollProductionCarSearch {
	slf.PageNum, slf.PageSize = page, size
	return slf
}

func (slf *PayrollProductionCarSearch) SetOrder(order string) *PayrollProductionCarSearch {
	slf.Order = order
	return slf
}

func (slf *PayrollProductionCarSearch) SetID(id uint) *PayrollProductionCarSearch {
	slf.ID = id
	return slf
}

func (slf *PayrollProductionCarSearch) SetCycle(cycle string) *PayrollProductionCarSearch {
	slf.Cycle = cycle
	return slf
}

func (slf *PayrollProductionCarSearch) SetMonthly(monthly string) *PayrollProductionCarSearch {
	slf.Monthly = monthly
	return slf
}

func (slf *PayrollProductionCarSearch) SetWorkshopNumber(workshopNumber string) *PayrollProductionCarSearch {
	slf.WorkshopNumber = workshopNumber
	return slf
}

func (slf *PayrollProductionCarSearch) SetGroupNumber(groupNumber int) *PayrollProductionCarSearch {
	slf.GroupNumber = groupNumber
	return slf
}

func (slf *PayrollProductionCarSearch) SetMarketNumber(marketNumber string) *PayrollProductionCarSearch {
	slf.MarketNumber = marketNumber
	return slf
}

func (slf *PayrollProductionCarSearch) SetMarketName(marketName string) *PayrollProductionCarSearch {
	slf.MarketName = marketName
	return slf
}

func (slf *PayrollProductionCarSearch) SetCarNumber(carNumber int) *PayrollProductionCarSearch {
	slf.CarNumber = carNumber
	return slf
}

func (slf *PayrollProductionCarSearch) SetSpec(spec string) *PayrollProductionCarSearch {
	slf.Spec = spec
	return slf
}

func (slf *PayrollProductionCarSearch) SetDesiredLevel(desiredLevel string) *PayrollProductionCarSearch {
	slf.DesiredLevel = desiredLevel
	return slf
}

func (slf *PayrollProductionCarSearch) SetFinishLevel(finishLevel string) *PayrollProductionCarSearch {
	slf.FinishLevel = finishLevel
	return slf
}

func (slf *PayrollProductionCarSearch) SetBadSilkType(badSilkType string) *PayrollProductionCarSearch {
	slf.BadSilkType = badSilkType
	return slf
}

func (slf *PayrollProductionCarSearch) build() *gorm.DB {
	var db = slf.Orm.Table(slf.TableName())

	if slf.ID > 0 {
		db = db.Where("id = ?", slf.ID)
	}

	if slf.Cycle != "" {
		db = db.Where("cycle = ?", slf.Cycle)
	}

	if slf.Monthly != "" {
		db = db.Where("cycle like ?", slf.Monthly+"%")
	}

	if slf.WorkshopNumber != "" {
		db = db.Where("workshop_number = ?", slf.WorkshopNumber)
	}

	if slf.GroupNumber > 0 {
		db = db.Where("group_number = ?", slf.GroupNumber)
	}

	if slf.CarNumber > 0 {
		db = db.Where("car_number = ?", slf.CarNumber)
	}

	if slf.MarketNumber != "" {
		db = db.Where("market_number = ?", slf.MarketNumber)
	}

	if slf.MarketName != "" {
		db = db.Where("market_name like ?", "%"+slf.MarketName+"%")
	}

	if slf.Spec != "" {
		db = db.Where("spec = ?", slf.Spec)
	}

	if slf.DesiredLevel != "" {
		db = db.Where("desired_level = ?", slf.DesiredLevel)
	}

	if slf.FinishLevel != "" {
		db = db.Where("finish_level = ?", slf.FinishLevel)
	}

	if slf.BadSilkType != "" {
		db = db.Where("bad_silk_type = ?", slf.BadSilkType)
	}

	db.Where("1 = 1")
	if slf.Order != "" {
		db = db.Order(slf.Order)
	}

	return db
}

// Create 单条插入
func (slf *PayrollProductionCarSearch) Create(record *PayrollProductionCar) error {
	var db = slf.build()

	if err := db.Create(record).Error; err != nil {
		return fmt.Errorf("create err: %v, record: %+v", err, record)
	}

	return nil
}

// CreateBatch 批量插入
func (slf *PayrollProductionCarSearch) CreateBatch(records []*PayrollProductionCar) error {
	var db = slf.build()

	if err := db.Create(&records).Error; err != nil {
		return fmt.Errorf("create batch err: %v, records: %+v", err, records)
	}

	return nil
}

// Save 单条更新
func (slf *PayrollProductionCarSearch) Save(record *PayrollProductionCar) error {
	var db = slf.build()

	if err := db.Omit("CreatedAt").Save(record).Error; err != nil {
		return fmt.Errorf("save err: %v, record: %+v", err, record)
	}

	return nil
}

// SaveBatch 批量更新
func (slf *PayrollProductionCarSearch) SaveBatch(record []*PayrollProductionCar) error {
	var db = slf.build()

	if err := db.Omit("CreatedAt").Save(record).Error; err != nil {
		return fmt.Errorf("save err: %v, record: %+v", err, record)
	}

	return nil
}

// UpdateByMap 单条更新
func (slf *PayrollProductionCarSearch) UpdateByMap(upMap map[string]interface{}) error {
	var (
		db = slf.build()
	)

	if err := db.Updates(upMap).Error; err != nil {
		return fmt.Errorf("update by map err: %v, upMap: %+v", err, upMap)
	}

	return nil
}

// UpdateByQuery 批量更新
func (slf *PayrollProductionCarSearch) UpdateByQuery(query string, args []interface{}, upMap map[string]interface{}) error {
	var (
		db = slf.Orm.Table(slf.TableName()).Where(query, args...)
	)

	if err := db.Updates(upMap).Error; err != nil {
		return fmt.Errorf("update by query err: %v, query: %s, args: %+v, upMap: %+v", err, query, args, upMap)
	}

	return nil
}

// Delete 删除
func (slf *PayrollProductionCarSearch) Delete() error {
	var db = slf.build()

	if err := db.Unscoped().Delete(&PayrollProductionCar{}).Error; err != nil {
		return err
	}

	return nil
}

// First 根据条件查询一条记录
func (slf *PayrollProductionCarSearch) First() (*PayrollProductionCar, error) {
	var (
		record = new(PayrollProductionCar)
		db     = slf.build()
	)

	if err := db.First(record).Error; err != nil {
		return record, err
	}

	return record, nil
}

// Find 指定条件查询（包含总条数）
func (slf *PayrollProductionCarSearch) Find() ([]*PayrollProductionCar, int64, error) {
	var (
		records = make([]*PayrollProductionCar, 0)
		total   int64
		db      = slf.build()
	)

	if err := db.Count(&total).Error; err != nil {
		return records, total, fmt.Errorf("find count err: %v", err)
	}
	if slf.PageNum*slf.PageSize > 0 {
		db = db.Offset((slf.PageNum - 1) * slf.PageSize).Limit(slf.PageSize)
	}
	if err := db.Find(&records).Error; err != nil {
		return records, total, fmt.Errorf("find records err: %v", err)
	}

	return records, total, nil
}

// FindNotTotal 指定条件查询
func (slf *PayrollProductionCarSearch) FindNotTotal() ([]*PayrollProductionCar, error) {
	var (
		records = make([]*PayrollProductionCar, 0)
		db      = slf.build()
	)

	if slf.PageNum*slf.PageSize > 0 {
		db = db.Offset((slf.PageNum - 1) * slf.PageSize).Limit(slf.PageSize)
	}
	if err := db.Find(&records).Error; err != nil {
		return records, fmt.Errorf("find records err: %v", err)
	}

	return records, nil
}

// FindByQuery 指定条件查询（包含总条数）
func (slf *PayrollProductionCarSearch) FindByQuery(query string, args []interface{}) ([]*PayrollProductionCar, int64, error) {
	var (
		records = make([]*PayrollProductionCar, 0)
		total   int64
		db      = slf.Orm.Table(slf.TableName()).Where(query, args...)
	)

	if err := db.Count(&total).Error; err != nil {
		return records, total, fmt.Errorf("find by query count err: %v", err)
	}
	if slf.PageNum*slf.PageSize > 0 {
		db = db.Offset((slf.PageNum - 1) * slf.PageSize).Limit(slf.PageSize)
	}
	if err := db.Find(&records).Error; err != nil {
		return records, total, fmt.Errorf("find by query records err: %v, query: %s, args: %+v", err, query, args)
	}

	return records, total, nil
}

// FindByQueryNotTotal 指定条件查询&不查询总条数.
func (slf *PayrollProductionCarSearch) FindByQueryNotTotal(query string, args []interface{}) ([]*PayrollProductionCar, error) {
	var (
		records = make([]*PayrollProductionCar, 0)
		db      = slf.Orm.Table(slf.TableName()).Where(query, args...)
	)

	if slf.PageNum*slf.PageSize > 0 {
		db = db.Offset((slf.PageNum - 1) * slf.PageSize).Limit(slf.PageSize)
	}
	if err := db.Find(&records).Error; err != nil {
		return records, fmt.Errorf("find by query records err: %v, query: %s, args: %+v", err, query, args)
	}

	return records, nil
}

// InitDefaultData 初始化数据
func (slf *PayrollProductionCarSearch) InitDefaultData() error {
	var (
		db          = slf.Orm.Table(slf.TableName())
		total int64 = 0
	)
	date := "2024-06"
	if err := db.Where("cycle = ?", date).Count(&total).Error; err != nil {
		return err
	}
	if total != 0 {
		return nil
	}
	data := make([]*PayrollProductionCar, 0)

	//workers, _ := NewWorkerSearch().FindNotTotal()
	//
	//for _, record := range workers {
	//	data = append(data, &PayrollProductionCar{
	//		Cycle: date,
	//	})
	//}

	err := slf.CreateBatch(data)
	return err
}