package period_profit

import (
	"app/commons/constant"
	"app/commons/core"
	"app/commons/core/exchange"
	"app/commons/model/entity"
	"app/commons/utils"
	"fmt"
	"github.com/shopspring/decimal"
	"gorm.io/gorm"
)

func (s *Service) calCurrentStakeProfit(periodNo string) error {
	records, err := s.BatchStakeUserCurrentOrder(s.DB().
		Where("usd_amount > 0").
		Where("last_profit_period < ?", periodNo))
	if err != nil {
		return err
	}
	dailyJobDate, err := utils.PeriodNoToDailyDate(periodNo) // 期任务格式转化为 日任务格式
	if err != nil {
		return err
	}
	core.JobLog.Infof("当期活期待计算收益数量:%d", len(records))
	productInfo, err := s.FirstStakeProduct(s.DB().Where("pledge_mode", entity.StakeProductTypeCurrent))
	if err != nil {
		core.JobLog.Errorf(err.Error())
		return err
	}
	price, err := exchange.GetCurrentSymbolUsdPrice(constant.CoinSymbolTD)
	if err != nil {
		core.JobLog.Errorf(err.Error())
		return err
	}
	profitRatio := productInfo.PeriodProfitRatio
	profitRecords := make([]*entity.UserProfitRecord, 0)
	core.JobLog.Infof("活期收益 price:%s profitRatio:%s", price, profitRatio)
	totalProfitQuantity := decimal.Zero
	totalProfitUsdAmount := decimal.Zero

	var ids []int64
	for _, item := range records {
		usdProfit := item.UsdAmount.Mul(profitRatio) // USD收益
		symbolProfit := usdProfit.Div(price)         // 币收益数量
		bs := constant.BsById(constant.BsCurrentStaticProfit)
		bs.ContextValue = fmt.Sprintf("%d", item.Id)
		bs.ContextName = item.TableName()
		bs.Desc = fmt.Sprintf("期:%s-usdAmount%s-profitRatio:%s-usdProfit:%s-Price:%s-SymbolProfit:%s", periodNo, item.UsdAmount, profitRatio, usdProfit, price, symbolProfit)
		profitInfo := &entity.ProfitInfo{
			RawUserId:      item.UserId,
			RawUserUid:     item.Uid,
			RewardUserId:   item.UserId,
			RewardUserUid:  item.Uid,
			RewardSymbol:   constant.CoinSymbolTD,
			SymbolUsdPrice: price,
			CapitalUsd:     item.UsdAmount,
			RewardRatio:    profitRatio,
			RewardUsdValue: usdProfit,
			RewardQuantity: symbolProfit,
			RewardPeriod:   periodNo,
			RewardDate:     dailyJobDate,
		}
		profitRecord := s.BuildUserProfitRecord(profitInfo, bs)
		profitRecords = append(profitRecords, profitRecord)
		totalProfitUsdAmount = totalProfitUsdAmount.Add(usdProfit)
		totalProfitQuantity = totalProfitQuantity.Add(symbolProfit)
		ids = append(ids, item.Id)
	}
	if len(profitRecords) > 0 {
		txDb := s.DB().Begin()
		err = txDb.CreateInBatches(profitRecords, 200).Error
		if err != nil {
			txDb.Rollback()
			return err
		}
		err = txDb.Model(&entity.StakeUserCurrentOrder{}).
			Where("id in (?)", ids).
			Updates(map[string]interface{}{
				"last_profit_period": periodNo,
				"version":            gorm.Expr("version + 1"),
			}).Error
		if err != nil {
			txDb.Rollback()
			return err
		}
		updateStm := txDb.Model(&entity.StakePeriodJob{}).
			Where("period_no", periodNo).
			Where("job_state", entity.PeriodJobStateRunning).
			Updates(map[string]interface{}{
				"price":                price,
				"static_symbol_profit": totalProfitQuantity,
				"static_usd_profit":    totalProfitUsdAmount,
			})
		if updateStm.RowsAffected != 1 || updateStm.Error != nil {
			txDb.Rollback()
			return err
		}
		utils.Today20060102Format()
		dailyStm := txDb.Model(&entity.SysJob{}).
			Where("job_date", dailyJobDate).
			Updates(map[string]interface{}{
				"today_static_profit":     gorm.Expr("today_static_profit + ?", totalProfitQuantity),
				"today_static_usd_profit": gorm.Expr("today_static_profit + ?", totalProfitUsdAmount),
			})
		if dailyStm.RowsAffected != 1 || dailyStm.Error != nil {
			txDb.Rollback()
			return err
		}
		txDb.Commit()
	}
	return nil
}