package service

import (
	"github.com/linmadan/egglib-go/core/application"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/factory"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/permission/command"
	service "gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/role"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/domain"
)

type PermissionService struct {
}

func NewPermissionService() *PermissionService {
	newPermissionService := &PermissionService{}
	return newPermissionService
}

func (rs *PermissionService) Update(in *command.UpdatePermissionCommand) (interface{}, error) {
	transactionContext, err := factory.ValidateStartTransaction(in)
	if err != nil {
		return nil, err
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()

	permissionRepository := factory.CreatePermissionRepository(map[string]interface{}{"transactionContext": transactionContext})
	// 获取权限配置
	_, permissions, err := permissionRepository.Find(map[string]interface{}{"companyId": in.CompanyId})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if len(permissions) == 0 {
		return nil, application.ThrowError(application.BUSINESS_ERROR, "权限配置数据错误")
	}
	permission := permissions[0]
	permission.OptHrScore = in.OptHrScore
	permission.OptEvalScore = in.OptEvalScore

	// 超级管理员权限传参
	if in.OptConfirmPerf > 0 || in.CycleDeadLine != nil {
		superAdmin, err := service.GetSuperAdmin(transactionContext, int(in.CompanyId), int(in.UserId))
		if err != nil {
			return nil, err
		}
		if superAdmin != domain.RoleTypeSuperAdmin {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "没有操作权限")
		}

		switch in.OptConfirmPerf {
		case domain.PermissionOff, domain.PermissionOn:
		default:
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "是否需要员工确认绩效参数错误")
		}
		var cycleDeadLine = in.CycleDeadLine
		var allMinuteSelf = cycleDeadLine.AssessmentSelf.Hour*60 + cycleDeadLine.AssessmentSelf.Minute
		var allMinute360 = cycleDeadLine.AssessmentAll.Hour*60 + cycleDeadLine.AssessmentAll.Minute
		//var allMinuteHr = cycleDeadLine.AssessmentHr.Hour*60 + cycleDeadLine.AssessmentHr.Minute
		var allMinuteSuperior = cycleDeadLine.AssessmentSuperior.Hour*60 + cycleDeadLine.AssessmentSuperior.Minute
		var allMinuteMy = cycleDeadLine.ViewMyPerf.Hour*60 + cycleDeadLine.ViewMyPerf.Minute

		// 注. 360和人资评估时间截止是相同的（前端只传递一个360评估参数）
		cycleDeadLine.AssessmentHr.Hour = cycleDeadLine.AssessmentAll.Hour
		cycleDeadLine.AssessmentHr.Minute = cycleDeadLine.AssessmentAll.Minute

		if allMinuteSelf > allMinute360 {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "截止时间:[360评估]不能小于[综合自评]")
		}
		if allMinute360 > allMinuteSuperior {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "截止时间:[上级评估]不能小于[360评估]")
		}
		if allMinuteSuperior > allMinuteMy {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "截止时间:[查看我的绩效]不能小于[上级评估]")
		}
		permission.OptConfirmPerf = in.OptConfirmPerf
		permission.CycleDeadline = in.CycleDeadLine
	}

	permission, err = permissionRepository.Insert(permission)
	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 permission, nil
}

func (rs *PermissionService) Get(in *command.GetPermissionCommand) (*domain.Permission, error) {
	transactionContext, err := factory.ValidateStartTransaction(in)
	if err != nil {
		return nil, err
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()
	permissionRepository := factory.CreatePermissionRepository(map[string]interface{}{"transactionContext": transactionContext})

	// 获取权限配置
	_, permissions, err := permissionRepository.Find(map[string]interface{}{"companyId": in.CompanyId})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	var permission *domain.Permission
	if len(permissions) == 0 { // 不存在时，新增权限配置
		value := &domain.Permission{
			Id:             0,
			CompanyId:      in.CompanyId,
			OptHrScore:     domain.PermissionOff,
			OptEvalScore:   domain.PermissionOff,
			OptConfirmPerf: domain.PermissionOff,
			CycleDeadline:  rs.defaultCycleDeadline(),
		}
		permission, err = permissionRepository.Insert(value)
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
	} else {
		permission = permissions[0]
		// 纠正数据
		var isChange = false
		if permission.OptHrScore == 0 {
			isChange = true
			permission.OptHrScore = domain.PermissionOff
		}
		if permission.OptEvalScore == 0 {
			isChange = true
			permission.OptEvalScore = domain.PermissionOff
		}
		if permission.OptConfirmPerf == 0 {
			isChange = true
			permission.OptConfirmPerf = domain.PermissionOff
		}
		if permission.CycleDeadline == nil {
			isChange = true
			permission.CycleDeadline = rs.defaultCycleDeadline()
		}
		if isChange {
			permission, err = permissionRepository.Insert(permission)
			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 permission, nil
}

// 创建默认周期截止时间
func (rs *PermissionService) defaultCycleDeadline() *domain.CycleDeadline {
	return &domain.CycleDeadline{
		AssessmentSelf: domain.DeadlineTime{
			Hour:   3 * 24,
			Minute: 0,
		},
		AssessmentAll: domain.DeadlineTime{
			Hour:   5 * 24,
			Minute: 0,
		},
		AssessmentHr: domain.DeadlineTime{
			Hour:   5 * 24,
			Minute: 0,
		},
		AssessmentSuperior: domain.DeadlineTime{
			Hour:   7 * 24,
			Minute: 0,
		},
		ViewMyPerf: domain.DeadlineTime{
			Hour:   9 * 24,
			Minute: 0,
		},
	}
}