import Link from 'next/link';
import { FreshnessBadge } from '@/components/ui/badges';
import { fmtAgo, fmtDateTime, fmtInt } from '@/lib/format';
import type { ConnectorStatus } from '@/lib/types';

/** "in 2 h" / "overdue 5 min" for scheduled timestamps (fmtAgo only handles the past). */
export function fmtUntil(v: string | null | undefined, now: number = Date.now()): string {
  if (!v) return '—';
  const t = new Date(v).getTime();
  if (Number.isNaN(t)) return '—';
  const s = Math.round((t - now) / 1000);
  if (s <= 0) return s > -60 ? 'due now' : `overdue ${fmtAgo(v, now).replace(' ago', '')}`;
  if (s < 60) return 'in < 1 min';
  const m = Math.round(s / 60);
  if (m < 60) return `in ${m} min`;
  const h = Math.round(m / 60);
  if (h < 48) return `in ${h} h`;
  return `in ${Math.round(h / 24)} d`;
}

export function fmtDuration(ms: number | null | undefined): string {
  if (ms === null || ms === undefined) return '—';
  if (ms < 1000) return `${fmtInt(ms)} ms`;
  if (ms < 120_000) return `${(ms / 1000).toFixed(1)} s`;
  return `${(ms / 60_000).toFixed(1)} min`;
}

export function fmtInterval(s: number | null | undefined): string {
  if (!s) return '—';
  if (s % 86400 === 0) return `${s / 86400} d`;
  if (s % 3600 === 0) return `${s / 3600} h`;
  return `${Math.round(s / 60)} min`;
}

export function RunStatusPill({ status }: { status: string | null | undefined }) {
  const s = status ?? 'never run';
  const color = s === 'success' ? 'var(--active)' : s === 'failed' ? 'var(--danger)' : s === 'running' ? 'var(--accent)' : s === 'unchanged' ? 'var(--ink-2)' : 'var(--inactive)';
  return (
    <span className="mono inline-flex items-center gap-1.5 text-xs" style={{ color }}>
      <span className="dot" aria-hidden /> {s}
    </span>
  );
}

/**
 * Connector health table (public /status, /status/data, admin overview). Stacks into cards under 768 px.
 * `last_error` is the error of the most recent *failed* run, which may be older than the last success — labelled accordingly.
 */
export function ConnectorsTable({ connectors, now = Date.now(), linkAdmin = false }: { connectors: ConnectorStatus[]; now?: number; linkAdmin?: boolean }) {
  return (
    <div className="overflow-x-auto">
      <table className="data-table stack min-w-0 md:min-w-[960px]">
        <thead>
          <tr>
            <th>Connector</th>
            <th>Freshness</th>
            <th>Last success</th>
            <th>Last status</th>
            <th>Next run</th>
            <th className="num">Duration</th>
            <th className="num">Failures</th>
            <th>Circuit</th>
            <th>Last failure</th>
          </tr>
        </thead>
        <tbody>
          {connectors.map((c) => (
            <tr key={c.name}>
              <td className="primary">
                {linkAdmin ? (
                  <Link href={`/admin/connectors/${encodeURIComponent(c.name)}`} className="mono text-sm text-ink hover:text-accent">
                    {c.name}
                  </Link>
                ) : (
                  <span className="mono text-sm text-ink">{c.name}</span>
                )}
                <div className="text-xs text-ink-3">
                  {c.source_name} · every {fmtInterval(c.interval_seconds)}
                  {!c.enabled && <span className="ml-2 text-warn">disabled</span>}
                </div>
              </td>
              <td data-label="Freshness">
                <FreshnessBadge status={c.freshness} />
              </td>
              <td data-label="Last success" title={fmtDateTime(c.last_success_at)}>
                <span className="text-sm">{fmtAgo(c.last_success_at, now)}</span>
              </td>
              <td data-label="Last status">
                <RunStatusPill status={c.last_status} />
              </td>
              <td data-label="Next run" title={fmtDateTime(c.next_run_at)}>
                <span className="text-sm text-ink-2">{c.enabled ? fmtUntil(c.next_run_at, now) : '—'}</span>
              </td>
              <td data-label="Duration" className="num tnum text-sm text-ink-2">
                {fmtDuration(c.last_duration_ms)}
              </td>
              <td data-label="Failures" className="num tnum text-sm">
                <span className={c.consecutive_failures > 0 ? 'text-warn' : 'text-ink-2'}>{fmtInt(c.consecutive_failures)}</span>
              </td>
              <td data-label="Circuit">
                {c.circuit_open_until && new Date(c.circuit_open_until).getTime() > now ? (
                  <span className="text-xs text-danger" title={fmtDateTime(c.circuit_open_until)}>
                    open · resets {fmtUntil(c.circuit_open_until, now)}
                  </span>
                ) : (
                  <span className="text-xs text-ink-3">closed</span>
                )}
              </td>
              <td data-label="Last failure" className="max-w-[280px]">
                {c.last_error ? (
                  <span className="mono block truncate text-xs text-ink-3" title={c.last_error}>
                    {c.last_error.length > 80 ? `${c.last_error.slice(0, 80)}…` : c.last_error}
                  </span>
                ) : (
                  <span className="text-xs text-ink-3">none recorded</span>
                )}
              </td>
            </tr>
          ))}
        </tbody>
      </table>
    </div>
  );
}

/** Freshness thresholds legend: per-connector thresholds scale with the connector interval (misc.py: aging = 3×, stale = 12×). */
export function FreshnessLegend({ connectors }: { connectors?: ConnectorStatus[] }) {
  return (
    <div className="text-sm leading-relaxed text-ink-2">
      <p>
        Connector freshness is relative to each connector&rsquo;s own schedule: <FreshnessBadge status="fresh" label="fresh" /> when the last successful sync is younger than 3 × the interval,{' '}
        <FreshnessBadge status="aging" label="aging" /> up to 12 × the interval, <FreshnessBadge status="stale" label="stale" /> beyond that, <FreshnessBadge status="unavailable" label="unavailable" /> when it never succeeded and{' '}
        <FreshnessBadge status="not_enabled" label="not enabled" /> for planned connectors.
      </p>
      {connectors && connectors.length > 0 && (
        <ul className="mt-3 grid gap-1 text-xs text-ink-3 sm:grid-cols-2">
          {connectors.map((c) => (
            <li key={c.name} className="mono">
              {c.name}: every {fmtInterval(c.interval_seconds)} → aging after {fmtInterval(c.interval_seconds * 3)}, stale after {fmtInterval(c.interval_seconds * 12)}
            </li>
          ))}
        </ul>
      )}
    </div>
  );
}