background.js

const DEFAULT_MODEL = "gemini-2.5-flash";

chrome.runtime.onMessage.addListener((message, _sender, sendResponse) => {
  handleMessage(message)
    .then((data) => sendResponse({ ok: true, data }))
    .catch((error) => sendResponse({ ok: false, error: error.message || String(error) }));

  return true;
});

async function handleMessage(message) {
  if (!message || !message.type) {
    throw new Error("Invalid message.");
  }

  if (message.type === "capture-screen") {
    return captureScreen();
  }

  if (message.type === "analyze-visible-page") {
    return analyzeVisiblePage();
  }

  if (message.type === "analyze-image") {
    return analyzeImage(message.payload);
  }

  throw new Error(`Unknown action: ${message.type}`);
}

async function captureScreen() {
  const { tab, screenshotUrl } = await captureActiveTabScreenshot();

  const payload = {
    screenshotUrl,
    sourceTitle: tab.title || "Captured page",
    sourceUrl: tab.url || "",
    mode: "crop"
  };

  await sendCropOverlayMessage(tab.id, payload);
  return { tabId: tab.id };
}

async function analyzeVisiblePage() {
  const { tab, screenshotUrl } = await captureActiveTabScreenshot();

  const payload = {
    screenshotUrl,
    sourceTitle: tab.title || "Captured page",
    sourceUrl: tab.url || "",
    mode: "visible-page"
  };

  await sendCropOverlayMessage(tab.id, payload);
  return { tabId: tab.id };
}

async function captureActiveTabScreenshot() {
  const tabs = await chrome.tabs.query({ active: true, currentWindow: true });
  const tab = tabs[0];

  if (!tab || tab.id == null || tab.windowId == null) {
    throw new Error("No active tab found.");
  }

  if (tab.url && /^(chrome|edge|brave|about):\/\//i.test(tab.url)) {
    throw new Error("Chrome does not allow screenshots on internal browser pages.");
  }

  const screenshotUrl = await chrome.tabs.captureVisibleTab(tab.windowId, {
    format: "png"
  });

  return { tab, screenshotUrl };
}

async function sendCropOverlayMessage(tabId, payload) {
  try {
    await chrome.tabs.sendMessage(tabId, {
      type: "open-crop-overlay",
      payload
    });
    return;
  } catch (_error) {
    await chrome.scripting.executeScript({
      target: { tabId },
      files: ["content-crop.js"]
    });

    await chrome.tabs.sendMessage(tabId, {
      type: "open-crop-overlay",
      payload
    });
  }
}

async function analyzeImage(payload) {
  const { imageDataUrl, apiKey, prompt, model } = payload || {};

  if (!imageDataUrl) {
    throw new Error("No cropped image was provided.");
  }

  if (!apiKey) {
    throw new Error("Gemini API key is required.");
  }

  const image = parseDataUrl(imageDataUrl);
  const geminiModel = normalizeModel(model);

  const response = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/${geminiModel}:generateContent`, {
    method: "POST",
    headers: {
      "x-goog-api-key": apiKey,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      contents: [
        {
          parts: [
            {
              inline_data: {
                mime_type: image.mimeType,
                data: image.base64
              }
            },
            {
              text: prompt || defaultPrompt()
            }
          ]
        }
      ],
      generationConfig: {
        maxOutputTokens: 1200
      }
    })
  });

  const result = await response.json().catch(() => ({}));

  if (!response.ok) {
    const detail = result.error && result.error.message ? result.error.message : response.statusText;
    throw new Error(`Gemini request failed: ${detail}`);
  }

  const answer = extractResponseText(result);

  if (!answer) {
    throw new Error("Gemini returned an empty answer.");
  }

  const stored = {
    answer,
    model: geminiModel,
    createdAt: new Date().toISOString()
  };

  await chrome.storage.local.set({ latestAnswer: stored });
  return stored;
}

function defaultPrompt() {
  return [
    "Baca soal pada gambar dan jawab hanya jawaban akhirnya saja.",
    "Jangan pakai pembuka, ucapan terima kasih, analisis, langkah-langkah, markdown, atau penjelasan.",
    "Kalau soal pilihan ganda, jawab format: A. isi jawaban.",
    "Kalau soal isian/hitungan, jawab hasil akhirnya saja."
  ].join(" ");
}

function extractResponseText(result) {
  const chunks = [];
  for (const candidate of result.candidates || []) {
    const parts = candidate.content && Array.isArray(candidate.content.parts)
      ? candidate.content.parts
      : [];

    for (const part of parts) {
      if (typeof part.text === "string") {
        chunks.push(part.text);
      }
    }
  }

  return chunks.join("\n").trim();
}

function parseDataUrl(dataUrl) {
  const match = /^data:([^;,]+);base64,(.+)$/s.exec(dataUrl);

  if (!match) {
    throw new Error("Invalid cropped image format.");
  }

  return {
    mimeType: match[1],
    base64: match[2]
  };
}

function normalizeModel(model) {
  const value = (model || DEFAULT_MODEL).trim();
  return value.replace(/^models\//, "") || DEFAULT_MODEL;
}