package domain_service

import (
	"fmt"
	"github.com/go-pg/pg/v10"
	"github.com/linmadan/egglib-go/utils/tool_funs"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/domain"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/infrastructure/dao"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/infrastructure/pg/models"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/infrastructure/repository"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/infrastructure/service_gateway"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/infrastructure/utils"
	"time"
)

// 共创公司统计
func (ptr *CooperationStatisticsService) CooperationCompanyStatistics(queryOptions map[string]interface{}) (interface{}, error) {
	// 参数验证
	var request = struct {
		UserBaseId  int64   `json:"userBaseId" valid:"Required"`
		CompanyList []int64 `json:"companyList" valid:"Required"` //公司列表 待统计的公司列表
	}{}
	if err := LoadQueryObject(queryOptions, &request); err != nil {
		return nil, err
	}
	queryOptions = tool_funs.SimpleStructToMap(&request)

	var response = make([]*cooperationCompanyStatisticsResponse, 0)
	var totalDividend float64
	for i := range request.CompanyList {
		orgId := request.CompanyList[i]
		item, err := ptr.cooperationCompanyStatistics(request.UserBaseId, orgId)
		if err != nil {
			return response, err
		}
		totalDividend += item.DividendsIncome
		response = append(response, item)
	}
	if totalDividend > 0 {
		for i := range response {
			response[i].DividendsRatio = utils.Round(response[i].DividendsIncome/totalDividend*100, 2)
		}
	}
	return response, nil
}

func (ptr *CooperationStatisticsService) cooperationCompanyStatistics(userBaseId int64, orgId int64) (*cooperationCompanyStatisticsResponse, error) {
	// 1.相关项目统计
	cooperationApplicationRepository, _ := repository.NewCooperationApplicationRepository(ptr.transactionContext)
	cooperationProjectCount, _, err := cooperationApplicationRepository.Find(map[string]interface{}{"userBaseId": userBaseId, "orgId": orgId,
		"limit": 1, "cooperationApplicationStatus": int32(2)})
	if err != nil {
		return nil, err
	}

	// 2.相关合约统计
	contractInfo, err := ptr.PersonCooperationContractStatistics(map[string]interface{}{
		"orgId":      orgId,
		"userBaseId": userBaseId,
	})
	if err != nil {
		return nil, err
	}
	//cooperationContractRelevantRepository, _ := dao.NewCooperationContractUndertakerDao(ptr.transactionContext)
	//cooperationContractCount, _, err := cooperationContractRelevantRepository.Find(map[string]interface{}{"userBaseId": userBaseId, "orgId": orgId,
	//	"limit": 100,"distinctColumnContractNumber":1})
	//if err != nil {
	//	return nil, err
	//}

	// 3.个人分红统计
	creditAccountDao, _ := dao.NewDividendsEstimateDao(ptr.transactionContext)
	var allDividends float64
	if allDividends, err = creditAccountDao.CountDividendsEstimateDividendsAmount(map[string]interface{}{"userBaseId": userBaseId, "orgId": orgId}); err != nil {
		return nil, err
	}

	var ret = &cooperationCompanyStatisticsResponse{
		OrgId:                    orgId,
		CooperationProjectCount:  cooperationProjectCount,
		CooperationContractCount: int64(contractInfo.ContractSum),
		DividendsIncome:          utils.Round(allDividends, 2),
	}
	return ret, nil
}

type cooperationCompanyStatisticsResponse struct {
	// 当天统计的企业id
	OrgId int64 `json:"orgId"`
	// 共创项目数
	CooperationProjectCount int64 `json:"cooperationProjectCount"`
	// 共创合约数
	CooperationContractCount int64 `json:"cooperationContractCount"`
	// 分红占比
	DividendsRatio float64 `json:"dividendsRatio"`
	// 分红支出
	DividendsIncome float64 `json:"dividendsIncome"`
}

// 个人-用户合约统计
func (ptr *CooperationStatisticsService) PersonCooperationContractStatistics(queryOptions map[string]interface{}) (*ContractSum, error) {
	// 参数验证
	var request = struct {
		UserBaseId int64 `json:"userBaseId" valid:"Required"`
		OrgId      int64 `json:"orgId"`
	}{}
	if err := LoadQueryObject(queryOptions, &request); err != nil {
		return nil, err
	}
	queryOptions = tool_funs.SimpleStructToMap(&request)
	queryOptions["limit"] = 10000 //TODO:合约数大于10000时？
	cooperationContractUndertaker, _ := dao.NewCooperationContractUndertakerDao(ptr.transactionContext)
	_, contractUndertakers, err := cooperationContractUndertaker.Find(queryOptions)
	if err != nil {
		return nil, nil
	}

	var response = &ContractSum{}
	if len(contractUndertakers) == 0 {
		return response, nil
	}
	var contractIds []int64
	for i := range contractUndertakers {
		contractIds = append(contractIds, contractUndertakers[i].CooperationContractId)
	}
	response.ContractSum = ptr.cooperationContractCount(contractIds, 0)
	response.ContractStoppedSum = ptr.cooperationContractCount(contractIds, 2)
	return response, nil
}

type ContractSum struct {
	ContractSum        int `json:"contractSum"`
	ContractStoppedSum int `json:"contractStoppedSum"`
}

func (ptr *CooperationStatisticsService) cooperationContractCount(contractIds []int64, status int) int {
	var total int
	var contract = new(models.CooperationContract)
	query := ptr.transactionContext.PgDd.Model(contract)
	query.ColumnExpr("count(*) total")
	query.Where("cooperation_contract_id in (?)", pg.In(contractIds))
	if status > 0 {
		query.Where("status =? ", status)
	}
	query.Select(&total)
	return total
}

// 个人 - 企业支付统计
func (ptr *CooperationStatisticsService) PersonCompanyPaymentHistoryStatistics(queryOptions map[string]interface{}) (interface{}, error) {
	// 参数验证
	var request = struct {
		Limit                    int       `json:"limit" valid:"Required"`
		Offset                   int       `json:"offset"`
		UserBaseId               int64     `json:"userBaseId" valid:"Required"`
		OrgId                    int64     `json:"orgId"`
		SortByActuallyPaidAmount int       `json:"sortByActuallyPaidAmount" valid:"Required"`
		PaymentBeginTime         time.Time `json:"paymentBeginTime"`
		PaymentEndTime           time.Time `json:"paymentEndTime"`
	}{}
	if err := LoadQueryObject(queryOptions, &request); err != nil {
		return nil, err
	}
	queryOptions = tool_funs.SimpleStructToMap(&request)

	type companyStatisticsResponse struct {
		CooperationTime      int64   `json:"cooperationTime"`
		DividendsOrderAmount float64 `json:"dividendsOrderAmount"`
		DividesAmount        float64 `json:"dividesAmount"`      // 分红金额
		ActuallyPaidAmount   float64 `json:"actuallyPaidAmount"` // 已支付金额
		UnPaidAmount         float64 `json:"unPaidAmount"`       // 未支付金额
		OrgId                int64   `json:"orgId,string"`
		OrgName              string  `json:"orgName"`

		Participator interface{} `json:"participator"`
	}

	var responses []companyStatisticsResponse
	creditAccountDao, _ := dao.NewCreditAccountDao(ptr.transactionContext)
	if err := creditAccountDao.CooperationCompanyDividendsStatistics(queryOptions, &responses); err != nil {
		return nil, err
	}

	var retMap = make([]interface{}, 0)
	for i := range responses {
		retMap = append(retMap, map[string]interface{}{
			"paymentAmount": responses[i].ActuallyPaidAmount,
			"org": map[string]interface{}{
				"orgId":   responses[i].OrgId,
				"orgName": responses[i].OrgName,
			},
		})
	}

	return retMap, nil
}

// 个人 - 共创浏览 详情页
func (ptr *CooperationStatisticsService) PersonCooperationProjectSharedInfo(queryOptions map[string]interface{}) (interface{}, error) {
	// 参数验证
	var request = struct {
		UserBaseId int64 `json:"userBaseId"`
		// 项目ID
		ProjectId int64 `json:"projectId" valid:"Required"`
		// 敏感数据
		Sensitive bool `json:"sensitive" valid:"Required"`
	}{}
	if err := LoadQueryObject(queryOptions, &request); err != nil {
		return nil, err
	}
	queryOptions = tool_funs.SimpleStructToMap(&request)
	var response = domain.CooperationProjectSharedInfoDto{
		ContractParticipant: make([]*domain.ContractParticipant, 0),
	}

	projectRepository, _ := repository.NewCooperationProjectRepository(ptr.transactionContext)
	project, err := projectRepository.FindOne(map[string]interface{}{"cooperationProjectId": request.ProjectId})
	if err != nil {
		return nil, fmt.Errorf("共创项目不存在")
	}

	// 0.共创项目数据
	updateAt := project.UpdatedAt
	if project.UpdatedAt.IsZero() {
		updateAt = project.CreatedAt
	}
	response.Project = map[string]interface{}{
		"cooperationProjectId":          fmt.Sprintf("%v", project.CooperationProjectId),
		"attachment":                    project.Attachment,
		"cooperationProjectDescription": project.CooperationProjectDescription,
		"cooperationProjectName":        project.CooperationProjectName,
		"status":                        project.Status,
		//"cooperationProjectDescription":project.CooperationProjectDescription,
		"updatedAt": updateAt.Unix() * 1000,
	}
	// 0.1 组织数据
	response.Org = project.Org
	if request.UserBaseId != 0 {
		// 当前用户对于项目组织的关注状态
		userServiceGateway := service_gateway.NewHttplibUserServiceGateway()
		userDetail, e := userServiceGateway.GetUserInfo(0, 0, request.UserBaseId)
		if e == nil && userDetail != nil {
			response.OrgStarred = userDetail.CheckOrgStarred(project.Org.OrgId)
		}
	}

	// 0.2 合约数据
	contractRepository, _ := dao.NewCooperationContractDao(ptr.transactionContext) // repository.NewCooperationContractRepository(ptr.transactionContext)
	_, contracts, _ := contractRepository.Find(map[string]interface{}{"cooperationProjectNumber": project.CooperationProjectNumber, "companyId": project.Company.CompanyId, "orgId": project.Org.OrgId, "offsetLimit": false})
	if len(contracts) == 0 {
		return response, nil
	}

	contractNumbers := make([]string, 0)
	mapContract := make(map[string]*domain.CooperationContract)
	for i := range contracts {
		contractNumbers = append(contractNumbers, contracts[i].CooperationContractNumber)
		mapContract[contracts[i].CooperationContractNumber] = contracts[i]
	}
	keyfun := func(num string, userBaseId int64) string {
		return num + "-" + fmt.Sprintf("%v", userBaseId)
	}

	// 1.项目的承接人
	undertakerRepository, _ := repository.NewCooperationContractUndertakerRepository(ptr.transactionContext)
	_, undertakers, err := undertakerRepository.Find(map[string]interface{}{"cooperationContractNumbers": contractNumbers, "companyId": project.Company.CompanyId, "orgId": project.Org.OrgId, "offsetLimit": false})
	userSorted := make([]string, 0)
	mapUser := make(map[string]*domain.ContractParticipant)
	for i := range undertakers {
		u := undertakers[i]
		key := keyfun(u.CooperationContractNumber, u.Undertaker.UserBaseId)
		userSorted = append(userSorted, key)
		mapUser[keyfun(u.CooperationContractNumber, u.Undertaker.UserBaseId)] = domain.NewContractParticipant(u.Undertaker.ToUser(), key, u.Undertaker.ContractAttachment)
	}

	// 2.合约的订单金额
	mapContractOrderAmount := make(map[string]float64)
	dividendsOrderDao, _ := dao.NewDividendsOrderDao(ptr.transactionContext)
	mapContractOrderAmount, _ = dividendsOrderDao.CalculateGoodOrderAmountByGroup(map[string]interface{}{
		"cooperationContractNumbers": contractNumbers, "companyId": project.Company.CompanyId, "orgId": project.Org.OrgId,
	})

	// 3.计算合约用户的分红预算金额
	var mapCreditAccount = make(map[string]*domain.CreditAccount)
	var creditAccountIds = make([]int64, 0)
	dividendsEstimateRepository, _ := repository.NewDividendsEstimateRepository(ptr.transactionContext)
	_, dividends, err := dividendsEstimateRepository.Find(map[string]interface{}{"cooperationContractNumbers": contractNumbers, "companyId": project.Company.CompanyId, "orgId": project.Org.OrgId, "isCanceled": false, "offsetLimit": false})
	if err != nil {
		return nil, err
	}
	for i := range dividends {
		d := dividends[i]
		key := keyfun(d.CooperationContractNumber, d.DividendsUser.UserBaseId)
		if v, ok := mapUser[key]; ok {
			v.DividendsAmount += d.DividendsAmount
		}
		if d.PaymentStatus == 2 && d.CreditAccountId != 0 {
			creditAccountIds = append(creditAccountIds, d.CreditAccountId)
		}
	}
	// 3.1 用户账期结算记录 - 查询是否有支付凭证
	if len(creditAccountIds) > 0 {
		creditAccountRepository, _ := repository.NewCreditAccountRepository(ptr.transactionContext)
		_, creditAccounts, err := creditAccountRepository.Find(map[string]interface{}{
			"creditAccountIds": creditAccountIds,
			"offsetLimit":      false,
		})
		if err != nil {
			return nil, err
		}
		for i := range creditAccounts {
			if len(creditAccounts[i].PaymentDocumentAttachments) == 0 {
				continue
			}
			for j := range creditAccounts[i].AccountDetail {
				detail := creditAccounts[i].AccountDetail[j]
				key := keyfun(detail.CooperationContractNumber, creditAccounts[i].Participator.UserBaseId)
				mapCreditAccount[key] = creditAccounts[i]
				if v, ok := mapUser[key]; ok {
					if len(v.PaymentDocument) == 0 && len(mapCreditAccount[key].PaymentDocumentAttachments) > 0 {
						v.PaymentDocument = "查看"
					}
					v.AppendAttachments(creditAccounts[i].PaymentDocumentAttachments)
				}
			}
		}
	}

	for _, v := range mapUser {
		if v1, ok := mapContractOrderAmount[v.CooperationContractNumber()]; ok {
			v.OrderAmount = v1
		}
		if v1, ok := mapContract[v.CooperationContractNumber()]; ok {
			v.Contract = map[string]interface{}{
				"cooperationContractId":   fmt.Sprintf("%v", v1.CooperationContractId),
				"cooperationContractName": v1.CooperationContractName,
				"status":                  v1.Status,
			}
		}
	}

	for i := range userSorted {
		if v, ok := mapUser[userSorted[i]]; ok {
			response.ContractParticipant = append(response.ContractParticipant, v.Complete(request.UserBaseId, request.Sensitive))
		}
	}
	return response, nil
}

// 个人 - 共创浏览  合约列表
func (ptr *CooperationStatisticsService) CompanyCooperationProjectContracts(queryOptions map[string]interface{}) (interface{}, error) {
	// 参数验证
	var request = struct {
		Offset int `json:"offset"`
		Limit  int `json:"limit"`
		// 项目ID
		ProjectId int64 `json:"projectId" valid:"Required"`
	}{}
	if err := LoadQueryObject(queryOptions, &request); err != nil {
		return nil, err
	}
	projectRepository, _ := repository.NewCooperationProjectRepository(ptr.transactionContext)
	project, err := projectRepository.FindOne(map[string]interface{}{"cooperationProjectId": request.ProjectId})
	if err != nil {
		return nil, fmt.Errorf("共创项目不存在")
	}

	// 0.2 合约数据
	contractRepository, _ := dao.NewCooperationContractDao(ptr.transactionContext) // repository.NewCooperationContractRepository(ptr.transactionContext)
	_, contracts, _ := contractRepository.Find(map[string]interface{}{"cooperationProjectNumber": project.CooperationProjectNumber,
		"companyId": project.Company.CompanyId,
		"orgId":     project.Org.OrgId,
		"limit":     request.Limit,
		"offset":    request.Offset,
	})
	if len(contracts) == 0 {
		return nil, nil
	}

	contractNumbers := make([]string, 0)
	mapContract := make(map[string]*domain.CooperationContract)
	for i := range contracts {
		contractNumbers = append(contractNumbers, contracts[i].CooperationContractNumber)
		mapContract[contracts[i].CooperationContractNumber] = contracts[i]
	}

	// 2.合约的订单金额
	mapContractOrderAmount := make(map[string]float64)
	dividendsOrderDao, _ := dao.NewDividendsOrderDao(ptr.transactionContext)
	mapContractOrderAmount, _ = dividendsOrderDao.CalculateGoodOrderAmountByGroup(map[string]interface{}{
		"cooperationContractNumbers": contractNumbers, "companyId": project.Company.CompanyId, "orgId": project.Org.OrgId,
	})

	// 3.计算合约用户的分红预算金额
	dividendsEstimateRepository, _ := dao.NewDividendsEstimateDao(ptr.transactionContext) //repository.NewDividendsEstimateRepository(ptr.transactionContext)
	mapDividends, err := dividendsEstimateRepository.DividendsEstimateStatisticsGroup(map[string]interface{}{"cooperationContractNumbers": contractNumbers, "companyId": project.Company.CompanyId, "orgId": project.Org.OrgId})
	if err != nil {
		return nil, err
	}
	results := make([]interface{}, 0)
	for i := range contracts {
		item := contracts[i]

		resultItem := &searchContractDividendsResult{
			CooperationContractId:     item.CooperationContractId,
			CooperationContractName:   item.CooperationContractName,
			CooperationContractNumber: item.CooperationContractNumber,
			Status:                    item.Status,
			CreatedAt:                 item.CreatedAt.Unix() * 1000,
		}
		if v, ok := mapContractOrderAmount[contracts[i].CooperationContractNumber]; ok {
			resultItem.DividendsOrderAmount = v
		}
		if v, ok := mapDividends[contracts[i].CooperationContractNumber]; ok {
			resultItem.DividendsAmount = v
		}
		results = append(results, resultItem)
	}
	return results, nil
}

// func(ptr *CooperationStatisticsService)

// 个人 - 共创浏览 详情页 - 附件数据
// response,error 有可能同时为空，返回需要判断
func (ptr *CooperationStatisticsService) PersonCooperationProjectSharedInfoAttachment(queryOptions map[string]interface{}) (interface{}, error) {
	// 参数验证
	var request = struct {
		UserBaseId int64 `json:"userBaseId"`
		// 用户
		UserId int64 `json:"userId" valid:"Required"`
		// 项目ID
		ProjectId int64 `json:"cooperationProjectId" valid:"Required"`
		// 合约ID
		ContractId int64 `json:"cooperationContractId" valid:"Required"`
		// 附件类型 1:合约附件 2：支付凭证
		AttachmentType int `json:"attachmentType" valid:"Required"`
	}{}
	if err := LoadQueryObject(queryOptions, &request); err != nil {
		return nil, err
	}
	var response = struct {
		Attachment *domain.Attachment `json:"attachment"`
		UserBaseId int64              `json:"userBaseId"`
	}{}
	userServiceGateway := service_gateway.NewHttplibUserServiceGateway()
	userDetail, e := userServiceGateway.GetUser(0, 0, request.UserId)
	if e != nil {
		return nil, e
	}
	request.UserBaseId = userDetail.UserBaseId
	response.UserBaseId = userDetail.UserBaseId
	switch request.AttachmentType {
	case 1:
		contractRepository, _ := dao.NewCooperationContractDao(ptr.transactionContext) // repository.NewCooperationContractRepository(ptr.transactionContext)
		contracts, err := contractRepository.FindOne(map[string]interface{}{"cooperationContractId": request.ContractId})
		if err != nil {
			return nil, fmt.Errorf("合约不存在")
		}
		undertakerRepository, _ := dao.NewCooperationContractUndertakerDao(ptr.transactionContext)
		_, undertakers, err := undertakerRepository.Find(map[string]interface{}{
			"userBaseId":             request.UserBaseId,
			"cooperationContractIds": []int64{contracts.CooperationContractId},
		})
		if err != nil {
			return nil, err
		}
		for i := range undertakers {
			if len(undertakers[i].Undertaker.ContractAttachment) == 0 {
				continue
			}
			response.Attachment = undertakers[i].Undertaker.ContractAttachment[0]
			break
		}
	case 2:
		// 0.2 合约数据
		contractRepository, _ := dao.NewCooperationContractDao(ptr.transactionContext) // repository.NewCooperationContractRepository(ptr.transactionContext)
		contracts, err := contractRepository.FindOne(map[string]interface{}{"cooperationContractId": request.ContractId})
		if err != nil {
			return nil, fmt.Errorf("合约不存在")
		}
		dividendsEstimateRepository, _ := repository.NewDividendsEstimateRepository(ptr.transactionContext)
		_, dividendsEstimates, err := dividendsEstimateRepository.Find(map[string]interface{}{
			"orgId":                     contracts.Org.OrgId,
			"companyId":                 contracts.Company.CompanyId,
			"cooperationContractNumber": contracts.CooperationContractNumber,
			"isCanceled":                false,
			"paymentStatus":             int32(2),
		})
		if err != nil {
			return nil, err
		}
		var estimateIds []int64
		if len(dividendsEstimates) == 0 {
			return response, nil
		}
		for i := range dividendsEstimates {
			estimateIds = append(estimateIds, dividendsEstimates[i].DividendsEstimateId)
		}
		creditAccountRepository, _ := repository.NewCreditAccountRepository(ptr.transactionContext)
		_, creditAccount, err := creditAccountRepository.Find(map[string]interface{}{
			"userBaseId":                request.UserBaseId,
			"orgId":                     contracts.Org.OrgId,
			"companyId":                 contracts.Company.CompanyId,
			"dividendsEstimateOrderIds": estimateIds,
		})
		if err != nil {
			return nil, err
		}
		if len(creditAccount) == 0 {
			return response, nil
		}
		for i := range creditAccount {
			if len(creditAccount[i].PaymentDocumentAttachments) == 0 {
				continue
			}
			response.Attachment = creditAccount[i].PaymentDocumentAttachments[0] // 获取第一个
			break
		}
	default:
		return nil, fmt.Errorf("unkown attachment type %v", request.AttachmentType)
	}

	return response, nil
}

// 个人 - 共创企业
func (ptr *CooperationStatisticsService) PersonCooperationCompany(queryOptions map[string]interface{}) (interface{}, error) {
	// 参数验证
	var request = struct {
		UserBaseId int64 `json:"userBaseId"`
	}{}
	if err := LoadQueryObject(queryOptions, &request); err != nil {
		return nil, err
	}
	var response = struct {
		OrgIds []int64 `json:"orgIds"`
	}{
		OrgIds: make([]int64, 0),
	}
	undertakerDao, _ := dao.NewCooperationContractUndertakerDao(ptr.transactionContext)
	_, undertakers, _ := undertakerDao.Find(map[string]interface{}{"userBaseId": request.UserBaseId, "offsetLimit": false})
	contractIds := make([]int64, 0)
	if len(undertakers) == 0 {
		return response, nil
	}
	for i := range undertakers {
		contractIds = append(contractIds, undertakers[i].CooperationContractId)
	}
	var mapOrg = make(map[int64]int64)
	contractDao, _ := dao.NewCooperationContractDao(ptr.transactionContext)
	_, contracts, err := contractDao.Find(map[string]interface{}{"cooperationContractIds": contractIds})
	if err != nil {
		return nil, err
	}
	for i := range contracts {
		orgId := contracts[i].Org.OrgId
		if _, ok := mapOrg[orgId]; !ok {
			response.OrgIds = append(response.OrgIds, orgId)
			mapOrg[orgId] = orgId
		}
	}
	return response, nil
}