package domain_service

import (
	"fmt"
	"github.com/beego/beego/v2/core/validation"
	"github.com/linmadan/egglib-go/utils/json"
	"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/utils"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/log"
	"math"
	"time"
)

// totalOrganizationUser 统计组织用户

// rankType 排行榜类型，1月榜，2年榜 3总榜，默认展示年榜
// top      排名前n个
func (ptr *CooperationStatisticsService) CooperationGoodsStatistics(queryOptions map[string]interface{}) ([]*domain.CooperationGoodsStatisticsDto, error) {
	orderGoodDao, _ := dao.NewOrderGoodDao(ptr.transactionContext)
	// 参数验证
	var request = struct {
		CompanyId int64 `json:"companyId" valid:"Required"`
		OrgId     int64 `json:"orgId" valid:"Required"`
		RankType  int   `json:"rankType" valid:"Required"`
		Top       int   `json:"top" valid:"Required"`
		Offset    int   `json:"offset"`
	}{}
	if err := LoadQueryObject(queryOptions, &request); err != nil {
		return nil, err
	}
	queryOptions = tool_funs.SimpleStructToMap(&request)

	y := time.Now().Year()
	m := time.Now().Month()
	var beginTime, endTime time.Time
	if request.RankType == 1 { //1月榜
		beginTime = time.Date(y, m, 1, 0, 0, 0, 0, time.Local)
		endTime = beginTime.AddDate(0, 1, 0)
		queryOptions["beginTime"] = beginTime.Format(time.RFC3339)
		queryOptions["endTime"] = endTime.Format(time.RFC3339)
	} else if request.RankType == 2 { //2年榜
		beginTime = time.Date(y, 1, 1, 0, 0, 0, 0, time.Local)
		endTime = beginTime.AddDate(1, 0, 0)
		queryOptions["beginTime"] = beginTime.Format(time.RFC3339)
		queryOptions["endTime"] = endTime.Format(time.RFC3339)
	}
	if request.Top > 0 {
		queryOptions["limit"] = request.Top
	}
	if request.Offset > 0 {
		queryOptions["offset"] = request.Offset
	}
	goods, err := orderGoodDao.CooperationGoodsStatistics(queryOptions)
	if err != nil {
		return nil, err
	}
	if len(goods) == 0 {
		goods = make([]*domain.CooperationGoodsStatisticsDto, 0)
	}

	// 2.计算百分比
	var totalAmount float64
	for i := range goods {
		goods[i].Rank = int32(i + 1)
		totalAmount += goods[i].GoodAmount
	}
	for i := range goods {
		if totalAmount == 0 {
			goods[i].GoodRatio = 0
			continue
		}
		goods[i].GoodRatio = utils.Round((goods[i].GoodAmount/totalAmount)*100, 0)
	}
	return goods, nil
}

// CooperationModeStatistics  企业-共创模式统计
//
// p1 p1_desc
func (ptr *CooperationStatisticsService) CooperationModeStatistics(queryOptions map[string]interface{}) ([]*domain.CooperationModeStatisticsDto, error) {
	orderGoodDao, _ := dao.NewOrderGoodDao(ptr.transactionContext)
	// 参数验证
	var request = struct {
		CompanyId int64 `json:"companyId" valid:"Required"`
		OrgId     int64 `json:"orgId" valid:"Required"`
	}{}
	if err := LoadQueryObject(queryOptions, &request); err != nil {
		return nil, err
	}
	queryOptions = tool_funs.SimpleStructToMap(&request)

	modeStatistics, err := orderGoodDao.CooperationModeStatistics(queryOptions)
	if err != nil {
		return nil, err
	}
	if len(modeStatistics) == 0 {
		modeStatistics = make([]*domain.CooperationModeStatisticsDto, 0)
	}

	return modeStatistics, nil
}

// DividendsStatistics  分红统计
//
// action 1:当前月
func (ptr *CooperationStatisticsService) CompanyDividendsStatistics(queryOptions map[string]interface{}) (interface{}, error) {
	// 参数验证
	var request = struct {
		CompanyId int64 `json:"companyId" valid:"Required"`
		OrgId     int64 `json:"orgId" valid:"Required"`
		Action    int   `json:"action" valid:"Required"`
	}{}
	if err := LoadQueryObject(queryOptions, &request); err != nil {
		return nil, err
	}
	queryOptions = tool_funs.SimpleStructToMap(&request)

	orderGoodDao, _ := dao.NewOrderGoodDao(ptr.transactionContext)
	var beginTime, endTime time.Time
	var res = make(map[string]interface{})
	if request.Action == 1 {
		y := time.Now().Year()
		m := time.Now().Month()
		beginTime = time.Date(y, m, 1, 0, 0, 0, 0, time.Local)
		endTime = beginTime.AddDate(0, 1, 0)
		queryOptions["beginTime"] = beginTime
		queryOptions["endTime"] = endTime
	}
	totalDividends, err := orderGoodDao.CompanyDividendsStatistics(queryOptions)
	if err != nil {
		return nil, err
	}
	queryOptions["paymentStatus"] = 2
	dividendsEstimate, err := orderGoodDao.CompanyDividendsStatistics(queryOptions)
	if err != nil {
		return nil, err
	}
	orderAmount := ptr.CalculateOrderAmount(queryOptions)

	res["creditAccount"] = dividendsEstimate.DividendsEstimate  // 本月账期结算统计
	res["orderAmount"] = orderAmount                            // 订单金额统计
	res["dividendsEstimate"] = totalDividends.DividendsEstimate // 分红预算统计
	return res, nil
}

func (ptr *CooperationStatisticsService) CalculateOrderAmount(queryOption map[string]interface{}) float64 {
	orderDao, err := dao.NewDividendsOrderDao(ptr.transactionContext)
	if err != nil {
		log.Logger.Error(err.Error())
	}
	amount, err := orderDao.CalculateDividendsOrderAmount(queryOption)
	if err != nil {
		log.Logger.Error(err.Error())
	}
	returnedOrderDao, _ := dao.NewDividendsReturnedOrderDao(ptr.transactionContext)
	returnedAmount, _ := returnedOrderDao.CalculateDividendsReturnedOrderAmount(queryOption)
	if math.Abs(returnedAmount) > math.Abs(amount) {
		return 0
	}
	return utils.Round(math.Abs(amount)-math.Abs(returnedAmount), 1)
}

func LoadQueryOptions(queryOption map[string]interface{}, keys ...string) (map[string]interface{}, error) {
	var res = make(map[string]interface{})
	for i := 0; i < len(keys); i++ {
		k := keys[i]
		if v, ok := queryOption[k]; ok {
			res[k] = v
		} else {
			return nil, fmt.Errorf("参数 %v 不存在", k)
		}
	}
	return res, nil
}

func LoadQueryObject(queryOption map[string]interface{}, obj interface{}) error {
	json.UnmarshalFromString(json.MarshalToString(queryOption), obj)
	validation := validation.Validation{}
	_, err := validation.Valid(obj)
	return err
}

type item struct {
	key string
	val interface{}
}