package model

import (
	"apsClient/pkg/sqlitex"
	"encoding/json"
	"fmt"
	"github.com/jinzhu/gorm"
)

type (
	Dashboard struct {
		CommonModel
		Version                       string
		DeviceRunningAmount           int   //开机台数
		TotalProductionAmount         int   //总产量
		WorkOrderAmount               int64 //生产工单数
		DelayWorkOrderAmount          int64 //延期交付工单数
		MaterialMissWorkOrderAmount   int   //物料不足工单数
		WaitSchedulingWorkOrderAmount int   //待排程工单数(库存充足未锁定 和 已锁定库存未排程的工单)
		PlanOrderFinishRate           int64 //计划达成率
		TotalDeviceAmount             int64 //总设备数
		InMaintenanceDeviceAmount     int64 //维修中设备数
		InternalDeviceRunningAmount   int   //自有开机台数
		ExternalDeviceRunningAmount   int   //外加工台数
		OutPlanProductionAmount       int   //计划外加工数
		PlanProductionAmount          int   //计划加工数
		RealExternalProductionAmount  int   //实际外加工数
		RealProductionAmount          int   //实际生产数
		WorkOrderFinishRate           int   //近一周工单完成率

		DeviceLoadData            string         //设备负荷对比分析
		DeviceLoad                []*CommonStats `gorm:"-"` //设备负荷对比分析
		MaterialRequirementData   string         //物料需求统计
		MaterialRequirement       []*CommonStats `gorm:"-"` //物料需求统计
		OrderFinishRateData       string         //订单完成比率
		OrderFinishRate           []*CommonStats `gorm:"-"` //订单完成比率
		PersonnelProductivityData string         //人员生产效率
		PersonnelProductivity     []*CommonStats `gorm:"-"` //人员生产效率
		WorkerTypeStatsData       string         //人员工种分析
		WorkerTypeStats           []*CommonStats `gorm:"-"` //人员工种分析

		TodayFinishAmount  int64             //车间当日合计生产
		TodayQualifiedRate string            //车间当日正品率
		WorkshopStatsData  string            //车间统计
		WorkshopStats      []*WorkshopStats  `gorm:"-"` //车间统计
		WorkOrderStatsData string            //工单进度统计
		WorkOrderStats     []*WorkOrderStats `gorm:"-"` //工单进度统计
	}

	CommonStats struct {
		Name  string
		Value string
	}

	WorkshopStats struct {
		Name      string //车间名称
		Total     int64  //生产总数
		Qualified int64  //正品数量
		Defective int    //次品数量
		Percent   int    //正品率
	}

	WorkOrderStats struct {
		Number                 string //编号
		Product                string //产品
		Scale                  string //规格
		Amount                 int64  //生产数量
		PlanTime               string //计划时间
		DelayDays              int    //延期天数
		ProcedureNum           int    //工序数量
		FinishProcedureNum     int    //已完成工序数量
		ProcessingProcedureNum int    //进行中工序数量
	}

	DashboardSearch struct {
		Dashboard
		Order    string
		PageNum  int
		PageSize int
		Orm      *gorm.DB
	}
)

const (
	VersionV1 = "v1" //12月9号央视访问版本
)

func (slf *Dashboard) TableName() string {
	return "dashboard"
}

func (slf *Dashboard) AfterFind(db *gorm.DB) error {
	var deviceLoad []*CommonStats
	var materialRequirement []*CommonStats
	var orderFinishRate []*CommonStats
	var personnelProductivity []*CommonStats
	var workerTypeStats []*CommonStats
	var workshopStats []*WorkshopStats
	var workOrderStats []*WorkOrderStats
	var err error
	if slf.DeviceLoadData != "" {
		if err = json.Unmarshal([]byte(slf.DeviceLoadData), &deviceLoad); err == nil {
			slf.DeviceLoad = deviceLoad
			slf.DeviceLoadData = ""
		}
	}
	if slf.MaterialRequirementData != "" {
		if err = json.Unmarshal([]byte(slf.MaterialRequirementData), &materialRequirement); err == nil {
			slf.MaterialRequirement = materialRequirement
			slf.MaterialRequirementData = ""
		}
	}
	if slf.OrderFinishRateData != "" {
		if err = json.Unmarshal([]byte(slf.OrderFinishRateData), &orderFinishRate); err == nil {
			slf.OrderFinishRate = orderFinishRate
			slf.OrderFinishRateData = ""
		}
	}
	if slf.PersonnelProductivityData != "" {
		if err = json.Unmarshal([]byte(slf.PersonnelProductivityData), &personnelProductivity); err == nil {
			slf.PersonnelProductivity = personnelProductivity
			slf.PersonnelProductivityData = ""
		}
	}

	if slf.WorkerTypeStatsData != "" {
		if err = json.Unmarshal([]byte(slf.WorkerTypeStatsData), &workerTypeStats); err == nil {
			slf.WorkerTypeStats = workerTypeStats
			slf.WorkerTypeStatsData = ""
		}
	}
	if slf.WorkshopStatsData != "" {
		if err = json.Unmarshal([]byte(slf.WorkshopStatsData), &workshopStats); err == nil {
			slf.WorkshopStats = workshopStats
			slf.WorkshopStatsData = ""
		}
	}
	if slf.WorkOrderStatsData != "" {
		if err = json.Unmarshal([]byte(slf.WorkOrderStatsData), &workOrderStats); err == nil {
			slf.WorkOrderStats = workOrderStats
			slf.WorkOrderStatsData = ""
		}
	}
	return nil
}

func NewDashboardSearch(db *gorm.DB) *DashboardSearch {
	if db == nil {
		db = sqlitex.GetDB()
	}
	return &DashboardSearch{Orm: db}
}

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

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

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

func (slf *DashboardSearch) SetId(id uint) *DashboardSearch {
	slf.ID = id
	return slf
}

func (slf *DashboardSearch) SetVersion(version string) *DashboardSearch {
	slf.Version = version
	return slf
}

func (slf *DashboardSearch) build() *gorm.DB {
	var db = slf.Orm.Model(&Dashboard{})

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

	if slf.Version == "" {
		slf.Version = VersionV1
	}

	db = db.Where("version = ?", VersionV1)

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

// Create 单条插入
func (slf *DashboardSearch) Create(record *Dashboard) 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 *DashboardSearch) CreateBatch(records []*Dashboard) error {
	var db = slf.build()
	for _, record := range records {
		if err := db.Create(record).Error; err != nil {
			return fmt.Errorf("create batch err: %v, records: %+v", err, records)
		}
	}
	return nil
}

func (slf *DashboardSearch) Upsert(record *Dashboard) error {
	var db = slf.build()
	old, err := slf.First()
	if err != gorm.ErrRecordNotFound && old.ID != 0 {
		record.ID = old.ID
		err = db.Save(&record).Error
	} else {
		err = db.Create(&record).Error
	}
	if err != nil {
		return fmt.Errorf("save err: %v, record: %+v", err, record)
	}

	return nil
}

func (slf *DashboardSearch) Save(record *Dashboard) error {
	var db = slf.build()

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

	return nil
}

func (slf *DashboardSearch) 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
}

func (slf *DashboardSearch) 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
}

func (slf *DashboardSearch) Delete() error {
	var db = slf.build()

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

	return nil
}

func (slf *DashboardSearch) First() (*Dashboard, error) {
	var (
		record = new(Dashboard)
		db     = slf.build()
	)

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

	return record, nil
}

func (slf *DashboardSearch) Find() ([]*Dashboard, int64, error) {
	var (
		records = make([]*Dashboard, 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
}

func (slf *DashboardSearch) Count() (int64, error) {
	var (
		total int64
		db    = slf.build()
	)
	if err := db.Count(&total).Error; err != nil {
		return total, fmt.Errorf("find count err: %v", err)
	}
	return total, nil
}

func (slf *DashboardSearch) FindNotTotal() ([]*Dashboard, error) {
	var (
		records = make([]*Dashboard, 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 *DashboardSearch) FindByQuery(query string, args []interface{}) ([]*Dashboard, int64, error) {
	var (
		records = make([]*Dashboard, 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 *DashboardSearch) FindByQueryNotTotal(query string, args []interface{}) ([]*Dashboard, error) {
	var (
		records = make([]*Dashboard, 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
}