PaymentSuggestion

"use client";

import * as React from "react";
import { cn } from "@/lib/ledger/cn";
import type { MoneyValue } from "@/lib/ledger/money.types";
import { Button } from "@/components/ledger/button";
import { SparklesIcon } from "@/components/ledger/icons";
import { Money } from "@/components/ledger/money";

export type InvoiceCandidate = { id: string; number: string; balance: number; age: number };

export interface PaymentSuggestionProps {
  candidates: InvoiceCandidate[];
  className?: string;
  lumpSum: MoneyValue;
  onAccept?: (ids: string[]) => void;
}

/**
 * Given a lump sum, propose the sets of open invoices that sum to it
 * exactly. Multiple valid combinations are ranked oldest-first, and the
 * basis is shown — not a bare confidence score.
 */
export function PaymentSuggestion({ lumpSum, candidates, onAccept, className }: PaymentSuggestionProps) {
  const target = Number(lumpSum.amount);
  const combos = React.useMemo(() => exactSubsets(candidates, target).slice(0, 3), [candidates, target]);

  if (combos.length === 0) {
    return (
      <p className={cn("text-body text-text-secondary", className)}>
        No combination of open invoices sums to <Money size="sm" tone="inherit" value={lumpSum} /> exactly.
      </p>
    );
  }

  return (
    <div className={cn("space-y-2", className)}>
      <h3 className="flex items-center gap-2 text-label font-medium text-text-secondary">
        <SparklesIcon aria-hidden="true" className="size-3.5 text-accent" />
        Combinations summing to <Money size="xs" tone="inherit" value={lumpSum} /> exactly
      </h3>
      <ul className="space-y-2">
        {combos.map((combo, i) => (
          <li
            className="flex flex-wrap items-center gap-3 rounded-md border border-border bg-surface p-3"
            key={i}
          >
            <span className="flex-1">
              <span className="reference-numeric block text-body">
                {combo.map((c) => c.number).join(" + ")}
              </span>
              <span className="block text-caption text-text-secondary">
                {combo.length} invoices · oldest {Math.max(...combo.map((c) => c.age))} days
              </span>
            </span>
            <Button onClick={() => onAccept?.(combo.map((c) => c.id))} size="sm" variant="primary">
              Apply this set
            </Button>
          </li>
        ))}
      </ul>
    </div>
  );
}

/** Small-n exact subset search, ranked oldest-first. */
function exactSubsets(candidates: InvoiceCandidate[], target: number): InvoiceCandidate[][] {
  const results: InvoiceCandidate[][] = [];
  const sorted = [...candidates].sort((a, b) => b.age - a.age);
  const limit = Math.min(sorted.length, 16);

  const walk = (index: number, running: number, picked: InvoiceCandidate[]) => {
    if (results.length >= 8) return;
    if (running === target && picked.length > 0) {
      results.push([...picked]);
      return;
    }
    if (running > target || index >= limit) return;
    picked.push(sorted[index]);
    walk(index + 1, running + sorted[index].balance, picked);
    picked.pop();
    walk(index + 1, running, picked);
  };

  walk(0, 0, []);
  return results;
}