package service

import (
	"time"

	"github.com/linmadan/egglib-go/core/application"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-manufacture/pkg/application/factory"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-manufacture/pkg/application/productTrouble/command"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-manufacture/pkg/application/productTrouble/dto"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-manufacture/pkg/domain"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-manufacture/pkg/infrastructure/domainService"
)

// 事故管理
type ProductTroubleService struct{}

func NewProductTroubleService(options map[string]interface{}) *ProductTroubleService {
	newService := &ProductTroubleService{}
	return newService
}

func (srv ProductTroubleService) SaveProductTrouble(operateInfo *domain.OperateInfo, param *command.SaveProductTroubleCommand) (map[string]interface{}, error) {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()

	productTroubleRepo, _ := factory.CreateProductTroubleRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	workShopRepo, _ := factory.CreateWorkshopRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	//获取车间数据
	workShopData, err := workShopRepo.FindOne(map[string]interface{}{
		"workshopId": param.WorkshopId,
	})
	if err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, "车间数据不能存在"+err.Error())
	}
	if workShopData.CompanyId != operateInfo.CompanyId {
		return nil, application.ThrowError(application.ARG_ERROR, "车间数据填写错误")
	}
	workStation, err := workShopData.FindWorkStation(param.WorkshopId, param.LineId, param.WorkshopId)
	if err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, err.Error())
	}
	var workerUser *domain.User
	userService := domainService.NewUserService()
	workerUser, err = userService.User(param.WorkerId)
	if err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, "获取员工信息失败，"+err.Error())
	}
	recordDate, err := time.ParseInLocation("2006-01-02", param.RecordDate, time.Local)
	if err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, "日期格式错误")
	}
	var troubleData *domain.ProductTrouble
	if param.Id > 0 {
		troubleData, err = productTroubleRepo.FindOne(map[string]interface{}{
			"id": param.Id,
		})
		if err != nil {
			return nil, application.ThrowError(application.ARG_ERROR, "事故数据填写错误")
		}
	} else {
		troubleData = &domain.ProductTrouble{
			CompanyId:     operateInfo.CompanyId,
			OrgId:         operateInfo.OrgId,
			CreatedAt:     time.Now(),
			ApproveStatus: domain.TroubleWaitApprove,
		}
	}

	troubleData.AmountLoss = param.AmountLoss
	troubleData.ProductWorker = *workerUser
	troubleData.RecordData = recordDate
	troubleData.Remark = param.Remark
	troubleData.UpdatedAt = time.Now()
	troubleData.WorkStation = *workStation
	err = troubleData.SetTypes(param.Types)
	if err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, err.Error())
	}
	_, err = productTroubleRepo.Save(troubleData)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	return map[string]interface{}{
		"id": troubleData.Id,
	}, nil
}

func (srv ProductTroubleService) GetProductTrouble(id int) (*dto.ProductTroubleInfo, error) {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()

	productTroubleRepo, _ := factory.CreateProductTroubleRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	troubleData, err := productTroubleRepo.FindOne(map[string]interface{}{
		"id": id,
	})
	if err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, "事故数据不存在，"+err.Error())
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}

	result := dto.ProductTroubleInfo{
		Id:           troubleData.Id,
		WorkshopId:   troubleData.WorkStation.WorkshopId,
		WorkshopName: troubleData.WorkStation.WorkshopName,
		LineId:       troubleData.WorkStation.LineId,
		LineName:     troubleData.WorkStation.LineName,
		SectionId:    troubleData.WorkStation.SectionId,
		SectionName:  troubleData.WorkStation.SectionName,
		Remark:       troubleData.Remark,
		ProductDate:  troubleData.RecordData.Format("2006-01-02"),
		AmountLoss:   troubleData.AmountLoss,
		Types:        int(troubleData.Types),
	}
	return &result, nil
}

func (srv ProductTroubleService) DeleteProductTrouble(id int64) error {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()
	productTroubleRepo, _ := factory.CreateProductTroubleRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	troubleData, err := productTroubleRepo.FindOne(map[string]interface{}{
		"id": id,
	})
	if err != nil {
		return application.ThrowError(application.ARG_ERROR, "事故数据不存在，"+err.Error())
	}
	_, err = productTroubleRepo.Remove(troubleData)
	if err != nil {
		return application.ThrowError(application.ARG_ERROR, err.Error())
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	return nil
}

func (srv ProductTroubleService) ApproveProductTrouble(operateInfo *domain.OperateInfo, id int64) error {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()
	productTroubleRepo, _ := factory.CreateProductTroubleRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	troubleData, err := productTroubleRepo.FindOne(map[string]interface{}{
		"id": id,
	})
	if err != nil {
		return application.ThrowError(application.ARG_ERROR, "事故数据不存在，"+err.Error())
	}
	var approveUser *domain.User
	userService := domainService.NewUserService()
	approveUser, err = userService.User(operateInfo.UserId)
	if err != nil {
		return application.ThrowError(application.ARG_ERROR, "获取审核人信息失败，"+err.Error())
	}
	err = troubleData.Approve(approveUser)
	if err != nil {
		return application.ThrowError(application.ARG_ERROR, err.Error())
	}

	troubleData.UpdatedAt = time.Now()
	_, err = productTroubleRepo.Save(troubleData)
	if err != nil {
		return application.ThrowError(application.ARG_ERROR, err.Error())
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	return nil
}