// in src/content/badges.ts
export type ScanEntry =
  | { kind: 'image'; img: HTMLImageElement; overlay: HTMLElement; badge: HTMLElement;
      timeoutId?: number; cleanup: () => void }
  | { kind: 'text'; toast: HTMLElement; timeoutId?: number; cleanup: () => void };

chrome.tabs.sendMessage(tabId, msg, (resp) => {
  if (chrome.runtime.lastError) {
    console.warn('[bg] sendMessage failed:', chrome.runtime.lastError.message);
    // Optional: surface a one-time toast in popup if applicable.
  }
});

for (const entry of activeBadges.values()) entry.cleanup();
activeBadges.clear();

import { pipeline, env, type ImageClassificationPipeline } from '@huggingface/transformers';

// Force remote-only (no local model resolution at runtime).
env.allowLocalModels = false;
env.allowRemoteModels = true;
env.useBrowserCache = true;

// HF primary, GitHub Releases fallback. See §6 for fallback wiring.
env.remoteHost = 'https://huggingface.co';

const DEFAULT_IMAGE_MODEL = 'Organika/sdxl-detector';
const MODEL_REVISION = 'main'; // TODO: pin to specific SHA before Phase 2 ships

let imageClassifier: ImageClassificationPipeline | null = null;
let imageLoading: Promise<ImageClassificationPipeline> | null = null;

export interface ProgressCallback {
  (info: { phase: 'downloading' | 'ready' | 'error'; pct?: number; error?: string }): void;
}

export async function ensureImageClassifier(
  modelId: string = DEFAULT_IMAGE_MODEL,
  onProgress?: ProgressCallback,
): Promise<ImageClassificationPipeline> {
  if (imageClassifier) return imageClassifier;
  if (imageLoading) return imageLoading;

  imageLoading = (async () => {
    onProgress?.({ phase: 'downloading', pct: 0 });
    try {
      const pipe = await pipeline('image-classification', modelId, {
        dtype: 'q8',
        device: 'auto',
        revision: MODEL_REVISION,
        progress_callback: (p: any) => {
          if (p.status === 'progress' && typeof p.progress === 'number') {
            onProgress?.({ phase: 'downloading', pct: Math.round(p.progress) });
          }
        },
      });
      imageClassifier = pipe as ImageClassificationPipeline;
      onProgress?.({ phase: 'ready', pct: 100 });
      return imageClassifier;
    } catch (err) {
      onProgress?.({ phase: 'error', error: String(err) });
      imageLoading = null;
      throw err;
    }
  })();

  return imageLoading;
}

export async function classifyImageDataUrl(
  dataUrl: string,
  onProgress?: ProgressCallback,
): Promise<{ rawScores: Record<string, number>; modelId: string; durationMs: number }> {
  const t0 = performance.now();
  const pipe = await ensureImageClassifier(undefined, onProgress);

  // transformers.js accepts data URLs and HTML image elements.
  const out = await pipe(dataUrl, { top_k: 5 });
  const rawScores: Record<string, number> = {};
  for (const item of out as Array<{ label: string; score: number }>) {
    rawScores[item.label] = item.score;
  }

  return {
    rawScores,
    modelId: DEFAULT_IMAGE_MODEL,
    durationMs: performance.now() - t0,
  };
}

import { classifyImageDataUrl } from '@/offscreen/ml-engine';
import type { ClassificationResult } from '@/shared/types';

const FAKE_LABEL_ALIASES = new Set(['fake', 'ai', 'ai-generated', 'generated']);
const REAL_LABEL_ALIASES = new Set(['real', 'human', 'photo', 'photograph']);

const UNCERTAIN_BAND = 0.10; // ±0.10 from threshold = uncertain

export async function classifyImageLocal(
  dataUrl: string,
  threshold: number,
): Promise<ClassificationResult> {
  const { rawScores, modelId, durationMs } = await classifyImageDataUrl(dataUrl);

  let aiScore = 0;
  let realScore = 0;
  for (const [label, score] of Object.entries(rawScores)) {
    const norm = label.toLowerCase();
    if (FAKE_LABEL_ALIASES.has(norm)) aiScore = Math.max(aiScore, score);
    if (REAL_LABEL_ALIASES.has(norm)) realScore = Math.max(realScore, score);
  }

  // Decide label
  let label: ClassificationResult['label'];
  let confidence: number;
  if (aiScore > realScore + UNCERTAIN_BAND && aiScore > threshold) {
    label = 'ai';
    confidence = aiScore;
  } else if (realScore > aiScore + UNCERTAIN_BAND && realScore > threshold) {
    label = 'real';
    confidence = realScore;
  } else {
    label = 'uncertain';
    confidence = Math.max(aiScore, realScore);
  }

  return {
    label,
    confidence,
    source: 'local',
    modelId,
    rawScores,
    durationMs,
  };
}

import { classifyImageLocal } from '@/detectors/image/local';
import { ensureImageClassifier } from './ml-engine';
import type { Message } from '@/shared/types';

chrome.runtime.onMessage.addListener((message: Message, _sender, sendResponse) => {
  if (message.type === 'CLASSIFY_IMAGE') {
    (async () => {
      try {
        const result = await classifyImageLocal(message.dataUrl, message.threshold ?? 0.55);
        sendResponse({ ok: true, requestId: message.requestId, result });
      } catch (err) {
        sendResponse({ ok: false, requestId: message.requestId, error: String(err) });
      }
    })();
    return true; // async sendResponse
  }

  if (message.type === 'PRELOAD_IMAGE_MODEL') {
    (async () => {
      await ensureImageClassifier(undefined, (info) => {
        chrome.runtime.sendMessage({ type: 'MODEL_STATUS', phase: info.phase, pct: info.pct });
      });
      sendResponse({ ok: true });
    })();
    return true;
  }
});

async function handleClassifyImage(msg: ClassifyImageMessage, sender: chrome.runtime.MessageSender) {
  await ensureOffscreen();
  const settings = await getSettings();

  // Phase 4 will branch here on settings.boostProvider.
  const response = await chrome.runtime.sendMessage({
    type: 'CLASSIFY_IMAGE',
    requestId: msg.requestId,
    dataUrl: msg.dataUrl,
    threshold: settings.confidenceThreshold,
  });

  if (sender.tab?.id != null) {
    chrome.tabs.sendMessage(sender.tab.id, {
      type: 'RESULT',
      requestId: msg.requestId,
      result: response?.ok ? response.result : {
        label: 'uncertain', confidence: 0, source: 'local',
        modelId: 'error', durationMs: 0,
        reasoning: response?.error ?? 'Unknown error',
      },
    }, (_) => { /* ignore lastError */ void chrome.runtime.lastError; });
  }
}

// Updated imageToDataUrl
async function imageToDataUrl(img: HTMLImageElement): Promise<string | null> {
  const src = img.currentSrc || img.src;
  if (!src) return null;

  // Skip data: URLs > 2 MB and SVGs (raster-only models can't handle SVG cleanly)
  if (src.startsWith('data:image/svg')) return null;
  if (src.startsWith('data:') && src.length > 2 * 1024 * 1024) return null;

  // Path A: try canvas (fast)
  try {
    const bitmap = await createImageBitmap(img, {
      resizeWidth: 224, resizeHeight: 224, resizeQuality: 'medium',
    });
    const canvas = new OffscreenCanvas(224, 224);
    const ctx = canvas.getContext('2d')!;
    ctx.drawImage(bitmap, 0, 0);
    bitmap.close();
    const blob = await canvas.convertToBlob({ type: 'image/jpeg', quality: 0.85 });
    return await blobToDataUrl(blob);
  } catch (e) {
    // Path B: fall back to background fetch
    return new Promise((resolve) => {
      chrome.runtime.sendMessage({ type: 'FETCH_IMAGE_BYTES', src }, (resp) => {
        if (chrome.runtime.lastError || !resp?.ok) return resolve(null);
        resolve(resp.dataUrl);
      });
    });
  }
}

if (message.type === 'FETCH_IMAGE_BYTES') {
  (async () => {
    try {
      const r = await fetch(message.src, { credentials: 'include' });
      if (!r.ok) return sendResponse({ ok: false, error: `HTTP ${r.status}` });
      const blob = await r.blob();
      const reader = new FileReader();
      reader.onload = () => sendResponse({ ok: true, dataUrl: reader.result });
      reader.onerror = () => sendResponse({ ok: false, error: 'read-failed' });
      reader.readAsDataURL(blob);
    } catch (err) {
      sendResponse({ ok: false, error: String(err) });
    }
  })();
  return true;
}

import type { ClassificationResult } from './types';

const DB_NAME = 'aicd-cache-v1';
const STORE = 'results';
const TTL_MS = 7 * 24 * 60 * 60 * 1000; // 7 days

interface CacheEntry {
  key: string; // sha256(bytes) + ':' + modelId + ':' + provider
  result: ClassificationResult;
  expiresAt: number;
}

let dbPromise: Promise<IDBDatabase> | null = null;

function openDb(): Promise<IDBDatabase> {
  if (dbPromise) return dbPromise;
  dbPromise = new Promise((resolve, reject) => {
    const req = indexedDB.open(DB_NAME, 1);
    req.onupgradeneeded = () => {
      req.result.createObjectStore(STORE, { keyPath: 'key' });
    };
    req.onsuccess = () => resolve(req.result);
    req.onerror = () => reject(req.error);
  });
  return dbPromise;
}

export async function sha256Hex(input: string | ArrayBuffer): Promise<string> {
  const buf = typeof input === 'string' ? new TextEncoder().encode(input) : input;
  const hash = await crypto.subtle.digest('SHA-256', buf);
  return Array.from(new Uint8Array(hash))
    .map((b) => b.toString(16).padStart(2, '0'))
    .join('');
}

export function cacheKey(contentHash: string, modelId: string, provider: string): string {
  return `${contentHash}:${modelId}:${provider}`;
}

export async function cacheGet(key: string): Promise<ClassificationResult | null> {
  const db = await openDb();
  return new Promise((resolve) => {
    const tx = db.transaction(STORE, 'readonly');
    const req = tx.objectStore(STORE).get(key);
    req.onsuccess = () => {
      const entry = req.result as CacheEntry | undefined;
      if (!entry) return resolve(null);
      if (entry.expiresAt < Date.now()) return resolve(null);
      resolve(entry.result);
    };
    req.onerror = () => resolve(null);
  });
}

export async function cacheSet(key: string, result: ClassificationResult): Promise<void> {
  const db = await openDb();
  return new Promise((resolve) => {
    const tx = db.transaction(STORE, 'readwrite');
    tx.objectStore(STORE).put({ key, result, expiresAt: Date.now() + TTL_MS });
    tx.oncomplete = () => resolve();
    tx.onerror = () => resolve();
  });
}

import { pipeline, type TextClassificationPipeline } from '@huggingface/transformers';

const DEFAULT_TEXT_MODEL = 'Hello-SimpleAI/chatgpt-detector-roberta';

let textClassifier: TextClassificationPipeline | null = null;
let textLoading: Promise<TextClassificationPipeline> | null = null;

export async function ensureTextClassifier(
  modelId = DEFAULT_TEXT_MODEL,
  onProgress?: ProgressCallback,
): Promise<TextClassificationPipeline> {
  if (textClassifier) return textClassifier;
  if (textLoading) return textLoading;

  textLoading = (async () => {
    const pipe = await pipeline('text-classification', modelId, {
      dtype: 'q8',
      device: 'auto',
      progress_callback: (p: any) => {
        if (p.status === 'progress' && typeof p.progress === 'number') {
          onProgress?.({ phase: 'downloading', pct: Math.round(p.progress) });
        }
      },
    });
    textClassifier = pipe as TextClassificationPipeline;
    onProgress?.({ phase: 'ready', pct: 100 });
    return textClassifier;
  })();

  return textLoading;
}

import { ensureTextClassifier } from '@/offscreen/ml-engine';
import type { ClassificationResult } from '@/shared/types';

const MIN_LENGTH = 100;

// Approx token count via 4-char heuristic (good enough for chunking; not exact)
function approxTokens(s: string): number { return Math.ceil(s.length / 4); }

function chunkText(text: string, maxTokens = 512, overlap = 64): string[] {
  if (approxTokens(text) <= maxTokens) return [text];
  const chunkSize = maxTokens * 4;
  const overlapSize = overlap * 4;
  const chunks: string[] = [];
  for (let start = 0; start < text.length; start += (chunkSize - overlapSize)) {
    chunks.push(text.slice(start, start + chunkSize));
    if (start + chunkSize >= text.length) break;
  }
  return chunks;
}

export async function classifyTextLocal(
  text: string,
  threshold: number,
): Promise<ClassificationResult | { tooShort: true }> {
  if (text.trim().length < MIN_LENGTH) return { tooShort: true };

  const t0 = performance.now();
  const pipe = await ensureTextClassifier();
  const chunks = chunkText(text);

  let aiSum = 0;
  let humanSum = 0;
  for (const chunk of chunks) {
    const result = (await pipe(chunk)) as Array<{ label: string; score: number }>;
    for (const r of result) {
      const label = r.label.toLowerCase();
      if (label.includes('ai') || label.includes('chatgpt') || label === 'fake') aiSum += r.score;
      if (label.includes('human') || label === 'real') humanSum += r.score;
    }
  }

  const aiAvg = aiSum / chunks.length;
  const humanAvg = humanSum / chunks.length;

  let label: ClassificationResult['label'];
  let confidence: number;
  if (aiAvg > threshold && aiAvg > humanAvg + 0.10) {
    label = 'ai'; confidence = aiAvg;
  } else if (humanAvg > threshold && humanAvg > aiAvg + 0.10) {
    label = 'real'; confidence = humanAvg;
  } else {
    label = 'uncertain'; confidence = Math.max(aiAvg, humanAvg);
  }

  return {
    label, confidence,
    source: 'local',
    modelId: 'Hello-SimpleAI/chatgpt-detector-roberta',
    rawScores: { ai: aiAvg, human: humanAvg },
    durationMs: performance.now() - t0,
  };
}

export interface ExtensionSettings {
  boostProvider: BoostProvider;
  apiKey: string;
  imageThreshold: number;  // default 0.55
  textThreshold: number;   // default 0.70
  showUncertain: boolean;
  localImageModel: string;
  localTextModel: string;
  // Phase 4 additions:
  fallbackOnBoostFailure: boolean;     // default true
  rateLimitRpm: number;                // default 10
}

// src/detectors/image/gemini.ts
import type { ClassificationResult } from '@/shared/types';

export async function classifyImageGemini(
  apiKey: string,
  dataUrl: string,
): Promise<ClassificationResult> {
  const t0 = performance.now();

  // Strip "data:image/jpeg;base64," prefix
  const [, mimeAndEncoding, base64] = dataUrl.match(/^data:(.+);base64,(.+)$/) || [];
  if (!base64) throw new Error('Invalid data URL');
  const mimeType = mimeAndEncoding?.split(';')[0] ?? 'image/jpeg';

  const url = `https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent?key=${apiKey}`;
  const body = {
    contents: [{
      parts: [
        { text: 'Classify whether this image was generated by AI or is a real photograph. Respond with structured JSON.' },
        { inlineData: { mimeType, data: base64 } },
      ],
    }],
    generationConfig: {
      responseMimeType: 'application/json',
      responseSchema: {
        type: 'object',
        required: ['label', 'confidence', 'reasoning'],
        properties: {
          label: { type: 'string', enum: ['ai', 'real', 'uncertain'] },
          confidence: { type: 'number' },
          reasoning: { type: 'string' },
        },
      },
    },
  };

  const r = await fetch(url, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(body),
  });
  if (!r.ok) throw new Error(`Gemini API ${r.status}: ${await r.text()}`);
  const data = await r.json();
  const text = data?.candidates?.[0]?.content?.parts?.[0]?.text ?? '{}';
  const parsed = JSON.parse(text);

  return {
    label: parsed.label,
    confidence: Math.max(0, Math.min(1, Number(parsed.confidence) || 0)),
    source: 'gemini',
    modelId: 'gemini-2.5-flash',
    reasoning: parsed.reasoning,
    durationMs: performance.now() - t0,
  };
}

import { classifyImageLocal } from './image/local';
import { classifyImageGemini } from './image/gemini';
import { classifyImageOpenAI } from './image/openai';
import { classifyImageHF } from './image/hf';
import type { ClassificationResult, ExtensionSettings } from '@/shared/types';

export async function classifyImage(
  dataUrl: string,
  settings: ExtensionSettings,
  emitToast: (msg: string) => void,
): Promise<ClassificationResult> {
  const useBoost = settings.boostProvider !== 'none' && settings.apiKey;

  if (useBoost) {
    try {
      switch (settings.boostProvider) {
        case 'gemini': return await classifyImageGemini(settings.apiKey, dataUrl);
        case 'openai': return await classifyImageOpenAI(settings.apiKey, dataUrl);
        case 'hf':     return await classifyImageHF(settings.apiKey, dataUrl, settings.localImageModel);
      }
    } catch (err) {
      if (settings.fallbackOnBoostFailure) {
        emitToast(`Boost failed (${humanizeError(err)}) — using local model`);
        return classifyImageLocal(dataUrl, settings.imageThreshold);
      }
      throw err;
    }
  }

  return classifyImageLocal(dataUrl, settings.imageThreshold);
}

class RateLimiter {
  private timestamps: number[] = [];
  constructor(private rpm: number) {}

  async acquire(): Promise<void> {
    const now = Date.now();
    this.timestamps = this.timestamps.filter((t) => now - t < 60_000);
    if (this.timestamps.length >= this.rpm) {
      const waitMs = 60_000 - (now - this.timestamps[0]) + 50;
      await new Promise((r) => setTimeout(r, waitMs));
      return this.acquire();
    }
    this.timestamps.push(now);
  }
}

const limiters: Record<string, RateLimiter> = {};

export async function acquireRateLimit(provider: string, rpm: number): Promise<void> {
  if (!limiters[provider]) limiters[provider] = new RateLimiter(rpm);
  await limiters[provider].acquire();
}

import { vi } from 'vitest';

vi.mock('@huggingface/transformers', () => ({
  pipeline: vi.fn().mockResolvedValue(
    vi.fn().mockResolvedValue([
      { label: 'fake', score: 0.92 },
      { label: 'real', score: 0.08 },
    ]),
  ),
  env: { allowLocalModels: false, allowRemoteModels: true, useBrowserCache: true },
}));

// ❌ ANTI-PATTERN: re-implementing the message bus
chrome.runtime.onMessage.addListener((m: any) => { /* untyped */ });

// ✅ DO: use the typed Message union
chrome.runtime.onMessage.addListener((m: Message, sender, sendResponse) => {
  if (m.type === 'CLASSIFY_IMAGE') { /* ... */ }
});

// ❌ ANTI-PATTERN: per-instance MutationObserver on document.body
new MutationObserver(...).observe(document.body, { childList: true, subtree: true });

// ✅ DO: ONE shared observer in the content-script module

// ❌ ANTI-PATTERN: fall-through types
type Entry = { img: HTMLImageElement | null; ... };
if (!entry.img) { /* it's a text toast */ }

// ✅ DO: discriminated unions
type Entry = { kind: 'image'; img: HTMLImageElement } | { kind: 'text'; toast: HTMLElement };
if (entry.kind === 'text') { /* known text */ }

// ❌ ANTI-PATTERN: pessimistic invalidation
const result = await classify(image); // never cached

// ✅ DO: cache hit → skip inference
const cached = await cacheGet(key);
if (cached) return cached;
const result = await classify(image);
await cacheSet(key, result);
return result;