"use client";
import { useMemo, useState } from "react";
import type { ValuationResponse, WaccResponse } from "@/types/api";
import { deltaClass, fmtCurrency, fmtPct } from "@/lib/format";
import {
  computeAdvancedDcf,
  computeDcf,
  computeSensitivityGrid,
  type AdvancedDcfInputs,
} from "@/lib/dcf";
import { AdvancedDcfPanel } from "@/components/prism/AdvancedDcfPanel";
import { DcfResults } from "@/components/prism/DcfResults";
import { SensitivityTable } from "@/components/prism/SensitivityTable";

type Props = { data: ValuationResponse; waccData?: WaccResponse | null; seedRevenue?: number | null };

type DcfMode = "simple" | "advanced";

function pctVsCurrent(implied?: number | null, current?: number | null): number | null {
  if (implied == null || current == null || current === 0) return null;
  return (implied - current) / current;
}

function SummaryChip({
  label,
  price,
  current,
  currency,
  accent = false,
  customised = false,
}: {
  label: string;
  price?: number | null;
  current?: number | null;
  currency: string;
  accent?: boolean;
  customised?: boolean;
}) {
  const pct = pctVsCurrent(price, current);
  return (
    <div className={`psm-val-chip${accent ? " accent" : ""}`}>
      <span className="psm-val-chip-label">
        {label}
        {customised && <span className="psm-val-chip-dot" />}
      </span>
      <span className="psm-val-chip-price">{price != null && price >= 0 ? fmtCurrency(price, 2, currency) : "—"}</span>
      {pct != null && (
        <span className={`psm-val-chip-pct ${deltaClass(pct)}`}>{fmtPct(pct, 1, true)}</span>
      )}
    </div>
  );
}

function MultipleRow({
  label,
  multiple,
  price,
  current,
  currency,
}: {
  label: string;
  multiple?: number | null;
  price?: number | null;
  current?: number | null;
  currency: string;
}) {
  const pct = pctVsCurrent(price, current);
  return (
    <div className="psm-val-mult-row">
      <span className="psm-val-mult-label">{label}</span>
      <span className="psm-val-mult-x">{multiple != null ? `${multiple.toFixed(1)}×` : "—"}</span>
      <span className="psm-val-mult-price">{price != null ? fmtCurrency(price, 2, currency) : "—"}</span>
      <span className={`psm-val-mult-pct ${pct != null ? deltaClass(pct) : "neutral"}`}>
        {pct != null ? fmtPct(pct, 1, true) : "—"}
      </span>
    </div>
  );
}

function DCFSlider({
  label,
  value,
  min,
  max,
  step,
  fmt,
  onChange,
}: {
  label: string;
  value: number;
  min: number;
  max: number;
  step: number;
  fmt: (v: number) => string;
  onChange: (v: number) => void;
}) {
  return (
    <div className="psm-val-slider-row">
      <div className="psm-val-slider-header">
        <span className="psm-val-slider-label">{label}</span>
        <span className="psm-val-slider-value">{fmt(value)}</span>
      </div>
      <input
        type="range"
        className="psm-val-range"
        min={min}
        max={max}
        step={step}
        value={value}
        onChange={(e) => onChange(parseFloat(e.target.value))}
      />
      <div className="psm-val-slider-ticks">
        <span className="psm-val-slider-tick">{fmt(min)}</span>
        <span className="psm-val-slider-tick">{fmt(max)}</span>
      </div>
    </div>
  );
}

function WaccNote({ waccData }: { waccData?: WaccResponse | null }) {
  if (!waccData?.available || waccData.wacc == null) return null;
  return (
    <div className="psm-val-wacc-note">
      <span className="psm-val-wacc-label">Market-implied WACC</span>
      <span className="psm-val-wacc-value">{fmtPct(waccData.wacc)}</span>
      <span className="psm-val-wacc-detail">
        β {waccData.beta.toFixed(2)} · Rf {fmtPct(waccData.risk_free_rate)} · ERP{" "}
        {fmtPct(waccData.equity_risk_premium)} · rd {fmtPct(waccData.cost_of_debt)} · t{" "}
        {fmtPct(waccData.tax_rate)}
      </span>
    </div>
  );
}

export function ValuationCard({ data, waccData, seedRevenue }: Props) {
  const { dcf, ev_ebitda, ev_revenue, price_to_book, current_price } = data;
  const currency = data.currency || "USD";

  // Slider defaults captured once from the initial API response
  const [defaults] = useState(() => ({
    wacc: dcf.wacc,
    terminalGrowth: dcf.terminal_growth,
    projectionYears: dcf.projection_years,
    growthRate: dcf.growth_rate_used ?? 0.05,
  }));

  const [wacc, setWacc] = useState(defaults.wacc);
  const [terminalGrowth, setTerminalGrowth] = useState(defaults.terminalGrowth);
  const [projectionYears, setProjectionYears] = useState(defaults.projectionYears);
  const [growthRate, setGrowthRate] = useState(defaults.growthRate);
  const [mode, setMode] = useState<DcfMode>("simple");
  const [advancedInputs, setAdvancedInputs] = useState<AdvancedDcfInputs>(() => ({
    baseRevenue: seedRevenue ?? 1_000,
    revenueGrowth: [0.05, 0.05, 0.05, 0.05, 0.05],
    ebitdaMargin: [0.25, 0.25, 0.25, 0.25, 0.25],
    dnaPctRevenue: [0.05, 0.05, 0.05, 0.05, 0.05],
    capexPctRevenue: [0.07, 0.07, 0.07, 0.07, 0.07],
    nwcPctDeltaRev: [0.02, 0.02, 0.02, 0.02, 0.02],
    taxRate: [0.21, 0.21, 0.21, 0.21, 0.21],
  }));

  const isCustomised =
    mode !== "simple" ||
    wacc !== defaults.wacc ||
    terminalGrowth !== defaults.terminalGrowth ||
    projectionYears !== defaults.projectionYears ||
    growthRate !== defaults.growthRate;

  function handleReset() {
    setMode("simple");
    setWacc(defaults.wacc);
    setTerminalGrowth(defaults.terminalGrowth);
    setProjectionYears(defaults.projectionYears);
    setGrowthRate(defaults.growthRate);
  }

  // equityBridge = net_debt + preferred equity + minority interest.
  // Derived as enterprise_value - equity_value (both from API); stays fixed while sliders move.
  const equityBridge =
    dcf.enterprise_value != null && dcf.equity_value != null
      ? dcf.enterprise_value - dcf.equity_value
      : (dcf.net_debt ?? 0);

  const computed = useMemo(() => {
    if (!dcf.available || dcf.error || !data.shares_outstanding) return null;
    if (mode === "advanced") {
      return computeAdvancedDcf(advancedInputs, {
        wacc,
        terminalGrowth,
        projectionYears: advancedInputs.revenueGrowth.length,
        sharesOutstanding: data.shares_outstanding,
        equityBridge,
      });
    }
    if (!dcf.base_fcf) return null;
    return computeDcf(
      { baseFcf: dcf.base_fcf, equityBridge, sharesOutstanding: data.shares_outstanding },
      { wacc, terminalGrowth, projectionYears, growthRate }
    );
  }, [mode, advancedInputs, wacc, terminalGrowth, projectionYears, growthRate, equityBridge, dcf, data.shares_outstanding]);

  const livePrice =
    computed && !("error" in computed) ? computed.intrinsicValuePerShare : null;

  const sensitivityMatrix = useMemo(() => {
    if (!dcf.available || dcf.error || !data.shares_outstanding) return null;
    if (mode === "simple" && dcf.sensitivity) return dcf.sensitivity;
    if (mode === "simple" && !dcf.base_fcf) return null;

    const shares = data.shares_outstanding;
    const grid = computeSensitivityGrid(wacc, terminalGrowth, (testWacc, testTerminalGrowth) => {
      if (mode === "simple") {
        if (!dcf.base_fcf) return null;
        const result = computeDcf(
          { baseFcf: dcf.base_fcf, equityBridge, sharesOutstanding: shares },
          { wacc: testWacc, terminalGrowth: testTerminalGrowth, projectionYears, growthRate }
        );
        return "error" in result ? null : result.intrinsicValuePerShare;
      }
      const result = computeAdvancedDcf(advancedInputs, {
        wacc: testWacc,
        terminalGrowth: testTerminalGrowth,
        projectionYears: advancedInputs.revenueGrowth.length,
        sharesOutstanding: shares,
        equityBridge,
      });
      return "error" in result ? null : result.intrinsicValuePerShare;
    });

    return {
      wacc: grid.wacc,
      terminal_growth: grid.terminalGrowth,
      implied_prices: grid.impliedPrices,
    };
  }, [mode, dcf, advancedInputs, wacc, terminalGrowth, projectionYears, growthRate, equityBridge, data.shares_outstanding]);

  const hasMultiples = ev_ebitda.available || ev_revenue.available || price_to_book.available;

  return (
    <section className="psm-card psm-val-card">
      {/* Summary strip */}
      <div className="psm-val-strip">
        <div className="psm-val-chip accent">
          <span className="psm-val-chip-label">Market Price</span>
          <span className="psm-val-chip-price">
            {current_price != null ? fmtCurrency(current_price, 2, currency) : "—"}
          </span>
        </div>
        <SummaryChip
          label="DCF"
          price={livePrice}
          current={current_price}
          currency={currency}
          customised={isCustomised}
        />
        <SummaryChip
          label="EV / EBITDA"
          price={ev_ebitda.available ? ev_ebitda.implied_price_per_share : null}
          current={current_price}
          currency={currency}
        />
        <SummaryChip
          label="EV / Revenue"
          price={ev_revenue.available ? ev_revenue.implied_price_per_share : null}
          current={current_price}
          currency={currency}
        />
        <SummaryChip
          label="P / Book"
          price={price_to_book.available ? price_to_book.implied_price_per_share : null}
          current={current_price}
          currency={currency}
        />
      </div>

      {data.currency_warning && (
        <p className="psm-muted-copy psm-val-currency-note">{data.currency_warning}</p>
      )}

      {/* DCF detail */}
      <div className="psm-val-section">
        <div className="psm-val-dcf-section-head">
          <span className="psm-eyebrow">Discounted Cash Flow</span>
          <div className="psm-val-mode-toggle">
            <div className="psm-val-mode-segment">
              <button
                className={`psm-val-mode-btn${mode === "simple" ? " active" : ""}`}
                onClick={() => setMode("simple")}
              >
                Simple
              </button>
              <button
                className={`psm-val-mode-btn${mode === "advanced" ? " active" : ""}`}
                onClick={() => setMode("advanced")}
              >
                Advanced
              </button>
            </div>
            {dcf.available && !dcf.error && isCustomised && (
              <button className="psm-val-reset-btn" onClick={handleReset}>
                Reset
              </button>
            )}
          </div>
        </div>

        {!dcf.available && (
          <p className="psm-muted-copy">Insufficient free cash flow history for DCF.</p>
        )}
        {dcf.available && dcf.error && (
          <p className="psm-val-dcf-error">{dcf.error}</p>
        )}
        {dcf.available && !dcf.error && (
          <div className="psm-val-dcf-body">
            {/* Left: assumptions */}
            <div className="psm-val-dcf-assumptions">
              <div className="psm-val-dcf-col-label">Assumptions</div>
              <WaccNote waccData={waccData} />
              {mode === "simple" ? (
                <>
                  <DCFSlider
                    label="WACC"
                    value={wacc}
                    min={0.03}
                    max={0.20}
                    step={0.005}
                    fmt={(v) => `${(v * 100).toFixed(1)}%`}
                    onChange={setWacc}
                  />
                  <DCFSlider
                    label="Terminal Growth"
                    value={terminalGrowth}
                    min={0}
                    max={0.06}
                    step={0.0025}
                    fmt={(v) => `${(v * 100).toFixed(2)}%`}
                    onChange={setTerminalGrowth}
                  />
                  <DCFSlider
                    label="FCF Growth"
                    value={growthRate}
                    min={0}
                    max={0.50}
                    step={0.01}
                    fmt={(v) => `${(v * 100).toFixed(0)}%`}
                    onChange={setGrowthRate}
                  />
                  <DCFSlider
                    label="Horizon"
                    value={projectionYears}
                    min={3}
                    max={15}
                    step={1}
                    fmt={(v) => `${v} yr`}
                    onChange={(v) => setProjectionYears(Math.round(v))}
                  />
                </>
              ) : (
                <AdvancedDcfPanel
                  inputs={advancedInputs}
                  onChange={setAdvancedInputs}
                  wacc={wacc}
                  terminalGrowth={terminalGrowth}
                  sharesOutstanding={data.shares_outstanding ?? 0}
                  equityBridge={equityBridge}
                  seedRevenue={seedRevenue}
                  currency={currency}
                />
              )}
            </div>

            {/* Divider */}
            <div className="psm-val-dcf-divider" />

            {/* Right: results */}
            <DcfResults
              dcf={dcf}
              computed={computed}
              livePrice={livePrice}
              sharesOutstanding={data.shares_outstanding ?? null}
              currency={currency}
            />
          </div>
        )}
        {sensitivityMatrix && (
          <SensitivityTable
            matrix={sensitivityMatrix}
            centerWacc={wacc}
            centerTerminalGrowth={terminalGrowth}
            currency={currency}
          />
        )}
      </div>

      {/* Multiples */}
      {hasMultiples && (
        <div className="psm-val-section">
          <div className="psm-val-section-head">
            <span className="psm-eyebrow">Multiples — at current market multiple</span>
          </div>
          <div className="psm-val-mult-list">
            {ev_ebitda.available && (
              <MultipleRow
                label="EV / EBITDA"
                multiple={ev_ebitda.multiple_used}
                price={ev_ebitda.implied_price_per_share}
                current={current_price}
                currency={currency}
              />
            )}
            {ev_revenue.available && (
              <MultipleRow
                label="EV / Revenue"
                multiple={ev_revenue.multiple_used}
                price={ev_revenue.implied_price_per_share}
                current={current_price}
                currency={currency}
              />
            )}
            {price_to_book.available && (
              <MultipleRow
                label="P / Book"
                multiple={price_to_book.multiple_used}
                price={price_to_book.implied_price_per_share}
                current={current_price}
                currency={currency}
              />
            )}
          </div>
        </div>
      )}
    </section>
  );
}