Layer 1: Google Gemini AI
   ↓ (ถ้า fail หรือ quota เต็ม)
Layer 2: Google Search API
   ↓ (ถ้า fail หรือไม่เจอ)
Layer 3: Local Quotes (400 items)
   ↓
Always Return Something!

import { GoogleGenerativeAI } from "@google/generative-ai";
import dotenv from "dotenv";
import crypto from "crypto";

dotenv.config();

// Gemini initialization
const GEMINI_KEY = process.env.GEMINI_API_KEY || "";
const genAI = GEMINI_KEY ? new GoogleGenerativeAI(GEMINI_KEY) : null;

// Cache + Cooldown (in-memory)
const GEN_CACHE = new Map(); // key -> { ts, out }
const CACHE_TTL_MS = 1000 * 60 * 30; // 30 minutes
let geminiCooldownUntil = 0;

function now() {
  return Date.now();
}

function makeKey({ transcript, style, language }) {
  const raw = `${language}::${style}::${transcript}`;
  return crypto.createHash("sha1").update(raw).digest("hex");
}

function cacheGet(key) {
  const hit = GEN_CACHE.get(key);
  if (!hit) return null;
  
  // Check if expired
  if (now() - hit.ts > CACHE_TTL_MS) {
    GEN_CACHE.delete(key);
    return null;
  }
  
  return hit.out;
}

function cacheSet(key, out) {
  GEN_CACHE.set(key, { ts: now(), out });
}

export async function generateSummaryAndQuote({ 
  transcript, 
  style = "inspire", 
  language = "th" 
}) {
  const input = {
    transcript: String(transcript || "").trim(),
    style: String(style || "inspire"),
    language: String(language || "th"),
  };

  // Normalize language: auto -> th
  if (input.language === "auto") input.language = "th";
  
  if (!input.transcript) {
    return {
      lines: [],
      bullets: [],
      keywords: [],
      quote: "",
    };
  }

  // ---- Step 1: Check Cache ----
  const key = makeKey(input);
  const cached = cacheGet(key);
  if (cached) {
    return { ...cached, _source: "cache" };
  }

  // ---- Step 2: Try Gemini ----
  console.log("[SELECTION] Step 1: Trying AI...");
  const geminiOk = await tryGeminiOnce(input);
  if (geminiOk) {
    cacheSet(key, geminiOk);
    console.log("✅ AI generation successful");
    return { ...geminiOk, _source: "gemini" };
  }

  // ---- Step 3: Try Google Search ----
  console.log("[SELECTION] Step 2: Falling back to Google Search...");
  try {
    const googleResult = await tryGoogleSearch(
      input.transcript, 
      input.style, 
      input.language
    );
    if (googleResult) {
      cacheSet(key, googleResult);
      return { ...googleResult, _source: "google" };
    }
    throw new Error("Google Search returned null");
  } catch (googleErr) {
    console.warn("⚠️ Google Search failed:", googleErr?.message);
  }

  // ---- Step 4: Local Quotes ----
  console.log("[SELECTION] Step 3: Falling back to Local Quotes...");
  const local = tryRandomQuotes(input.transcript, input.style);
  cacheSet(key, local);
  return { ...local, _source: "local" };
}

async function tryGeminiOnce({ transcript, style, language }) {
  if (!genAI) {
    console.warn("⚠️ GEMINI_API_KEY missing -> skip AI");
    return null;
  }

  // Check cooldown
  if (now() < geminiCooldownUntil) {
    const left = Math.ceil((geminiCooldownUntil - now()) / 1000);
    console.warn(`⚠️ Gemini cooldown active (${left}s) -> skip AI`);
    return null;
  }

  try {
    const model = genAI.getGenerativeModel({ model: "gemini-2.0-flash-exp" });

    const langName = language === "th" ? "ไทย" : "English";
    const prompt = `
คุณคือผู้ช่วยสร้างคำคมที่สร้างแรงบันดาลใจ
ให้ตอบเป็นภาษา: ${langName}
สไตล์คำคม: ${style}

**สำคัญมาก:** 
- คำคม (quote) ต้อง**แตกต่าง**จากข้อความต้นฉบับ
- อย่าคัดลอกข้อความต้นฉบับมาเป็นคำคม
- สร้างคำคมใหม่ที่สร้างแรงบันดาลใจจากแนวคิดของข้อความต้นฉบับ
- คำคมควรสั้น กระชับ และมีพลัง

ตอบเป็น JSON เท่านั้น (ห้ามมีข้อความอื่น):
{
  "lines": ["สรุป 3-5 บรรทัด"],
  "bullets": ["หัวข้อย่อย 3 ข้อ"],
  "keywords": ["คีย์เวิร์ด 3-5 คำ"],
  "quote": "คำคมใหม่ที่สร้างแรงบันดาลใจ 1-2 ประโยค",
  "translation": "แปลคำคม (quote) เป็นภาษาไทย"
}

ข้อความต้นฉบับ:
"${transcript}"
    `.trim();

    const result = await model.generateContent(prompt);
    const text = result.response.text();
    const parsed = extractJson(text);

    return {
      lines: Array.isArray(parsed.lines) ? parsed.lines : [],
      bullets: Array.isArray(parsed.bullets) ? parsed.bullets : [],
      keywords: Array.isArray(parsed.keywords) ? parsed.keywords : [],
      quote: String(parsed.quote || "").trim(),
      translation: String(parsed.translation || "").trim(),
    };
  } catch (err) {
    // Handle 429 (Rate Limit)
    if (err?.status === 429) {
      const retryMs = parseRetryDelayMs(err) ?? 30_000;
      geminiCooldownUntil = now() + retryMs;
      console.warn(`⚠️ Gemini 429 -> cooldown ${Math.ceil(retryMs / 1000)}s`);
    }

    console.error("Gemini API Error:", err?.message || err);
    return null;
  }
}

function extractJson(text) {
  const s = String(text || "").trim();
  
  // Remove ```json fences
  const cleaned = s
    .replace(/```json/gi, "")
    .replace(/```/g, "")
    .trim();
  
  // Find JSON object
  const start = cleaned.indexOf("{");
  const end = cleaned.lastIndexOf("}");
  
  if (start >= 0 && end > start) {
    return JSON.parse(cleaned.slice(start, end + 1));
  }
  
  return JSON.parse(cleaned);
}

function parseRetryDelayMs(err) {
  try {
    const details = err?.errorDetails || [];
    const retry = details.find(d => 
      String(d["@type"] || "").includes("RetryInfo")
    );
    const s = String(retry?.retryDelay || "").trim(); // e.g. "44s"
    const m = /^(\d+)\s*s$/.exec(s);
    if (m) return Number(m[1]) * 1000;
  } catch { }
  return null;
}

function tryRandomQuotes(transcript, style) {
  console.log("📚 Using Local Quotes (Fallback Layer 3)...");

  const localQuotes = [
    "ความล้มเหลวไม่ใช่จุดจบ แต่เป็นจุดเริ่มต้นของความสำเร็จ",
    "อย่ารอให้โอกาสเข้ามาหา แต่จงออกไปสร้างโอกาสด้วยตัวเอง",
    "ทุกความพยายามอาจไม่นำมาซึ่งความสำเร็จ แต่ทุกความสำเร็จล้วนเกิดจากความพยายาม",
    // ... 400+ quotes
  ];

  const randomQuote = localQuotes[
    Math.floor(Math.random() * localQuotes.length)
  ];

  return {
    lines: [
      `เกี่ยวกับ: ${transcript.substring(0, 30)}...`,
      "ระบบใช้คำคมจากคลังข้อมูลสำรอง",
      "เนื่องจากโควต้า AI เต็มหรือค้นหาไม่พบ",
    ],
    bullets: ["สร้างแรงบันดาลใจ", "ข้อคิดเตือนใจ", "มุมมองชีวิต"],
    keywords: ["แรงบันดาลใจ", "ชีวิต", "ความสำเร็จ", "พลังบวก"],
    quote: randomQuote,
  };
}

User Request
    ↓
generateSummaryAndQuote()
    ↓
┌─────────────────────────────────┐
│ 1. Check Cache                  │
│    ✅ Hit → Return immediately   │
│    ❌ Miss → Continue            │
└────────────┬────────────────────┘
             ↓
┌─────────────────────────────────┐
│ 2. Try Gemini AI                │
│    ✅ Success → Cache & Return   │
│    ❌ Fail (429/Error) → Next    │
└────────────┬────────────────────┘
             ↓
┌─────────────────────────────────┐
│ 3. Try Google Search             │
│    ✅ Found → Cache & Return     │
│    ❌ Not Found → Next           │
└────────────┬────────────────────┘
             ↓
┌─────────────────────────────────┐
│ 4. Local Quotes                  │
│    ✅ Always Success             │
└────────────┬────────────────────┘
             ↓
        Return Result

// ✅ ดี - มี fallback
const result = await tryAI() || await trySearch() || getLocal();

// ❌ ไม่ดี - อาจ return null
const result = await tryAI();

// ✅ ดี - cache ก่อนเรียก API
const cached = getCache(key);
if (cached) return cached;

const result = await callAPI();
setCache(key, result);

// ✅ ดี - ตั้ง cooldown
if (err.status === 429) {
  cooldownUntil = now() + retryDelay;
}

// ❌ ไม่ดี - เรียก API ซ้ำทันที
if (err.status === 429) {
  return await callAPI(); // จะโดน 429 อีก!
}

// TODO: เพิ่ม retry 3 ครั้งสำหรับ Gemini API
// - ถ้า fail ครั้งแรก รอ 1 วินาที แล้วลองใหม่
// - ถ้า fail ครั้งที่ 2 รอ 2 วินาที
// - ถ้า fail ครั้งที่ 3 ไปใช้ fallback

// TODO: แทนที่ in-memory cache ด้วย Redis
// - ใช้ redis.get() และ redis.set()
// - ตั้ง TTL ด้วย EXPIRE

// TODO: เพิ่ม metrics tracking
// - นับจำนวน cache hits/misses
// - นับจำนวน API calls ต่อ source
// - คำนวณ cost savings จาก cache