package repository

import (
	"context"
	"fmt"
	"time"

	"github.com/google/uuid"
	"gorm.io/gorm"

	"apskel-pos-be/internal/constants"
)

// GameBudgetMetricsRepository reads what a budget's metrics are computed from
// (docs/rfc-enakgame.md §10), on read, from the tables that hold it.
type GameBudgetMetricsRepository interface {
	// RealizedCost sums the voucher costs recognized against a budget at or after from
	// and before to; a nil bound is open. EnakPoint not from EnakGame names no budget,
	// so it never counts (D5).
	RealizedCost(ctx context.Context, budgetID uuid.UUID, from, to *time.Time) (int64, error)
	// CoinIssued sums the EnakCoin rewards the budget paid for.
	CoinIssued(ctx context.Context, budgetID uuid.UUID) (int64, error)
	// Exposure sums, per currency, what is still spendable at asOf of the balances the
	// budget's rewards created, following them through transfers and exchanges: the
	// most that can still turn into cost.
	Exposure(ctx context.Context, budgetID uuid.UUID, asOf time.Time) (coins, points int64, err error)
}

type gameBudgetMetricsRepository struct {
	db *gorm.DB
}

func NewGameBudgetMetricsRepository(db *gorm.DB) GameBudgetMetricsRepository {
	return &gameBudgetMetricsRepository{db: db}
}

func (r *gameBudgetMetricsRepository) RealizedCost(ctx context.Context, budgetID uuid.UUID, from, to *time.Time) (int64, error) {
	q := DBFromContext(ctx, r.db).WithContext(ctx).Table("voucher_redemption_costs").Where("budget_id = ?", budgetID)
	if from != nil {
		q = q.Where("recognized_at >= ?", *from)
	}
	if to != nil {
		q = q.Where("recognized_at < ?", *to)
	}
	var total int64
	if err := q.Select("COALESCE(SUM(cost), 0)").Scan(&total).Error; err != nil {
		return 0, fmt.Errorf("failed to sum realized cost: %w", err)
	}
	return total, nil
}

func (r *gameBudgetMetricsRepository) CoinIssued(ctx context.Context, budgetID uuid.UUID) (int64, error) {
	var total int64
	err := DBFromContext(ctx, r.db).WithContext(ctx).Table("game_session_rewards").Where("budget_id = ?", budgetID).
		Select("COALESCE(SUM(amount), 0)").Scan(&total).Error
	if err != nil {
		return 0, fmt.Errorf("failed to sum issued EnakCoin: %w", err)
	}
	return total, nil
}

func (r *gameBudgetMetricsRepository) Exposure(ctx context.Context, budgetID uuid.UUID, asOf time.Time) (int64, int64, error) {
	var rows []struct {
		Currency string
		Total    int64
	}
	err := DBFromContext(ctx, r.db).WithContext(ctx).Raw(`
		WITH RECURSIVE tree AS (
			SELECT l.id, l.currency, l.remaining_amount, l.expires_at
			FROM game_session_rewards r
			JOIN wallet_lots l ON l.source_transaction_id = r.wallet_transaction_id
			WHERE r.budget_id = ?
		  UNION ALL
			SELECT c.id, c.currency, c.remaining_amount, c.expires_at
			FROM tree t
			JOIN wallet_lots c ON c.origin_lot_id = t.id
		)
		SELECT currency, COALESCE(SUM(remaining_amount), 0) AS total
		FROM tree
		WHERE remaining_amount > 0 AND (expires_at IS NULL OR expires_at > ?)
		GROUP BY currency`, budgetID, asOf).Scan(&rows).Error
	if err != nil {
		return 0, 0, fmt.Errorf("failed to sum budget exposure: %w", err)
	}
	var coins, points int64
	for _, row := range rows {
		switch row.Currency {
		case constants.WalletCurrencyCoin:
			coins = row.Total
		case constants.WalletCurrencyPoint:
			points = row.Total
		}
	}
	return coins, points, nil
}