package factory

import (
	"github.com/linmadan/egglib-go/core/application"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-manufacture/pkg/domain"
)

// FastPgWorkshop  快速返回车间对象
//
// transactionContext 事务
// id  对象唯一标识
func FastPgWorkshop(transactionContext application.TransactionContext, id int, options ...option) (domain.WorkshopRepository, *domain.Workshop, error) {
	var rep domain.WorkshopRepository
	var mod *domain.Workshop
	var err error
	if value, err := CreateWorkshopRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		rep = value
	}
	if id > 0 {
		if mod, err = rep.FindOne(map[string]interface{}{"workshopId": id}); err != nil {
			if err == domain.ErrorNotFound {
				return nil, nil, application.ThrowError(application.RES_NO_FIND_ERROR, "该车间不存在")
			}
			return nil, nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
	}
	//if err = fastPgDataAuth(transactionContext, mod, options...); err != nil {
	//	return nil, nil, err
	//}
	return rep, mod, err
}

// FastPgWorkshop  快速返回车间对象
//
// transactionContext 事务
// id  对象唯一标识
func FastPgWorkshops(transactionContext application.TransactionContext, companyId int, options ...option) (domain.Workshops, error) {
	var rep domain.WorkshopRepository
	//var mod *domain.Workshop
	var err error
	if value, err := CreateWorkshopRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		rep = value
	}
	_, workshops, err := rep.Find(map[string]interface{}{"companyId": companyId})
	if err != nil {
		return nil, err
	}
	if len(workshops) == 0 {
		workshops = make([]*domain.Workshop, 0)
	}
	return workshops, err
}

// FastPgWorkstation  快速返回工作定位对象
//
// transactionContext 事务
// workshopId  车间ID
// lineId      生产线ID
// sectionId   对象ID
func FastPgWorkstation(transactionContext application.TransactionContext, workshopId, lineId, sectionId int, options ...option) (domain.WorkshopRepository, *domain.WorkStation, error) {
	var rep domain.WorkshopRepository
	var mod *domain.Workshop
	var err error
	if value, err := CreateWorkshopRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		rep = value
	}

	if mod, err = rep.FindOne(map[string]interface{}{"workshopId": workshopId}); err != nil {
		if err == domain.ErrorNotFound {
			return nil, nil, application.ThrowError(application.RES_NO_FIND_ERROR, "该工作位置不存在")
		}
		return nil, nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}

	workStation, err := mod.FindWorkStation(workshopId, lineId, sectionId)
	if err != nil {
		return rep, nil, err
	}
	o := NewFastOptions(options...)
	if o.SetPrincipal {
		workStation.Principal = mod.Principal
	}
	return rep, workStation, err
}

// FastPgProductJob  快速返回工位对象
//
// transactionContext 事务
// id  对象唯一标识
func FastPgProductJob(transactionContext application.TransactionContext, id int, options ...option) (domain.ProductJobRepository, *domain.ProductJob, error) {
	var rep domain.ProductJobRepository
	var mod *domain.ProductJob
	var err error
	if value, err := CreateProductJobRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		rep = value
	}
	if id > 0 {
		if mod, err = rep.FindOne(map[string]interface{}{"productJobId": id}); err != nil {
			if err == domain.ErrorNotFound {
				return nil, nil, application.ThrowError(application.RES_NO_FIND_ERROR, "该工位不存在")
			}
			return nil, nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
	}
	//if err = fastPgDataAuth(transactionContext, mod, options...); err != nil {
	//	return nil, nil, err
	//}
	return rep, mod, err
}

// FastPgProductGroup  快速返回生产组对象
//
// transactionContext 事务
// id  对象唯一标识
func FastPgProductGroup(transactionContext application.TransactionContext, id int, options ...option) (domain.ProductGroupRepository, *domain.ProductGroup, error) {
	var rep domain.ProductGroupRepository
	var mod *domain.ProductGroup
	var err error
	if value, err := CreateProductGroupRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		rep = value
	}
	if id > 0 {
		if mod, err = rep.FindOne(map[string]interface{}{"productGroupId": id}); err != nil {
			if err == domain.ErrorNotFound {
				return nil, nil, application.ThrowError(application.RES_NO_FIND_ERROR, "该生产班组不存在")
			}
			return nil, nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
	}
	//if err = fastPgDataAuth(transactionContext, mod, options...); err != nil {
	//	return nil, nil, err
	//}
	return rep, mod, err
}

// FastPgProduct  快速返回产品对象
//
// transactionContext 事务
// id  对象唯一标识
func FastPgProduct(transactionContext application.TransactionContext, id int, options ...option) (domain.ProductRepository, *domain.Product, error) {
	var rep domain.ProductRepository
	var mod *domain.Product
	var err error
	if value, err := CreateProductRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		rep = value
	}
	if id > 0 {
		if mod, err = rep.FindOne(map[string]interface{}{"productId": id}); err != nil {
			if err == domain.ErrorNotFound {
				return nil, nil, application.ThrowError(application.RES_NO_FIND_ERROR, "该产品不存在")
			}
			return nil, nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
	}
	return rep, mod, err
}

// FastPgDevice  快速返回设备对象
//
// transactionContext 事务
// id  对象唯一标识
func FastPgDevice(transactionContext application.TransactionContext, id int, options ...option) (domain.DeviceRepository, *domain.Device, error) {
	var rep domain.DeviceRepository
	var mod *domain.Device
	var err error
	if value, err := CreateDeviceRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		rep = value
	}
	if id > 0 {
		if mod, err = rep.FindOne(map[string]interface{}{"deviceId": id}); err != nil {
			if err == domain.ErrorNotFound {
				return nil, nil, application.ThrowError(application.RES_NO_FIND_ERROR, "该设备档案不存在")
			}
			return nil, nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
	}
	return rep, mod, err
}

// FastPgProductCalendar  快速返回设备对象
//
// transactionContext 事务
// id  对象唯一标识
func FastPgProductCalendar(transactionContext application.TransactionContext, id int, options ...option) (domain.ProductCalendarRepository, *domain.ProductCalendar, error) {
	var rep domain.ProductCalendarRepository
	var mod *domain.ProductCalendar
	var err error
	if value, err := CreateProductCalendarRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		rep = value
	}
	if id > 0 {
		if mod, err = rep.FindOne(map[string]interface{}{"productCalendarId": id}); err != nil {
			if err == domain.ErrorNotFound {
				return nil, nil, application.ThrowError(application.RES_NO_FIND_ERROR, "该车间日历不存在")
			}
			return nil, nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
	}
	return rep, mod, err
}

// FastPgUnitConversion  快速返回单位换算对象
//
// transactionContext 事务
// id  对象唯一标识
func FastPgUnitConversion(transactionContext application.TransactionContext, id int, options ...option) (domain.UnitConversionRepository, *domain.UnitConversion, error) {
	var rep domain.UnitConversionRepository
	var mod *domain.UnitConversion
	var err error
	if value, err := CreateUnitConversionRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		rep = value
	}
	if id > 0 {
		if mod, err = rep.FindOne(map[string]interface{}{"unitConversionId": id}); err != nil {
			if err == domain.ErrorNotFound {
				return nil, nil, application.ThrowError(application.RES_NO_FIND_ERROR, "该单位换算不存在")
			}
			return nil, nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
	}
	return rep, mod, err
}

// FastPgProductPlan  快速返回生产计划对象
//
// transactionContext 事务
// id  对象唯一标识
func FastPgProductPlan(transactionContext application.TransactionContext, id int, options ...option) (domain.ProductPlanRepository, *domain.ProductPlan, error) {
	var rep domain.ProductPlanRepository
	var mod *domain.ProductPlan
	var err error
	if value, err := CreateProductPlanRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		rep = value
	}
	if id > 0 {
		if mod, err = rep.FindOne(map[string]interface{}{"productPlanId": id}); err != nil {
			if err == domain.ErrorNotFound {
				return nil, nil, application.ThrowError(application.RES_NO_FIND_ERROR, "该生产计划不存在")
			}
			return nil, nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
	}
	return rep, mod, err
}

// FastPgProductPlan  快速返回生产计划对象
//
// transactionContext 事务
// id  对象唯一标识
func FastPgProductPlanDispatchRecord(transactionContext application.TransactionContext, id int, options ...option) (domain.ProductPlanDispatchRecordRepository, *domain.ProductPlanDispatchRecord, error) {
	var rep domain.ProductPlanDispatchRecordRepository
	var mod *domain.ProductPlanDispatchRecord
	var err error
	if value, err := CreateProductPlanDispatchRecordRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		rep = value
	}
	if id > 0 {
		if mod, err = rep.FindOne(map[string]interface{}{"productPlanDispatchRecordId": id}); err != nil {
			if err == domain.ErrorNotFound {
				return nil, nil, application.ThrowError(application.RES_NO_FIND_ERROR, "该生产计划调度记录不存在")
			}
			return nil, nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
	}
	return rep, mod, err
}

// FastPgAttendance  快速返回考勤记录
//
// transactionContext 事务
// id  对象唯一标识
func FastPgAttendance(transactionContext application.TransactionContext, id int, options ...option) (domain.ProductAttendanceRecordRepository, *domain.ProductAttendanceRecord, error) {
	var rep domain.ProductAttendanceRecordRepository
	var mod *domain.ProductAttendanceRecord
	var err error
	if value, err := CreateProductAttendanceRecordRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		rep = value
	}
	if id > 0 {
		if mod, err = rep.FindOne(map[string]interface{}{"productAttendanceRecordId": id}); err != nil {
			if err == domain.ErrorNotFound {
				return nil, nil, application.ThrowError(application.RES_NO_FIND_ERROR, "该考勤记录不存在")
			}
			return nil, nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
	}
	return rep, mod, err
}

// FastPgProductRecord  快速返回生产记录
//
// transactionContext 事务
// id  对象唯一标识
func FastPgProductRecord(transactionContext application.TransactionContext, id int, options ...option) (domain.ProductRecordRepository, *domain.ProductRecord, error) {
	var rep domain.ProductRecordRepository
	var mod *domain.ProductRecord
	var err error
	if value, err := CreateProductRecordRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		rep = value
	}
	if id > 0 {
		if mod, err = rep.FindOne(map[string]interface{}{"productRecordId": id}); err != nil {
			if err == domain.ErrorNotFound {
				return nil, nil, application.ThrowError(application.RES_NO_FIND_ERROR, "该记录不存在")
			}
			return nil, nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
	}
	return rep, mod, err
}

// FastPgWorkshopWorkTimeRecord  快速返回生产记录
//
// transactionContext 事务
// id  对象唯一标识
func FastPgWorkshopWorkTimeRecord(transactionContext application.TransactionContext, id int, options ...option) (domain.WorkshopWorkTimeRecordRepository, *domain.WorkshopWorkTimeRecord, error) {
	var rep domain.WorkshopWorkTimeRecordRepository
	var mod *domain.WorkshopWorkTimeRecord
	var err error
	if value, err := CreateWorkshopWorkTimeRecordRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		rep = value
	}
	if id > 0 {
		if mod, err = rep.FindOne(map[string]interface{}{"workshopWorkTimeRecordId": id}); err != nil {
			if err == domain.ErrorNotFound {
				return nil, nil, application.ThrowError(application.RES_NO_FIND_ERROR, "该记录不存在")
			}
			return nil, nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
	}
	return rep, mod, err
}

// FastPgDeviceDailyRunningRecord  快速返回设备每日运行记录
//
// transactionContext 事务
// id  对象唯一标识
func FastPgDeviceDailyRunningRecord(transactionContext application.TransactionContext, id int, options ...option) (domain.DeviceDailyRunningRecordRepository, *domain.DeviceDailyRunningRecord, error) {
	var rep domain.DeviceDailyRunningRecordRepository
	var mod *domain.DeviceDailyRunningRecord
	var err error
	if value, err := CreateDeviceDailyRunningRecordRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		rep = value
	}
	if id > 0 {
		if mod, err = rep.FindOne(map[string]interface{}{"deviceDailyRunningRecordId": id}); err != nil {
			if err == domain.ErrorNotFound {
				return nil, nil, application.ThrowError(application.RES_NO_FIND_ERROR, "该记录不存在")
			}
			return nil, nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
	}
	return rep, mod, err
}

// FastProductMaterialGroup  快速返回物料
//
// transactionContext 事务
// id  对象唯一标识
func FastProductMaterialGroup(transactionContext application.TransactionContext, id int, options ...option) (domain.ProductMaterialGroupRepository, *domain.ProductMaterialGroup, error) {
	var rep domain.ProductMaterialGroupRepository
	var mod *domain.ProductMaterialGroup
	var err error
	if value, err := CreateProductMaterialGroupRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		rep = value
	}
	if id > 0 {
		if mod, err = rep.FindOne(map[string]interface{}{"productMaterialGroupId": id}); err != nil {
			if err == domain.ErrorNotFound {
				return nil, nil, application.ThrowError(application.RES_NO_FIND_ERROR, "该物料分组不存在")
			}
			return nil, nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
	}
	return rep, mod, err
}

// FastProductMaterialGroup  快速返回物料
//
// transactionContext 事务
// id  对象唯一标识
func FastProductMaterial(transactionContext application.TransactionContext, id int, options ...option) (domain.ProductMaterialRepository, *domain.ProductMaterial, error) {
	var rep domain.ProductMaterialRepository
	var mod *domain.ProductMaterial
	var err error
	if value, err := CreateProductMaterialRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		rep = value
	}
	if id > 0 {
		if mod, err = rep.FindOne(map[string]interface{}{"productMaterialId": id}); err != nil {
			if err == domain.ErrorNotFound {
				return nil, nil, application.ThrowError(application.RES_NO_FIND_ERROR, "该物料分组不存在")
			}
			return nil, nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
	}
	return rep, mod, err
}

/*****   2.配置  *****/

type FastOptions struct {
	DataAuthRequired bool
	SetPrincipal     bool
	OperateInfo      *domain.OperateInfo
}

func NewFastOptions(options ...option) *FastOptions {
	o := &FastOptions{
		DataAuthRequired: false,
	}
	for i := 0; i < len(options); i++ {
		options[i](o)
	}
	return o
}

type option func(options *FastOptions)

// 需要数据权限
func WithDataAuthRequired() option {
	return func(options *FastOptions) {
		options.DataAuthRequired = true
	}
}

// WithOperator 操作人
func WithOperator(op *domain.OperateInfo) option {
	return func(options *FastOptions) {
		options.OperateInfo = op
	}
}

// WithOperator 操作人
func WithSetPrincipal() option {
	return func(options *FastOptions) {
		options.SetPrincipal = true
	}
}