package store

import (
	"errors"
	"fmt"

	"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
}

// 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
}