package service

import (
	"github.com/linmadan/egglib-go/core/application"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/application/web/dividendsEstimate/command"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/application/web/dividendsEstimate/dto"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/application/web/dividendsEstimate/query"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/constant"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/domain"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/infrastructure/broker"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/infrastructure/service_gateway/allied_creation_cooperation"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/infrastructure/service_gateway/allied_creation_user"
	"strconv"
)

// 分红预算管理
type DividendsEstimateService struct {
}

//piliao  取消分红预算
func (dividendsEstimateService *DividendsEstimateService) CancelDividendsEstimate(cancelDividendsEstimateCommand *command.CancelDividendsEstimateCommand) (interface{}, error) {
	creationCooperationGateway := allied_creation_cooperation.NewHttplibAlliedCreationCooperation(cancelDividendsEstimateCommand.Operator)
	_, err := creationCooperationGateway.DividendsEstimatesBatchCancel(allied_creation_cooperation.ReqDividendsEstimateBatchCancel{
		DividendsEstimateIds: cancelDividendsEstimateCommand.DividendsEstimateId,
	})
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	return cancelDividendsEstimateCommand, nil
}

// 确定预算业绩分红激励
func (dividendsEstimateService *DividendsEstimateService) EstimateDividendsIncentives(estimateDividendsIncentivesCommand *command.EstimateDividendsIncentivesCommand) (interface{}, error) {
	creationCooperationGateway := allied_creation_cooperation.NewHttplibAlliedCreationCooperation(
		estimateDividendsIncentivesCommand.Operator)
	result, err := creationCooperationGateway.DividendsEstimateDividendsIncentives(allied_creation_cooperation.ReqDividendsEstimateDividendsIncentives{
		OrderGoodIds: estimateDividendsIncentivesCommand.OrderGoodIds,
	})
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	respData := map[string]string{
		"result": result.Report,
	}
	for _, v := range result.DividendsEstimates {
		if err = broker.Push(constant.TOPIC_UP_BLOCK_CHAIN, broker.NewPushObject(
			domain.BlockChainSourceCooperationDividendsEstimate,
			strconv.Itoa(int(v.DividendsEstimateId)),
			"",
			v,
		)); err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, "消息服务异常"+err.Error())
		}
	}
	return respData, nil
}

// 确定预算金额激励分红
func (dividendsEstimateService *DividendsEstimateService) EstimateMoneyIncentives(estimateMoneyIncentivesCommand *command.EstimateMoneyIncentivesCommand) (interface{}, error) {
	creationCooperationGateway := allied_creation_cooperation.NewHttplibAlliedCreationCooperation(
		estimateMoneyIncentivesCommand.Operator)
	result, err := creationCooperationGateway.DividendsEstimatesEstimateMoneys(allied_creation_cooperation.ReqDividendsEstimateMoneyIncentives{
		CooperationContractId:    estimateMoneyIncentivesCommand.CooperationContractId,
		DividendsIncentivesStage: estimateMoneyIncentivesCommand.DividendsIncentivesStage,
		UndertakerUids:           estimateMoneyIncentivesCommand.UndertakerUids,
		Action:                   estimateMoneyIncentivesCommand.CmdType,
	})
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	data := []map[string]interface{}{}
	for i := range result {
		item := map[string]interface{}{
			"userId":          result[i].DividendsUser.UserId,
			"userName":        result[i].DividendsUser.UserInfo.UserName,
			"dividendsAmount": result[i].DividendsAmount,
		}
		data = append(data, item)
	}
	returnData := map[string]interface{}{
		"list": data,
	}
	for _, v := range result {
		if err = broker.Push(constant.TOPIC_UP_BLOCK_CHAIN, broker.NewPushObject(
			domain.BlockChainSourceCooperationDividendsEstimate,
			strconv.Itoa(int(v.DividendsEstimateId)),
			"",
			v,
		)); err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, "消息服务异常"+err.Error())
		}
	}
	return returnData, nil
}

// 查询分红预算单列表
func (dividendsEstimateService *DividendsEstimateService) SearchDividendsEstimate(searchDividendsEstimateQuery *query.SearchDividendsEstimateQuery) (
	int, interface{}, error) {
	creationCooperationGateway := allied_creation_cooperation.NewHttplibAlliedCreationCooperation(
		searchDividendsEstimateQuery.Operator)
	result, err := creationCooperationGateway.DividendsEstimatesSearch(allied_creation_cooperation.ReqDividendsEstimateSearch{
		DividendsEstimateOrderNumber: searchDividendsEstimateQuery.DividendsEstimateOrderNumber, //承接人分红预算单号
		OrderOrReturnedOrderNum:      searchDividendsEstimateQuery.OrderOrReturnedOrderNum,
		DividendsType:                searchDividendsEstimateQuery.DividendsType, //分红类型，1订单分红，2退货冲销，3金额激励
		PageNumber:                   searchDividendsEstimateQuery.PageNumber,
		PageSize:                     searchDividendsEstimateQuery.PageSize,
		CompanyId:                    searchDividendsEstimateQuery.Operator.CompanyId,
		OrgIds:                       searchDividendsEstimateQuery.Operator.OrgIds,
	})
	if err != nil {
		return 0, nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	var primaryIdList = make([]string, 0)
	for _, v := range result.Grid.List {
		item := strconv.Itoa(v.DividendsEstimateId)
		primaryIdList = append(primaryIdList, item)
	}
	creationUserGateway := allied_creation_user.NewHttplibAlliedCreationUser(
		searchDividendsEstimateQuery.Operator)
	resp, err := creationUserGateway.ListBlockChains(allied_creation_user.ReqListBlockChain{
		DisableLimit:            true,
		EnableDistinctPrimaryID: true,
		PrimaryIDList:           primaryIdList,
		Source:                  domain.BlockChainSourceCooperationDividendsEstimate,
	})
	if err != nil {
		return 0, nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}
	mapChainItems := resp.ToMap()

	items := []dto.DividendsEstimateItem{}
	for _, v := range result.Grid.List {
		item := dto.DividendsEstimateItem{
			DividendsEstimateId:          v.DividendsEstimateId,
			DividendsAccountStatus:       v.DividendsAccountStatus,
			DividendsAmount:              v.DividendsAmount,
			DividendsEstimateOrderNumber: v.DividendsEstimateOrderNumber,
			DividendsEstimateTime:        v.DividendsEstimateTime.UnixNano() / 1e6,
			DividendsParticipateType:     v.DividendsParticipateType,
			DividendsType:                v.DividendsType,
			OrderOrReturnedOrderNum:      v.OrderOrReturnedOrderNum,
			CooperationProjectNumber:     v.CooperationProjectNumber,
			CooperationContractNumber:    v.CooperationContractNumber,
			DividendsIncentivesStage:     v.DividendsStage,
			IsCanceled:                   v.IsCanceled,
			AuthFlag:                     v.Org.OrgId == int(searchDividendsEstimateQuery.Operator.OrgId),
		}
		item.DividendsUser.Phone = v.DividendsUser.UserInfo.UserPhone
		item.DividendsUser.UsersName = v.DividendsUser.UserInfo.UserName
		item.DividendsUser.UsersId = v.DividendsUser.UserId
		item.DividendsUser.UserBaseId = v.DividendsUser.UserBaseId
		item.DividendsUser.UserType = v.DividendsUser.UserType
		item.Org.OrgId = v.Org.OrgId
		item.Org.OrgName = v.Org.OrgName

		primaryId := strconv.Itoa(v.DividendsEstimateId)
		if v, ok := mapChainItems[primaryId]; ok {
			item.UpChainID = v.UpChainID
			item.BlockHash = v.BlockHash
		}
		items = append(items, item)
	}

	return result.Grid.Total, items, nil
}

// 查询业绩分红
func (dividendsEstimateService *DividendsEstimateService) SearchDividendsIncentives(searchDividendsIncentivesQuery *query.SearchDividendsIncentivesQuery) (
	int, interface{}, error) {
	creationCooperationGateway := allied_creation_cooperation.NewHttplibAlliedCreationCooperation(
		searchDividendsIncentivesQuery.Operator)
	result, err := creationCooperationGateway.DividendsEstimateSearchDividends(
		allied_creation_cooperation.ReqDividendsEstimateSearchDividend{
			PageNumber:                searchDividendsIncentivesQuery.PageNumber,
			PageSize:                  searchDividendsIncentivesQuery.PageSize,
			CooperationContractNumber: searchDividendsIncentivesQuery.CooperationContractNumber,
			OrderOrReturnedOrderNum:   searchDividendsIncentivesQuery.OrderOrReturnedOrderNum,
		})
	if err != nil {
		return 0, nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}

	listdata := []dto.DividendsEstimateDividendItem{}
	for _, v := range result.List {
		item := dto.DividendsEstimateDividendItem{
			OrderGoodId:               v.OrderGoodId,
			OrderGoodName:             v.OrderGoodName,
			CooperationContractNumber: v.CooperationContractNumber,
			CustomerName:              v.CustomerName,
			DividendsIncentivesAmount: v.OrderAmount,
			OrderOrReturnedOrderNum:   v.OrderNumber,
			OriginalOrderNum:          v.OriginalOrderNum,
			RegionName:                v.RegionName,
		}
		item.OrderTime = v.OrderDate.UnixNano() / 1e6
		listdata = append(listdata, item)
	}
	return result.Total, listdata, nil
}

// 查询金额激励分红
func (dividendsEmmateService *DividendsEstimateService) SearchMoneyIncentives(searchMoneyIncentivesQuery *query.SearchMoneyIncentivesQuery) (
	int, interface{}, error) {
	creationCooperationGateway := allied_creation_cooperation.NewHttplibAlliedCreationCooperation(
		searchMoneyIncentivesQuery.Operator)
	result, err := creationCooperationGateway.DividendsEstimatesSearchMoney(allied_creation_cooperation.ReqDividendsEstimateSearchMoney{
		PageNumber:              searchMoneyIncentivesQuery.PageNumber,
		PageSize:                searchMoneyIncentivesQuery.PageSize,
		CooperationContractName: searchMoneyIncentivesQuery.CooperationContractName,
		DepartmentName:          searchMoneyIncentivesQuery.DepartmentName,
	})
	if err != nil {
		return 0, nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	dataList := dto.ToDividendsEstimateMoneyItem(result)
	return result.Grid.Total, dataList, nil
}

func NewDividendsEstimateService(options map[string]interface{}) *DividendsEstimateService {
	newDividendsEstimateService := &DividendsEstimateService{}
	return newDividendsEstimateService
}

func (dividendsEmmateService *DividendsEstimateService) MoneyIncentivesSelector(queryParam *query.MoneyIncentiveSelectorQuery) (interface{}, error) {
	creationCooperationGateway := allied_creation_cooperation.NewHttplibAlliedCreationCooperation(
		queryParam.Operator)
	resultContract, err := creationCooperationGateway.CooperationContractSearch(allied_creation_cooperation.ReqCooperationContractSearch{
		CooperationContractNumber: queryParam.CooperationContractNumber,
	})
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if len(resultContract.Grid.List) == 0 {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, "未找到对应的合约数据")
	}
	contractData := resultContract.Grid.List[0]
	resultDividendsEstimate, err := creationCooperationGateway.DividendsEstimatesSearch(allied_creation_cooperation.ReqDividendsEstimateSearch{
		CooperationContractNumber: queryParam.CooperationContractNumber,
		DividendsType:             3,
		CompanyId:                 queryParam.Operator.CompanyId,
	})
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	rules := []dto.MoneyIncentivesRule{}
	for _, v := range contractData.MoneyIncentivesRules {
		r := dto.MoneyIncentivesRule{
			MoneyIncentivesStage:      v.MoneyIncentivesStage,
			MoneyIncentivesStageStart: int(v.MoneyIncentivesTime.UnixNano() / 1e6),
		}
		rules = append(rules, r)
	}
	contractUndertaker := []dto.ContractUndertaker{}
	for _, v := range contractData.Undertakers {

		ruleStage := []int{}
		for _, vv := range resultDividendsEstimate.Grid.List {
			if v.UserId == vv.DividendsUser.UserId {
				ruleStage = append(ruleStage, vv.DividendsStage)
			}
		}
		temp := dto.ContractUndertaker{
			UserId:                  v.UserId,
			UsersName:               v.UserInfo.UserName,
			ContractIncentivesRules: ruleStage,
		}
		contractUndertaker = append(contractUndertaker, temp)
	}
	data := map[string]interface{}{
		"contractUndertaker":  contractUndertaker,
		"moneyIncentivesRule": rules,
	}
	return data, nil
}

//ConfimDividendsEstimate 确定分红预算
func (dividendsEstimateService *DividendsEstimateService) ConfimDividendsEstimate(confimDividendsEstimateCommand *command.ConfimDividendsEstimateCommand) (interface{}, error) {
	creationCooperationGateway := allied_creation_cooperation.NewHttplibAlliedCreationCooperation(confimDividendsEstimateCommand.Operator)
	result, err := creationCooperationGateway.CreditAccountsAdd(allied_creation_cooperation.ReqCreditAccountsAdd{
		DividendsEstimateIds: confimDividendsEstimateCommand.DividendsEstimateId,
	})
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	return result, nil
}