background.js

const MODEL_ENDPOINT = "https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent";

const maxTokensByLevel = { H1: 300, H2: 350, H3: 450, PLAN: 600, PSEUDO: 700 };

chrome.runtime.onMessage.addListener((msg, sender, sendResponse) => {
if (msg.type === 'LCM_GET_HINT') {
handleGetHint(msg).then(sendResponse).catch(err => {
console.error('LCM_GET_HINT error', err);
sendResponse({ ok: false, error: String(err) });
});
return true; // async
}
});

async function getApiKey() {
return new Promise((resolve) => {
chrome.storage.local.get(['GEMINI_API_KEY'], d => resolve(d.GEMINI_API_KEY || ''));
});
}

function buildPrompt(msg) {
  const { context = {}, code = "", level, question = "" } = msg;
  if (level === "PSEUDO") return buildPseudoPrompt(context, code, question);
  return buildNormalHintPrompt(context, code, level, question);
}

function buildNormalHintPrompt(context, code, level, question) {
  const { title = "Unknown", url = "", difficulty = "" } = context;

  const rules = `ROLE: You are a considerate DSA mentor in the user's browser.
RULES:
- Give exactly ONE tiny hint per request.
- Start with a short Socratic question, then a 1–2 sentence nudge.
- Optionally include ≤5 lines showing the NEXT micro-change only.
- Provide ONE test case to try next.
- Never give full solutions unless the user types the word "reveal".`;

  const hintSpec = `HINT LEVEL: ${level}
If level is H1 → minimal nudge; H2 → concept; H3 → approach; PLAN → 4–6 bullet steps.`;

  const ctx = `CONTEXT:
Title: ${title}
URL: ${url}
Difficulty: ${difficulty}
User question: ${question}
User code (truncated):
${code ? code.slice(0, 5000) : "<no code yet>"}`;

  const format = `RESPONSE FORMAT (markdown):
- One Socratic question (short).
- One nudge (1–2 sentences).
- Optional snippet (<=5 lines) for the next micro-step.
- One explicit test case to try.`;

  return `${rules}\n\n${hintSpec}\n\n${ctx}\n\n${format}`;
}

function buildPseudoPrompt(context, code, question) {
  const { title = "Unknown", url = "", difficulty = "" } = context;

  const rules = `ROLE: You are a precise DSA mentor. The user wants COMPLETE language-agnostic pseudocode, not prose.`;

  const contract = `CONTRACT for PSEUDOCODE mode:
- Output ONLY a fenced code block. No text before or after.
- Label the fence as "pseudo" like: \`\`\`pseudo
- Length 10–16 lines.
- MUST include: variable initialization, main loop condition, per-iteration updates, edge/carry handling if applicable, pointer/index advances, and the final return line.
- Use generic control flow (if/else, while/for). Do NOT name any real language (C++/Java/etc.).`;

  const ctx = `CONTEXT:
Title: ${title}
URL: ${url}
Difficulty: ${difficulty}
User request: ${question || "complete pseudocode"}
User code (may be empty, do not copy language syntax from it):
${code ? code.slice(0, 2000) : "<no code yet>"}`;

  const output = `OUTPUT:
Return ONLY:
\`\`\`pseudo
<complete algorithm pseudocode 10–16 lines here>
\`\`\`
No prose.`;

  return `${rules}\n\n${contract}\n\n${ctx}\n\n${output}`;
}

async function handleGetHint(msg) {
const key = await getApiKey();
if (!key) return { ok: false, error: 'Missing API key. Open Options and paste your Gemini key.' };


const prompt = buildPrompt(msg);


const res = await fetch(`${MODEL_ENDPOINT}?key=${encodeURIComponent(key)}`, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
contents: [ { role: 'user', parts: [ { text: prompt } ] } ],
generationConfig: {
  temperature: 0.2,
  topK: 40,
  topP: 0.95,
  maxOutputTokens: maxTokensByLevel[msg.level] || 700
},

safetySettings: []
})
});

if (!res.ok) {
  let t = "";
  try { t = await res.text(); } catch {}
  if (res.status === 503) {
    return { ok: false, error: "Model is busy right now. Please wait ~20–60s and try again." };
  }
  if (res.status === 429) {
    return { ok: false, error: "Free-tier rate limit hit. Wait a bit and retry." };
  }
  if (res.status === 401 || res.status === 403) {
    return { ok: false, error: "API key invalid or not allowed. Check Options → Gemini key." };
  }
  return { ok: false, error: `Gemini error ${res.status}${t ? `: ${t}` : ""}` };
}

const data = await res.json();
const text = data?.candidates?.[0]?.content?.parts?.[0]?.text || '(no response)';
return { ok: true, text };
}

// Ask the page for Monaco's buffer (or a textarea fallback)
chrome.runtime.onMessage.addListener((msg, sender, sendResponse) => {
  if (msg.type !== "LCM_GET_CODE") return;   // ignore others

  const tabId = sender.tab?.id;
  if (!tabId) { sendResponse({ ok: false, error: "No tab id" }); return true; }

  chrome.scripting.executeScript(
    {
      target: { tabId },
      func: () => {
        try {
          // Monaco (preferred)
          const model = globalThis.monaco?.editor?.getModels?.()[0];
          if (model?.getValue) return { ok: true, code: model.getValue() };
          // Fallback: any textarea
          const ta = document.querySelector("textarea");
          return { ok: true, code: ta ? ta.value : "" };
        } catch (e) {
          return { ok: false, error: String(e) };
        }
      }
    },
    (results) => {
      if (chrome.runtime.lastError) {
        sendResponse({ ok: false, error: chrome.runtime.lastError.message });
        return;
      }
      const r = results?.[0]?.result || { ok: false, error: "No result" };
      sendResponse(r);
    }
  );
  return true; // async
});