package repository

import (
	"context"
	"database/sql"
	"time"

	"github.com/muyuqingfeng/iloom/textile-service/internal/model"
)

type PaymentRepo struct {
	db *sql.DB
}

func NewPaymentRepo(db *sql.DB) *PaymentRepo {
	return &PaymentRepo{db: db}
}

func (r *PaymentRepo) ListByCompany(ctx context.Context, companyID string) ([]model.Payment, error) {
	query := `
		SELECT p.id, p.plan_id, p.from_company_id, p.to_company_id,
		       p.amount, p.quantity, p.price_per_meter, p.status, p.paid_at, p.created_at,
		       COALESCE(pp.plan_code, '') AS plan_code,
		       COALESCE(c.name, '') AS from_company_name
		FROM ilm_payment p
		LEFT JOIN ilm_production_plan pp ON p.plan_id = pp.id
		LEFT JOIN ilm_company c ON p.from_company_id = c.id
		WHERE p.to_company_id = ?
		ORDER BY p.created_at DESC`

	rows, err := r.db.QueryContext(ctx, query, companyID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()

	var payments []model.Payment
	for rows.Next() {
		var p model.Payment
		if err := rows.Scan(
			&p.ID, &p.PlanID, &p.FromCompanyID, &p.ToCompanyID,
			&p.Amount, &p.Quantity, &p.PricePerMeter, &p.Status, &p.PaidAt, &p.CreatedAt,
			&p.PlanCode, &p.FromCompanyName,
		); err != nil {
			return nil, err
		}
		payments = append(payments, p)
	}
	return payments, rows.Err()
}

func (r *PaymentRepo) Confirm(ctx context.Context, paymentID string) error {
	now := time.Now()
	query := `
		UPDATE ilm_payment
		SET status = 'paid', paid_at = ?
		WHERE id = ?`

	_, err := r.db.ExecContext(ctx, query, now, paymentID)
	return err
}

func (r *PaymentRepo) CountPending(ctx context.Context, companyID string) (int, error) {
	var count int
	err := r.db.QueryRowContext(ctx,
		`SELECT COUNT(*) FROM ilm_payment WHERE to_company_id = ? AND status = 'pending'`,
		companyID,
	).Scan(&count)
	return count, err
}