package service

import (
	"context"
	"fmt"
	"math/rand"
	"time"

	"go-common/app/job/main/ugcpay/dao"
	"go-common/app/job/main/ugcpay/model"
	"go-common/app/job/main/ugcpay/service/pay"
	xsql "go-common/library/database/sql"
	"go-common/library/log"

	"github.com/pkg/errors"
)

type taskBillDaily struct {
	dao        *dao.Dao
	pay        *pay.Pay
	rnd        *rand.Rand
	dayOffset  int
	namePrefix string
	tl         *taskLog
}

func (s *taskBillDaily) Run() (err error) {
	var (
		ctx      = context.Background()
		finished bool
		expectFN = func(ctx context.Context) (expect int64, err error) {
			var (
				beginTime, endTime         = dayRange(s.dayOffset)
				expectPaid, expectRefunded int64
			)
			if expectPaid, err = s.dao.CountPaidOrderUser(ctx, beginTime, endTime); err != nil {
				return
			}
			if expectRefunded, err = s.dao.CountRefundedOrderUser(ctx, beginTime, endTime); err != nil {
				return
			}
			expect = expectPaid + expectRefunded
			return
		}
	)
	if finished, err = checkOrCreateTaskFromLog(ctx, s, s.tl, expectFN); err != nil || finished {
		return
	}
	return s.run(ctx)
}

func (s *taskBillDaily) TTL() int32 {
	return 3600 * 2
}

func (s *taskBillDaily) Name() string {
	return fmt.Sprintf("%s_%d", s.namePrefix, dailyBillVer(time.Now()))
}

// 日账单生成
func (s *taskBillDaily) run(ctx context.Context) (err error) {
	// 已支付成功订单入账
	paidLL := &orderPaidLL{
		limit: 1000,
		dao:   s.dao,
	}
	paidLL.beginTime, paidLL.endTime = dayRange(s.dayOffset)
	if err = runLimitedList(ctx, paidLL, time.Millisecond*5, s.runPaidOrder); err != nil {
		return
	}

	// 已退款订单入账
	refundLL := &orderRefundedLL{
		limit: 1000,
		dao:   s.dao,
	}
	refundLL.beginTime, refundLL.endTime = dayRange(s.dayOffset)
	return runLimitedList(ctx, refundLL, time.Millisecond*5, s.runRefundedOrder)
}

// 处理退款order
func (s *taskBillDaily) runRefundedOrder(ctx context.Context, ele interface{}) (err error) {
	order, ok := ele.(*model.Order)
	if !ok {
		return errors.Errorf("refundedOrderHandler convert ele: %+v failed", order)
	}
	log.Info("runRefundedOrder handle order: %+v", order)

	logOrder := &model.LogOrder{
		OrderID:   order.OrderID,
		FromState: order.State,
		ToState:   model.OrderStateRefundFinished,
	}
	order.State = model.OrderStateRefundFinished

	fn := func(ctx context.Context, tx *xsql.Tx) (affected bool, err error) {
		var (
			bill          *model.DailyBill
			asset         *model.Asset
			ver           = dailyBillVer(order.RefundTime)
			monthVer      = monthlyBillVer(order.RefundTime)
			billDailyLog  *model.LogBillDaily
			userIncome, _ = calcAssetIncome(order.RealFee) // 收入计算结果
		)
		affected = true

		// 获得订单对应的asset
		if asset, err = s.dao.Asset(ctx, order.OID, order.OType, order.Currency); err != nil {
			return
		}
		if asset == nil {
			err = errors.Errorf("dailyBillHander find invalid asset order, order: %+v", order)
			return
		}

		// 获得该mid对应的日账单
		if bill, err = s.dao.DailyBill(ctx, asset.MID, model.BizAsset, model.CurrencyBP, ver); err != nil {
			return
		}
		if bill == nil {
			if bill, err = s.initDailyBill(ctx, asset.MID, model.BizAsset, model.CurrencyBP, ver, monthVer); err != nil {
				return
			}
		}
		// 计算日账单
		billDailyLog = &model.LogBillDaily{
			BillID:  bill.BillID,
			FromIn:  bill.In,
			ToIn:    bill.In,
			FromOut: bill.Out + userIncome,
			ToOut:   bill.Out,
			OrderID: order.OrderID + "_r",
		}
		bill.Out += userIncome

		// 更新order
		rowAffected, err := s.dao.TXUpdateOrder(ctx, tx, order)
		if err != nil {
			tx.Rollback()
			return
		}
		if rowAffected <= 0 {
			tx.Rollback()
			log.Error("UpdateOrder no affected from order: %+v", order)
			affected = false
			return
		}

		// 添加 order log
		_, err = s.dao.TXInsertOrderUserLog(ctx, tx, logOrder)
		if err != nil {
			tx.Rollback()
			return
		}

		// 更新daily_bill
		rowAffected, err = s.dao.TXUpdateDailyBill(ctx, tx, bill)
		if err != nil {
			tx.Rollback()
			return
		}
		if rowAffected <= 0 {
			log.Error("TXUpdateDailyBill no affected bill: %+v", bill)
			tx.Rollback()
			affected = false
			return
		}

		// 添加 daily bill log , uk order_id
		_, err = s.dao.TXInsertLogDailyBill(ctx, tx, billDailyLog)
		if err != nil {
			tx.Rollback()
			return
		}

		// 更新 aggr
		aggrMonthlyAsset := &model.AggrIncomeUserAsset{
			MID:      bill.MID,
			Currency: bill.Currency,
			Ver:      monthVer,
			OID:      order.OID,
			OType:    order.OType,
		}
		aggrAllAsset := &model.AggrIncomeUserAsset{
			MID:      bill.MID,
			Currency: bill.Currency,
			Ver:      0,
			OID:      order.OID,
			OType:    order.OType,
		}
		aggrUser := &model.AggrIncomeUser{
			MID:      bill.MID,
			Currency: bill.Currency,
		}
		_, err = s.dao.TXUpsertDeltaAggrIncomeUserAsset(ctx, tx, aggrAllAsset, 0, 1, 0, userIncome)
		if err != nil {
			tx.Rollback()
			return
		}
		_, err = s.dao.TXUpsertDeltaAggrIncomeUserAsset(ctx, tx, aggrMonthlyAsset, 0, 1, 0, userIncome)
		if err != nil {
			tx.Rollback()
			return
		}
		_, err = s.dao.TXUpsertDeltaAggrIncomeUser(ctx, tx, aggrUser, 0, 1, 0, userIncome)
		if err != nil {
			tx.Rollback()
			return
		}

		log.Info("Settle daily bill: %+v, aggrAllAsset: %+v, aggrMonthlyAsset: %+v, aggrUser: %+v, from refunded order: %+v", bill, aggrAllAsset, aggrMonthlyAsset, aggrUser, order)
		return
	}

	return runTXCASTaskWithLog(ctx, s, s.tl, fn)
}

func (s *taskBillDaily) runPaidOrder(ctx context.Context, ele interface{}) (err error) {
	order, ok := ele.(*model.Order)
	if !ok {
		return errors.Errorf("runPaidOrder convert ele: %+v failed", order)
	}
	log.Info("runPaidOrder handle order: %+v", order)

	checkOK, payDesc, err := s.checkOrder(ctx, order) // 对支付订单对账
	if err != nil {
		return err
	}
	logOrder := &model.LogOrder{
		OrderID:   order.OrderID,
		FromState: order.State,
		Desc:      payDesc,
	}
	var fn func(context.Context, *xsql.Tx) (affected bool, err error)

	if checkOK { // 对账成功
		logOrder.ToState = model.OrderStateSettled
		order.State = model.OrderStateSettled
		fn = func(ctx context.Context, tx *xsql.Tx) (affected bool, err error) {
			var (
				bill          *model.DailyBill
				asset         *model.Asset
				ver           = dailyBillVer(order.PayTime)
				monthVer      = monthlyBillVer(order.PayTime)
				billDailyLog  *model.LogBillDaily
				userIncome, _ = calcAssetIncome(order.RealFee) // 收入计算结果
			)
			affected = true

			// 获得订单对应的asset
			if asset, err = s.dao.Asset(ctx, order.OID, order.OType, order.Currency); err != nil {
				return
			}
			if asset == nil {
				log.Error("runPaidOrder find invalid asset order, order: %+v", order)
				return
			}

			// 获得该mid对应的日账单
			if bill, err = s.dao.DailyBill(ctx, asset.MID, model.BizAsset, model.CurrencyBP, ver); err != nil {
				return
			}
			if bill == nil {
				if bill, err = s.initDailyBill(ctx, asset.MID, model.BizAsset, model.CurrencyBP, ver, monthVer); err != nil {
					return
				}
			}
			// 计算日账单
			billDailyLog = &model.LogBillDaily{
				BillID:  bill.BillID,
				FromIn:  bill.In,
				ToIn:    bill.In + userIncome,
				FromOut: bill.Out,
				ToOut:   bill.Out,
				OrderID: order.OrderID,
			}
			bill.In += userIncome

			// 更新order
			rowAffected, err := s.dao.TXUpdateOrder(ctx, tx, order)
			if err != nil {
				tx.Rollback()
				return
			}
			if rowAffected <= 0 {
				tx.Rollback()
				log.Error("UpdateOrder no affected from order: %+v", order)
				affected = false
				return
			}

			// 添加 order log
			_, err = s.dao.TXInsertOrderUserLog(ctx, tx, logOrder)
			if err != nil {
				tx.Rollback()
				return
			}

			// 更新daily_bill
			rowAffected, err = s.dao.TXUpdateDailyBill(ctx, tx, bill)
			if err != nil {
				tx.Rollback()
				return
			}
			if rowAffected <= 0 {
				log.Error("TXUpsertDeltaDailyBill no affected bill: %+v", bill)
				tx.Rollback()
				affected = false
				return
			}

			// 添加 daily bill log , uk order_id
			_, err = s.dao.TXInsertLogDailyBill(ctx, tx, billDailyLog)
			if err != nil {
				tx.Rollback()
				return
			}

			// 更新 aggr
			aggrMonthlyAsset := &model.AggrIncomeUserAsset{
				MID:      bill.MID,
				Currency: bill.Currency,
				Ver:      monthVer,
				OID:      order.OID,
				OType:    order.OType,
			}
			aggrAllAsset := &model.AggrIncomeUserAsset{
				MID:      bill.MID,
				Currency: bill.Currency,
				Ver:      0,
				OID:      order.OID,
				OType:    order.OType,
			}
			aggrUser := &model.AggrIncomeUser{
				MID:      bill.MID,
				Currency: bill.Currency,
			}
			_, err = s.dao.TXUpsertDeltaAggrIncomeUserAsset(ctx, tx, aggrAllAsset, 1, 0, userIncome, 0)
			if err != nil {
				tx.Rollback()
				return
			}
			_, err = s.dao.TXUpsertDeltaAggrIncomeUserAsset(ctx, tx, aggrMonthlyAsset, 1, 0, userIncome, 0)
			if err != nil {
				tx.Rollback()
				return
			}
			_, err = s.dao.TXUpsertDeltaAggrIncomeUser(ctx, tx, aggrUser, 1, 0, userIncome, 0)
			if err != nil {
				tx.Rollback()
				return
			}
			log.Info("taskBillDaily: %+v, aggrAllAsset: %+v, aggrMonthlyAsset: %+v, aggrUser: %+v, from paid order: %+v", bill, aggrAllAsset, aggrMonthlyAsset, aggrUser, order)
			return
		}
	} else { // 对账失败
		logOrder.ToState = model.OrderStateBadDebt
		order.State = model.OrderStateBadDebt
		fn = func(ctx context.Context, tx *xsql.Tx) (affected bool, err error) {
			var (
				orderBadDebt *model.OrderBadDebt
			)
			affected = true

			if orderBadDebt, err = s.dao.OrderBadDebt(ctx, order.OrderID); err != nil {
				return
			}
			if orderBadDebt == nil {
				if orderBadDebt, err = s.initBadDebt(ctx, order.OrderID); err != nil {
					return
				}
			}
			orderBadDebt.Type = "unknown"
			orderBadDebt.State = "failed"

			// 更新order
			rowAffected, theErr := s.dao.TXUpdateOrder(ctx, tx, order)
			if theErr != nil {
				tx.Rollback()
				return
			}
			if rowAffected <= 0 {
				tx.Rollback()
				log.Error("UpdateOrder no affected from order: %+v", order)
				affected = false
				return
			}

			// 添加order log
			_, theErr = s.dao.TXInsertOrderUserLog(ctx, tx, logOrder)
			if theErr != nil {
				tx.Rollback()
				return
			}

			// 添加坏账表
			_, err = s.dao.TXUpdateOrderBadDebt(ctx, tx, orderBadDebt)
			if err != nil {
				tx.Rollback()
				return
			}
			log.Info("Add bad debt: %+v", orderBadDebt)
			return
		}
	}
	return runTXCASTaskWithLog(ctx, s, s.tl, fn)
}

func (s *taskBillDaily) checkOrder(ctx context.Context, order *model.Order) (ok bool, payDesc string, err error) {
	ok = false
	if order == nil {
		return
	}
	if order.PayID == "" {
		log.Error("Check order found baddebt order: %+v", order)
		return
	}

	payParam := s.pay.CheckOrder(order.PayID)
	s.pay.Sign(payParam)
	payJSON, err := s.pay.ToJSON(payParam)
	if err != nil {
		return
	}
	orders, err := s.dao.PayCheckOrder(ctx, payJSON)
	if err != nil {
		return
	}
	result, ok := orders[order.PayID]
	if !ok {
		return
	}
	payDesc = result.RecoStatusDesc
	switch result.RecoStatusDesc {
	case model.PayCheckOrderStateSuccess:
		ok = true
	default:
		ok = false
	}
	return
}

func (s *taskBillDaily) initDailyBill(ctx context.Context, mid int64, biz, currency string, ver, monthVer int64) (bill *model.DailyBill, err error) {
	bill = &model.DailyBill{}
	bill.BillID = orderID(s.rnd)
	bill.MID = mid
	bill.Biz = model.BizAsset
	bill.Currency = model.CurrencyBP
	bill.In = 0
	bill.Out = 0
	bill.Ver = ver
	bill.MonthVer = monthVer
	bill.Version = 1

	if bill.ID, err = s.dao.InsertDailyBill(ctx, bill); err != nil {
		return
	}
	return
}

func (s *taskBillDaily) initBadDebt(ctx context.Context, orderID string) (data *model.OrderBadDebt, err error) {
	data = &model.OrderBadDebt{
		OrderID: orderID,
		Type:    "",
		State:   "",
	}
	if data.ID, err = s.dao.InsertOrderBadDebt(ctx, data); err != nil {
		return
	}
	return
}