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/application/productTrouble/query"
	"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),
		WorkerId:     troubleData.ProductWorker.UserId,
		WorkerName:   troubleData.ProductWorker.UserName,
	}
	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
}

// ListProductTrouble 事故管理列表
func (srv ProductTroubleService) ListProductTrouble(param *query.ListProductTrouble) (int64, []dto.ProductTroubleList, error) {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return 0, nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return 0, nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()

	productTroubleRepo, _ := factory.CreateProductTroubleRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	limit := param.PageSize
	offset := param.PageSize * (param.PageNumber - 1)
	condition := map[string]interface{}{
		"limit":     limit,
		"offsett":   offset,
		"companyId": param.CompanyId,
		"orgId":     param.OrgId,
	}

	if len(param.WorkerName) > 0 {
		condition["productWorkerName"] = param.WorkerName
	}

	if len(param.WorkshopName) > 0 {
		condition["workshopName"] = param.WorkshopName
	}
	cnt, troubleDataList, err := productTroubleRepo.Find(condition)
	if err != nil {
		return 0, nil, application.ThrowError(application.ARG_ERROR, "事故数据不存在，"+err.Error())
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return 0, nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}

	result := []dto.ProductTroubleList{}
	var item dto.ProductTroubleList
	for _, v := range troubleDataList {
		item = dto.ProductTroubleList{
			Id:                v.Id,
			WorkshopId:        v.WorkStation.WorkshopId,
			WorkshopName:      v.WorkStation.WorkshopName,
			LineId:            v.WorkStation.LineId,
			LineName:          v.WorkStation.LineName,
			SectionId:         v.WorkStation.SectionId,
			SectionName:       v.WorkStation.SectionName,
			Remark:            v.Remark,
			ProductDate:       v.RecordData.Format("2006-01-02"),
			AmountLoss:        v.AmountLoss,
			Types:             v.GetTypesName(),
			WorkerId:          v.ProductWorker.UserId,
			WorkerName:        v.ProductWorker.UserName,
			ApproveStatus:     int(v.ApproveStatus),
			ApproveStatusName: v.GetApproveStatusName(),
		}
		result = append(result, item)
	}
	return cnt, result, nil
}