package store

import (
	"errors"
	"fmt"
	"time"

	"gorm.io/gorm"

	"github.com/wangjia/pay/internal/model"
)

var (
	ErrOrderNotFound   = errors.New("store: order not found")
	ErrAttemptNotFound = errors.New("store: attempt not found")
)

// GetOrder returns an order by out_trade_no.
func (s *OrderStore) GetOrder(outTradeNo string) (*model.OrderV2, error) {
	var o model.OrderV2
	if err := s.db.Where("out_trade_no = ?", outTradeNo).First(&o).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, ErrOrderNotFound
		}
		return nil, fmt.Errorf("store.GetOrder: %w", err)
	}
	return &o, nil
}

// MarkDisputed 打拒付标(P8 Task6):条件 UPDATE 仅在 disputed=false 时翻转,幂等——
// 重投同一 dispute 命中 rows_affected=0,不报错,调用方(recordChargeback)不看返回值
// 也安全(打标不改状态机,不存在"取消标记"这一操作,单向翻转足够)。
func (s *OrderStore) MarkDisputed(outTradeNo string) (bool, error) {
	res := s.db.Model(&model.OrderV2{}).
		Where("out_trade_no = ? AND disputed = ?", outTradeNo, false).
		Update("disputed", true)
	if res.Error != nil {
		return false, fmt.Errorf("store.MarkDisputed: %w", res.Error)
	}
	return res.RowsAffected > 0, nil
}

// AttemptByProviderRef resolves an attempt from a bare provider_ref, so settlement
// can recover out_trade_no + channel from a callback/query that only carries the ref.
func (s *OrderStore) AttemptByProviderRef(providerRef string) (*model.Attempt, error) {
	var a model.Attempt
	if err := s.db.Where("provider_ref = ?", providerRef).First(&a).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, ErrAttemptNotFound
		}
		return nil, fmt.Errorf("store.AttemptByProviderRef: %w", err)
	}
	return &a, nil
}

// ListAttemptsByStatus lists attempts in a status (for query-sync fallback).
func (s *OrderStore) ListAttemptsByStatus(status model.AttemptStatus, limit int) ([]model.Attempt, error) {
	if limit <= 0 || limit > 200 {
		limit = 100
	}
	var out []model.Attempt
	if err := s.db.Where("status = ?", status).Order("id ASC").Limit(limit).Find(&out).Error; err != nil {
		return nil, fmt.Errorf("store.ListAttemptsByStatus: %w", err)
	}
	return out, nil
}

// ExpirePendingAttempts marks all pending attempts of an order as expired
// (used before a retry spawns a fresh attempt). Order status is untouched.
func (s *OrderStore) ExpirePendingAttempts(outTradeNo string) (int64, error) {
	res := s.db.Model(&model.Attempt{}).
		Where("out_trade_no = ? AND status = ?", outTradeNo, model.AttemptPending).
		Update("status", model.AttemptExpired)
	if res.Error != nil {
		return 0, fmt.Errorf("store.ExpirePendingAttempts: %w", res.Error)
	}
	return res.RowsAffected, nil
}

// PaidAttempt returns the settled (paid) attempt of an order — the payment a
// refund reverses (channel + provider_ref for the original transaction).
func (s *OrderStore) PaidAttempt(outTradeNo string) (*model.Attempt, error) {
	var a model.Attempt
	err := s.db.Where("out_trade_no = ? AND status = ?", outTradeNo, model.AttemptPaid).First(&a).Error
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, ErrAttemptNotFound
		}
		return nil, fmt.Errorf("store.PaidAttempt: %w", err)
	}
	return &a, nil
}

// ApplyRefundToOrder advances a settled order's status per cumulative refunds:
// fully refunded → refunded, else → partially_refunded. Guard: only from a
// post-paid, non-fully-refunded state (paid / partially_refunded / refunding).
func (s *OrderStore) ApplyRefundToOrder(outTradeNo string, fully bool) (bool, error) {
	next := model.OrderPartRefundedV2
	if fully {
		next = model.OrderRefundedV2
	}
	res := s.db.Model(&model.OrderV2{}).
		Where("out_trade_no = ? AND status IN ?", outTradeNo,
			[]model.OrderStatusV2{model.OrderPaidV2, model.OrderPartRefundedV2, model.OrderRefundingV2}).
		Update("status", next)
	if res.Error != nil {
		return false, fmt.Errorf("store.ApplyRefundToOrder: %w", res.Error)
	}
	return res.RowsAffected > 0, nil
}

// ExpireStaleOrders closes pending orders whose created_at predates cutoff
// (TTL 到期未付),条件 UPDATE 只翻 status=pending 的行——与并发 settle 翻 paid
// 互斥(谁先谁赢,另一方 RowsAffected=0),故幂等且崩溃安全。含"零尝试孤儿单"
// (建单后 CreateAttempt 失败、无 attempt 的 pending 单):它 status 仍是 pending,
// 同样被扫到关闭(P2-T4 复审记录的缺口)。cutoff 由调用方用注入时钟算,store 不碰时钟。
//
// 注:与 ExpirePendingAttempts 语义不同——那个是 attempt 级(标 attempt expired,
// 订单不动,retry 前用);这个是 order 级(标整张订单 expired)。
func (s *OrderStore) ExpireStaleOrders(cutoff time.Time, limit int) (int64, error) {
	if limit <= 0 || limit > 1000 {
		limit = 500
	}
	// 先选主键再批量 UPDATE:回避 "UPDATE ... ORDER BY LIMIT" 的方言差异(sqlite/mysql)。
	var ids []uint64
	if err := s.db.Model(&model.OrderV2{}).
		Where("status = ? AND created_at < ?", model.OrderPendingV2, cutoff).
		Order("id ASC").Limit(limit).Pluck("id", &ids).Error; err != nil {
		return 0, fmt.Errorf("store.ExpireStaleOrders select: %w", err)
	}
	if len(ids) == 0 {
		return 0, nil
	}
	res := s.db.Model(&model.OrderV2{}).
		Where("id IN ? AND status = ?", ids, model.OrderPendingV2). // status 守卫兜住 select→update 间的并发翻转
		Update("status", model.OrderExpiredV2)
	if res.Error != nil {
		return 0, fmt.Errorf("store.ExpireStaleOrders update: %w", res.Error)
	}
	return res.RowsAffected, nil
}

// SumPaidAttemptMinorByAccountSince 聚合各账户自 since 起的已付金额(minor),供 LimitAware
// 判当日用量。量纲:attempt.AmountMinor 即账户所属渠道结算币种 minor(与 DailyLimit 同量纲)。
func (s *OrderStore) SumPaidAttemptMinorByAccountSince(since time.Time) (map[string]int64, error) {
	type row struct {
		AccountID string
		Total     int64
	}
	var rows []row
	if err := s.db.Model(&model.Attempt{}).
		Select("account_id, SUM(amount_minor) AS total").
		Where("status = ? AND account_id <> '' AND paid_at >= ?", model.AttemptPaid, since).
		Group("account_id").Scan(&rows).Error; err != nil {
		return nil, fmt.Errorf("store.SumPaidAttemptMinorByAccountSince: %w", err)
	}
	out := make(map[string]int64, len(rows))
	for _, r := range rows {
		out[r.AccountID] = r.Total
	}
	return out, nil
}

// ListRecentlyPaidAttempts 列近期(paid_at>=since)已付 attempt,供对账抽查反查渠道核对。
func (s *OrderStore) ListRecentlyPaidAttempts(since time.Time, limit int) ([]model.Attempt, error) {
	if limit <= 0 || limit > 500 {
		limit = 100
	}
	var out []model.Attempt
	if err := s.db.Where("status = ? AND paid_at >= ?", model.AttemptPaid, since).
		Order("id DESC").Limit(limit).Find(&out).Error; err != nil {
		return nil, fmt.Errorf("store.ListRecentlyPaidAttempts: %w", err)
	}
	return out, nil
}

// ListOrdersByStatus 按状态集合列订单,供退款修复扫描(Task 5 P4 义务)定位「当前处于
// 退款相关态」的候选订单,与 RefundStore.ListDistinctOutTradeNosByStatus(succeeded)取并集。
func (s *OrderStore) ListOrdersByStatus(statuses []model.OrderStatusV2, limit int) ([]model.OrderV2, error) {
	if limit <= 0 || limit > 500 {
		limit = 200
	}
	var out []model.OrderV2
	if err := s.db.Where("status IN ?", statuses).
		Order("id ASC").Limit(limit).Find(&out).Error; err != nil {
		return nil, fmt.Errorf("store.ListOrdersByStatus: %w", err)
	}
	return out, nil
}

// ListOrdersByStatusSince 同 ListOrdersByStatus,但加 updated_at>=since 回溯窗——
// refunding/partially_refunded 是长期驻留态(订单进入后可能停留很久),不设窗口时
// 会占满 limit 名额,把「近期才卡滞、需要自愈」的订单挤出候选(与
// RefundStore.ListDistinctOutTradeNosByStatusSince 同一治法,同一 lookback 语义)。
func (s *OrderStore) ListOrdersByStatusSince(statuses []model.OrderStatusV2, since time.Time, limit int) ([]model.OrderV2, error) {
	if limit <= 0 || limit > 500 {
		limit = 200
	}
	var out []model.OrderV2
	if err := s.db.Where("status IN ? AND updated_at >= ?", statuses, since).
		Order("id ASC").Limit(limit).Find(&out).Error; err != nil {
		return nil, fmt.Errorf("store.ListOrdersByStatusSince: %w", err)
	}
	return out, nil
}

// ListAttemptsByChannelSince 列某渠道 created_at>=since 的 attempt(任意状态),
// 供 orphan 扫描构造"已知期望金额集"(凡 pay 合法签发过的金额都不算孤儿)。
func (s *OrderStore) ListAttemptsByChannelSince(channel string, since time.Time, limit int) ([]model.Attempt, error) {
	if limit <= 0 || limit > 500 {
		limit = 200
	}
	var out []model.Attempt
	if err := s.db.Where("channel = ? AND created_at >= ?", channel, since).
		Order("id DESC").Limit(limit).Find(&out).Error; err != nil {
		return nil, fmt.Errorf("store.ListAttemptsByChannelSince: %w", err)
	}
	return out, nil
}