/**
 * TIP Hype Cycle Engine — Norton-Bass Diffusion Model
 *
 * Fits a Bass diffusion model to historical optical transceiver shipment share data,
 * maps the resulting adoption curve to a Gartner Hype Cycle phase, and stores the
 * analysis in hype_cycle_analysis table.
 *
 * Bass model (single-generation):
 *   cumulative adopters: F(t) = [1 - e^(-(p+q)*t)] / [1 + (q/p)*e^(-(p+q)*t)]
 *   rate of adoption:    f(t) = dF/dt = (p + q*F(t)) * (1 - F(t)) * M
 *
 * Parameters:
 *   p  — coefficient of innovation (typical: 0.001–0.03)
 *   q  — coefficient of imitation  (typical: 0.10–0.50)
 *   M  — market potential as fraction of total port shipments (0–1)
 *
 * Gartner phase mapping via position on the f(t) curve relative to f(t_peak):
 *   < 5% of M cumulative              → Innovation Trigger
 *   5–30% rising phase                → Peak of Inflated Expectations
 *   past peak, f(t) declining, F<60%  → Trough of Disillusionment
 *   F 60–85%                          → Slope of Enlightenment
 *   F > 85%                           → Plateau of Productivity
 *
 * Sources for seed data:
 *   Dell'Oro Group (public summaries), LightCounting quarterly (free tier),
 *   CIR Research, company earnings calls (public).
 */

import { pool } from "./db";

// ── Historical seed data ───────────────────────────────────────────────────────
// Approximate shipment share (% of total optical transceiver port volume) per year.
// Derived from publicly available Dell'Oro / LightCounting industry summaries.
// These are best estimates — the engine will fit curves to these points.

interface HistoricalPoint {
  year: number;
  shipmentShare: number;  // 0.0 – 1.0 fraction of total port shipments
  aspUsd?: number;        // OEM ASP at that year (optional, for price trajectory)
}

const HISTORICAL_DATA: Record<string, HistoricalPoint[]> = {
  "10G-SFP+": [
    { year: 2010, shipmentShare: 0.05, aspUsd: 800 },
    { year: 2011, shipmentShare: 0.12, aspUsd: 600 },
    { year: 2012, shipmentShare: 0.22, aspUsd: 450 },
    { year: 2013, shipmentShare: 0.32, aspUsd: 320 },
    { year: 2014, shipmentShare: 0.42, aspUsd: 240 },
    { year: 2015, shipmentShare: 0.52, aspUsd: 180 },
    { year: 2016, shipmentShare: 0.60, aspUsd: 130 },
    { year: 2017, shipmentShare: 0.62, aspUsd: 90 },
    { year: 2018, shipmentShare: 0.58, aspUsd: 60 },
    { year: 2019, shipmentShare: 0.50, aspUsd: 40 },
    { year: 2020, shipmentShare: 0.42, aspUsd: 28 },
    { year: 2021, shipmentShare: 0.36, aspUsd: 20 },
    { year: 2022, shipmentShare: 0.30, aspUsd: 14 },
    { year: 2023, shipmentShare: 0.24, aspUsd: 10 },
    { year: 2024, shipmentShare: 0.18, aspUsd: 7 },
    { year: 2025, shipmentShare: 0.13, aspUsd: 5 },
  ],
  "100G-QSFP28": [
    { year: 2016, shipmentShare: 0.02, aspUsd: 3200 },
    { year: 2017, shipmentShare: 0.08, aspUsd: 2200 },
    { year: 2018, shipmentShare: 0.18, aspUsd: 1400 },
    { year: 2019, shipmentShare: 0.28, aspUsd: 850 },
    { year: 2020, shipmentShare: 0.36, aspUsd: 480 },
    { year: 2021, shipmentShare: 0.42, aspUsd: 280 },
    { year: 2022, shipmentShare: 0.44, aspUsd: 160 },
    { year: 2023, shipmentShare: 0.42, aspUsd: 95 },
    { year: 2024, shipmentShare: 0.38, aspUsd: 60 },
    { year: 2025, shipmentShare: 0.34, aspUsd: 40 },
  ],
  "400G-QSFP-DD": [
    { year: 2020, shipmentShare: 0.01, aspUsd: 12000 },
    { year: 2021, shipmentShare: 0.04, aspUsd: 7500 },
    { year: 2022, shipmentShare: 0.09, aspUsd: 4200 },
    { year: 2023, shipmentShare: 0.18, aspUsd: 2200 },
    { year: 2024, shipmentShare: 0.28, aspUsd: 1100 },
    { year: 2025, shipmentShare: 0.36, aspUsd: 600 },
  ],
  "800G-OSFP": [
    { year: 2023, shipmentShare: 0.005, aspUsd: 24000 },
    { year: 2024, shipmentShare: 0.025, aspUsd: 16000 },
    { year: 2025, shipmentShare: 0.07,  aspUsd: 10000 },
  ],
  "400G-ZR": [
    { year: 2021, shipmentShare: 0.005, aspUsd: 8500 },
    { year: 2022, shipmentShare: 0.015, aspUsd: 5500 },
    { year: 2023, shipmentShare: 0.030, aspUsd: 3800 },
    { year: 2024, shipmentShare: 0.050, aspUsd: 2800 },
    { year: 2025, shipmentShare: 0.075, aspUsd: 2100 },
  ],
  "1.6T-OSFP": [
    { year: 2025, shipmentShare: 0.001, aspUsd: 40000 },
  ],
};

// Year the technology first entered commercial availability (t=0 for Bass model)
const FIRST_YEAR: Record<string, number> = {
  "10G-SFP+":     2009,
  "100G-QSFP28":  2015,
  "400G-QSFP-DD": 2019,
  "800G-OSFP":    2022,
  "400G-ZR":      2020,
  "1.6T-OSFP":    2024,
};

// Estimated peak market share (M) — as fraction of all optical transceiver ports at peak
// Technologies plateau at different shares because of market stratification
const MARKET_POTENTIAL: Record<string, number> = {
  "10G-SFP+":     0.65,  // Was dominant, now declining
  "100G-QSFP28":  0.48,  // Plateaued, being replaced by 400G
  "400G-QSFP-DD": 0.42,  // Growing, will peak ~2027
  "800G-OSFP":    0.35,  // Just starting, will peak ~2028-2029
  "400G-ZR":      0.15,  // Coherent niche, smaller market
  "1.6T-OSFP":    0.30,  // Future generation, estimate only
};

// ── Bass model math ────────────────────────────────────────────────────────────

/** Bass cumulative adoption fraction F(t) — 0..1 relative to M */
function bassCumulative(p: number, q: number, t: number): number {
  if (t <= 0) return 0;
  const pq = p + q;
  const num = 1 - Math.exp(-pq * t);
  const den = 1 + (q / p) * Math.exp(-pq * t);
  return num / den;
}

/** Bass instantaneous adoption rate f(t) = dF/dt * M */
function bassRate(p: number, q: number, M: number, t: number): number {
  const F = bassCumulative(p, q, t);
  return (p + q * F) * (1 - F) * M;
}

/** Year at which Bass adoption rate peaks: t_peak = ln(q/p) / (p+q) */
function bassPeakTime(p: number, q: number): number {
  if (q <= p) return 0; // no peak (monotonically declining from t=0, unusual)
  return Math.log(q / p) / (p + q);
}

// ── Least-squares Bass fitting ────────────────────────────────────────────────

interface BassParams { p: number; q: number; M: number; rSquared: number }

/**
 * Fit Bass parameters (p, q) to historical shipment share data via gradient descent.
 * M is fixed (from MARKET_POTENTIAL) to reduce the search space.
 */
function fitBass(
  data: HistoricalPoint[],
  firstYear: number,
  M: number
): BassParams {
  if (data.length < 2) {
    // Not enough data — return reasonable defaults
    return { p: 0.01, q: 0.25, M, rSquared: 0 };
  }

  // Convert to t (years since first year) and normalised share (relative to M)
  const points = data.map((d) => ({
    t: d.year - firstYear,
    F: Math.min(d.shipmentShare / M, 0.999), // cumulative fraction of M
  }));

  // Grid search over reasonable p/q ranges, then refine
  let bestP = 0.01;
  let bestQ = 0.25;
  let bestSse = Infinity;

  const pRange = [0.001, 0.003, 0.005, 0.008, 0.01, 0.015, 0.02, 0.03];
  const qRange = [0.05, 0.10, 0.15, 0.20, 0.25, 0.30, 0.35, 0.40, 0.50];

  for (const p of pRange) {
    for (const q of qRange) {
      let sse = 0;
      for (const pt of points) {
        const predicted = bassCumulative(p, q, pt.t);
        sse += (predicted - pt.F) ** 2;
      }
      if (sse < bestSse) {
        bestSse = sse;
        bestP = p;
        bestQ = q;
      }
    }
  }

  // Fine-grained refinement around best grid point
  const step = 0.001;
  for (let dp = -5; dp <= 5; dp++) {
    for (let dq = -10; dq <= 10; dq++) {
      const p = Math.max(0.001, bestP + dp * step);
      const q = Math.max(0.01,  bestQ + dq * step);
      let sse = 0;
      for (const pt of points) {
        const predicted = bassCumulative(p, q, pt.t);
        sse += (predicted - pt.F) ** 2;
      }
      if (sse < bestSse) {
        bestSse = sse;
        bestP = p;
        bestQ = q;
      }
    }
  }

  // Compute R²
  const meanF = points.reduce((s, pt) => s + pt.F, 0) / points.length;
  const ssTot = points.reduce((s, pt) => s + (pt.F - meanF) ** 2, 0);
  const rSquared = ssTot > 0 ? Math.max(0, 1 - bestSse / ssTot) : 0;

  return { p: bestP, q: bestQ, M, rSquared };
}

// ── Gartner Hype Cycle phase detection ───────────────────────────────────────

type HypePhase =
  | "innovation_trigger"
  | "peak_inflated_expectations"
  | "trough_disillusionment"
  | "slope_enlightenment"
  | "plateau_productivity";

interface PhaseResult {
  phase: HypePhase;
  hypeScore: number;          // 0–100 position on Gartner curve
  yearsToNext: number;        // estimated years until next phase
  phaseSinceYear: number;     // approximate calendar year current phase started
}

/**
 * Map Bass model position to Gartner Hype Cycle phase.
 * Uses cumulative adoption F(t) and whether we're before/after the peak.
 */
function detectPhase(
  p: number,
  q: number,
  M: number,
  currentT: number,
  firstYear: number
): PhaseResult {
  const tPeak = bassPeakTime(p, q);
  const F = bassCumulative(p, q, currentT);
  const currentShare = F * M;
  const peakF = bassCumulative(p, q, tPeak);

  // Normalised position: 0 = start, 1 = peak rate (not peak cumulative)
  const prePeakNorm = tPeak > 0 ? Math.min(currentT / tPeak, 1) : 1;
  const isPrePeak = currentT < tPeak;

  let phase: HypePhase;
  let hypeScore: number;
  let yearsToNext: number;
  let phaseSinceYear: number;

  if (currentShare < 0.03 * M) {
    // < 3% of market potential — innovation trigger
    phase = "innovation_trigger";
    hypeScore = Math.round(prePeakNorm * 25);
    // Estimate time to reach 5% share
    let tTo5pct = currentT + 1;
    while (bassCumulative(p, q, tTo5pct) * M < 0.05 * M && tTo5pct < 30) tTo5pct++;
    yearsToNext = Math.max(0.5, tTo5pct - currentT);
    phaseSinceYear = firstYear;

  } else if (isPrePeak || F < peakF * 0.85) {
    // Rising phase — Peak of Inflated Expectations
    phase = "peak_inflated_expectations";
    // Score 25–75 based on how close we are to the rate peak
    hypeScore = Math.round(25 + prePeakNorm * 50);
    yearsToNext = Math.max(0.5, tPeak - currentT + 1);
    // Phase started when share crossed 5%
    let tStart = 0;
    while (bassCumulative(p, q, tStart) * M < 0.03 * M && tStart < tPeak) tStart += 0.5;
    phaseSinceYear = Math.round(firstYear + tStart);

  } else if (F < 0.50) {
    // Post-peak, still < 50% adoption — Trough of Disillusionment
    phase = "trough_disillusionment";
    // Score 75 → 45 (declining from peak)
    const postPeakProgress = (F - peakF * 0.85) / (0.50 - peakF * 0.85);
    hypeScore = Math.round(75 - postPeakProgress * 30);
    // Time to reach 50% share
    let tTo50 = currentT + 0.5;
    while (bassCumulative(p, q, tTo50) < 0.50 && tTo50 < 30) tTo50 += 0.5;
    yearsToNext = Math.max(0.5, tTo50 - currentT);
    phaseSinceYear = Math.round(firstYear + tPeak);

  } else if (F < 0.85) {
    // 50–85% cumulative — Slope of Enlightenment
    phase = "slope_enlightenment";
    const enlightProgress = (F - 0.50) / (0.85 - 0.50);
    hypeScore = Math.round(45 + enlightProgress * 30);
    // Time to reach 85% share
    let tTo85 = currentT + 0.5;
    while (bassCumulative(p, q, tTo85) < 0.85 && tTo85 < 30) tTo85 += 0.5;
    yearsToNext = Math.max(0.5, tTo85 - currentT);
    let tStart50 = currentT;
    while (tStart50 > 0 && bassCumulative(p, q, tStart50 - 0.5) >= 0.50) tStart50 -= 0.5;
    phaseSinceYear = Math.round(firstYear + tStart50);

  } else {
    // > 85% adoption — Plateau of Productivity
    phase = "plateau_productivity";
    hypeScore = Math.min(100, Math.round(75 + (F - 0.85) / (1 - 0.85) * 25));
    yearsToNext = 0; // no next phase
    let tStart85 = currentT;
    while (tStart85 > 0 && bassCumulative(p, q, tStart85 - 0.5) < 0.85) tStart85 += 0.5;
    phaseSinceYear = Math.round(firstYear + tStart85);
  }

  return { phase, hypeScore, yearsToNext, phaseSinceYear };
}

// ── ASP projection ────────────────────────────────────────────────────────────

/**
 * Project ASP decline based on historical data (log-linear regression).
 * Returns: current ASP (estimated) + % decline expected over 3 years.
 */
function projectAsp(data: HistoricalPoint[]): { currentAsp: number | null; declinePct3y: number | null } {
  const withAsp = data.filter((d) => d.aspUsd != null && d.aspUsd > 0);
  if (withAsp.length < 2) return { currentAsp: withAsp[0]?.aspUsd ?? null, declinePct3y: null };

  // Log-linear fit: ln(asp) = a + b * year
  const n = withAsp.length;
  const sumX = withAsp.reduce((s, d) => s + d.year, 0);
  const sumY = withAsp.reduce((s, d) => s + Math.log(d.aspUsd!), 0);
  const sumXY = withAsp.reduce((s, d) => s + d.year * Math.log(d.aspUsd!), 0);
  const sumX2 = withAsp.reduce((s, d) => s + d.year * d.year, 0);
  const b = (n * sumXY - sumX * sumY) / (n * sumX2 - sumX * sumX);
  const a = (sumY - b * sumX) / n;

  const currentYear = new Date().getFullYear();
  const currentAsp = Math.exp(a + b * currentYear);
  const futureAsp = Math.exp(a + b * (currentYear + 3));
  const declinePct3y = ((currentAsp - futureAsp) / currentAsp) * 100;

  return {
    currentAsp: Math.round(currentAsp),
    declinePct3y: Math.round(declinePct3y),
  };
}

// ── Seed market_metrics with historical data ──────────────────────────────────

async function seedMarketMetrics(): Promise<void> {
  const currentYear = new Date().getFullYear();

  for (const [tech, points] of Object.entries(HISTORICAL_DATA)) {
    for (const pt of points) {
      if (pt.year > currentYear) continue; // Don't seed future projections

      // shipment_share
      await pool.query(
        `INSERT INTO market_metrics (time, technology, metric_type, value, source, notes)
         VALUES ($1, $2, 'shipment_share', $3, $4, $5)
         ON CONFLICT DO NOTHING`,
        [
          new Date(pt.year, 6, 1).toISOString(), // mid-year timestamp
          tech,
          pt.shipmentShare,
          "Dell\'Oro/LightCounting (public summary)",
          `Annual shipment share ${pt.year}`,
        ]
      );

      // asp_usd
      if (pt.aspUsd) {
        await pool.query(
          `INSERT INTO market_metrics (time, technology, metric_type, value, source, notes)
           VALUES ($1, $2, 'asp_usd', $3, $4, $5)
           ON CONFLICT DO NOTHING`,
          [
            new Date(pt.year, 6, 1).toISOString(),
            tech,
            pt.aspUsd,
            "Dell\'Oro/LightCounting (public summary)",
            `OEM ASP estimate ${pt.year} USD`,
          ]
        );
      }
    }
  }
}

// ── Main compute function ─────────────────────────────────────────────────────

export async function computeHypeCycle(): Promise<void> {
  console.log("=== Hype Cycle Engine — Norton-Bass Model ===\n");

  // Seed historical data if not present
  const { rows: existing } = await pool.query(
    `SELECT COUNT(*) AS n FROM market_metrics WHERE metric_type = 'shipment_share'`
  );
  if (parseInt(existing[0].n, 10) < 10) {
    console.log("  Seeding historical market_metrics data...");
    await seedMarketMetrics();
    console.log("  Seed complete.\n");
  }

  const currentYear = new Date().getFullYear();
  const results: Array<{
    technology: string;
    phase: HypePhase;
    hypeScore: number;
    currentShare: number;
    aspCurrent: number | null;
    aspDecline3y: number | null;
  }> = [];

  for (const [tech, data] of Object.entries(HISTORICAL_DATA)) {
    const firstYear = FIRST_YEAR[tech] ?? (data[0]?.year ?? 2020);
    const M = MARKET_POTENTIAL[tech] ?? 0.30;
    const currentT = currentYear - firstYear;

    // Fit Bass model
    const { p, q, rSquared } = fitBass(data, firstYear, M);
    const tPeak = bassPeakTime(p, q);
    const F = bassCumulative(p, q, currentT);
    const currentShare = F * M;

    // Detect phase
    const { phase, hypeScore, yearsToNext, phaseSinceYear } = detectPhase(
      p, q, M, currentT, firstYear
    );

    // Project 1y and 3y adoption
    const F1y = bassCumulative(p, q, currentT + 1);
    const F3y = bassCumulative(p, q, currentT + 3);

    // ASP projection
    const { currentAsp, declinePct3y } = projectAsp(data);

    // Store result in hype_cycle_analysis
    await pool.query(
      `INSERT INTO hype_cycle_analysis (
         computed_at, technology,
         bass_p, bass_q, bass_m,
         t_peak_year, current_t, current_share,
         projected_share_1y, projected_share_3y,
         hype_phase, hype_score, phase_since_year, years_to_next_phase,
         asp_current_usd, asp_decline_pct_3y,
         r_squared, data_points, notes
       ) VALUES (
         NOW(), $1,
         $2, $3, $4,
         $5, $6, $7,
         $8, $9,
         $10, $11, $12, $13,
         $14, $15,
         $16, $17, $18
       )`,
      [
        tech,
        p, q, M,
        Math.round((firstYear + tPeak) * 10) / 10,
        currentT,
        Math.round(currentShare * 1000) / 1000,
        Math.round(F1y * M * 1000) / 1000,
        Math.round(F3y * M * 1000) / 1000,
        phase,
        hypeScore,
        phaseSinceYear,
        Math.round(yearsToNext * 10) / 10,
        currentAsp,
        declinePct3y,
        Math.round(rSquared * 1000) / 1000,
        data.length,
        `Fitted via grid search + refinement. Data points: ${data[0]?.year}–${data[data.length - 1]?.year}`,
      ]
    );

    results.push({ technology: tech, phase, hypeScore, currentShare, aspCurrent: currentAsp, aspDecline3y: declinePct3y });

    const phaseEmoji: Record<HypePhase, string> = {
      innovation_trigger:          "🔬",
      peak_inflated_expectations:  "📈",
      trough_disillusionment:      "📉",
      slope_enlightenment:         "🔄",
      plateau_productivity:        "✅",
    };

    console.log(
      `  ${phaseEmoji[phase]} ${tech.padEnd(18)} ` +
      `phase=${phase.padEnd(30)} ` +
      `score=${hypeScore.toString().padStart(3)} ` +
      `share=${(currentShare * 100).toFixed(1).padStart(5)}%  ` +
      `R²=${rSquared.toFixed(2)}  ` +
      `ASP=${currentAsp ? `$${currentAsp.toLocaleString()}` : "n/a"}`
    );
  }

  // Update hype_score in market_metrics for API consumers
  for (const r of results) {
    await pool.query(
      `INSERT INTO market_metrics (time, technology, metric_type, value, source, notes)
       VALUES (NOW(), $1, 'hype_score', $2, 'hype-cycle-engine', $3)`,
      [r.technology, r.hypeScore, r.phase]
    );
  }

  // Cleanup old analysis rows
  await pool.query(`SELECT cleanup_hype_cycle_analysis()`);

  console.log(`\n=== Hype Cycle Engine Complete — ${results.length} technologies analyzed ===\n`);
}

// ── Export for API endpoint ───────────────────────────────────────────────────

/** Fetch latest hype cycle analysis for all or a specific technology */
export async function getHypeCycleAnalysis(technology?: string): Promise<unknown[]> {
  const sql = technology
    ? `SELECT * FROM hype_cycle_analysis WHERE technology = $1 ORDER BY computed_at DESC LIMIT 1`
    : `SELECT DISTINCT ON (technology) * FROM hype_cycle_analysis ORDER BY technology, computed_at DESC`;

  const { rows } = await pool.query(sql, technology ? [technology] : []);
  return rows;
}

// ── CLI entry point ───────────────────────────────────────────────────────────

if (require.main === module) {
  computeHypeCycle()
    .then(() => pool.end())
    .catch((err: unknown) => {
      console.error("Fatal:", err);
      pool.end();
      process.exit(1);
    });
}