import fs from "node:fs";
import path from "node:path";
import { fileURLToPath } from "node:url";

const __dirname = path.dirname(fileURLToPath(import.meta.url));
const manifestPath = path.join(__dirname, "benchlocal.pack.json");
const scenariosPath = path.join(__dirname, "scenarios.json");

export const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));

function loadScenarios() {
  return JSON.parse(fs.readFileSync(scenariosPath, "utf8"));
}

export function listScenarios() {
  return loadScenarios().map(s => ({
    id: s.id,
    name: s.name,
    category: s.category || "Общие",
    description: s.name
  }));
}

export function getScenarios() {
  return listScenarios();
}

/**
 * Нормализация букв-омоглифов (защита от различий раскладки А/A, В/B, С/C, Е/E, Н/H, Р/P, Х/X)
 */
function normalizeScriptChar(char) {
  const c = String(char || "").trim().toUpperCase();
  const map = { "A": "А", "B": "В", "C": "С", "E": "Е", "H": "Н", "P": "Р", "X": "Х" };
  return map[c] || c;
}

/**
 * Детектор макро-зацикливаний (период блока от 25 до 250 слов)
 */
function detectMacroLoop(text) {
  const words = (text.toLowerCase().match(/[\p{L}\p{N}'-]+/gu) || []);
  const n = words.length;
  if (n < 50) return { isLoop: false };

  const maxL = Math.min(250, Math.floor(n / 2));
  for (let L = 25; L <= maxL; L += 5) {
    const step = Math.max(1, Math.floor(L / 4));
    for (let i = 0; i <= n - 2 * L; i += step) {
      let matches = 0;
      for (let j = 0; j < L; j++) {
        if (words[i + j] === words[i + L + j]) {
          matches++;
        }
      }
      const similarity = matches / L;
      if (similarity >= 0.85) {
        const sample = words.slice(i, i + Math.min(12, L)).join(" ");
        return {
          isLoop: true,
          reason: `Макро-петля: повторяющийся блок ~${L} слов (${Math.round(similarity * 100)}% совпадения): '${sample}...'`
        };
      }
    }
  }

  const paragraphs = text
    .split(/\n+/)
    .map(p => p.trim().toLowerCase())
    .filter(p => p.split(/\s+/).length >= 15);

  for (let i = 0; i < paragraphs.length - 1; i++) {
    if (paragraphs[i] === paragraphs[i + 1]) {
      return {
        isLoop: true,
        reason: `Повтор целого абзаца подряд: '${paragraphs[i].slice(0, 50)}...'`
      };
    }
  }

  return { isLoop: false };
}

/**
 * Детектор микро-зацикливаний (слова, биграммы, короткие фразы)
 */
function detectMicroLoop(text, finishReason) {
  const words = (text.toLowerCase().match(/[\p{L}\p{N}'-]+/gu) || []);
  if (words.length < 5) return { isLoop: false };

  for (let i = 0; i <= words.length - 5; i++) {
    const w = words[i];
    if (words[i + 1] === w && words[i + 2] === w && words[i + 3] === w && words[i + 4] === w) {
      return { isLoop: true, reason: `Повтор слова 5+ раз подряд: '${w}'` };
    }
  }

  for (let i = 0; i <= words.length - 8; i++) {
    if (
      words[i] === words[i + 2] && words[i + 1] === words[i + 3] &&
      words[i] === words[i + 4] && words[i + 1] === words[i + 5] &&
      words[i] === words[i + 6] && words[i + 1] === words[i + 7]
    ) {
      return { isLoop: true, reason: `Тандемный повтор пары слов: '${words[i]} ${words[i + 1]}'` };
    }
  }

  const maxK = Math.min(20, Math.floor(words.length / 3));
  for (let k = 3; k <= maxK; k++) {
    for (let i = 0; i <= words.length - 3 * k; i++) {
      let isMatch = true;
      for (let j = 0; j < k; j++) {
        if (words[i + j] !== words[i + k + j] || words[i + j] !== words[i + 2 * k + j]) {
          isMatch = false;
          break;
        }
      }
      if (isMatch) {
        const sample = words.slice(i, i + Math.min(k, 6)).join(" ");
        return { isLoop: true, reason: `Тандемный повтор фразы из ${k} слов: '${sample}...'` };
      }
    }
  }

  if (finishReason === "length" && words.length >= 20) {
    const tail = words.slice(-20);
    const tailBigrams = new Set();
    for (let i = 0; i < tail.length - 1; i++) {
      tailBigrams.add(`${tail[i]}_${tail[i + 1]}`);
    }
    if (tailBigrams.size <= 4) {
      return { isLoop: true, reason: "Аварийное зацикливание хвоста при исчерпании лимита токенов" };
    }
  }

  return { isLoop: false };
}

/**
 * Валидатор Категории 1: Распознавание смыслового зацикливания (Строгая бинарная оценка)
 */
function validateCategory1(scenario, rawText) {
  const text = (rawText || "").trim();
  if (!text) {
    return { pass: false, reason: "Пустой ответ от модели" };
  }

  const pattern = /(?:мой\s+ответ|my\s+answer)\s*:\s*\(\s*([12])\s*\)\s*\(\s*([А-ЯA-Zа-яa-z])\s*\)/i;
  const match = text.match(pattern);

  if (!match) {
    return {
      pass: false,
      reason: `Не соблюден формат ответа. Ожидалось: 'Мой ответ: (1/2) (Буква)', получено: '${text.slice(0, 60)}...'`
    };
  }

  const actualBinary = match[1];
  const actualLetterNorm = normalizeScriptChar(match[2]);

  const expectedBinary = String(scenario.expectedBinary);
  const expectedLetterNorm = normalizeScriptChar(scenario.expectedLetter);

  // СТРОГАЯ БИНАРНАЯ ПРОВЕРКА: Либо верны оба пункта (100), либо провал (0)
  if (actualBinary !== expectedBinary || actualLetterNorm !== expectedLetterNorm) {
    const verdictName = actualBinary === "1" ? "Да" : "Нет";
    const expVerdictName = expectedBinary === "1" ? "Да" : "Нет";
    return {
      pass: false,
      reason: `Задание не выполнено. Получено: (${actualBinary} - ${verdictName}) (${match[2].toUpperCase()}), ожидалось: (${expectedBinary} - ${expVerdictName}) (${scenario.expectedLetter})`
    };
  }

  return { pass: true, reason: `Задание выполнено полностью: зацикливание и количество (${expectedBinary}) (${scenario.expectedLetter}) определены верно` };
}

/**
 * Валидатор Категории 2: Массовая генерация 100 элементов
 */
function validateCategory2(scenario, rawText, finishReason) {
  const text = (rawText || "").trim();
  if (!text) {
    return { pass: false, reason: "Пустой ответ от модели" };
  }

  const lines = text.split(/\n+/).map(l => l.trim()).filter(Boolean);
  const items = [];

  for (const line of lines) {
    const m = line.match(/^(?:\d+[\.\)]|\-\s*|\*\s*)(.+)$/);
    if (m) {
      items.push(m[1].trim().toLowerCase());
    }
  }

  const finalItems = items.length >= 40 ? items : lines.map(l => l.toLowerCase());

  // 1. Повтор одного пункта 4+ раза подряд
  for (let i = 0; i <= finalItems.length - 4; i++) {
    if (
      finalItems[i] === finalItems[i + 1] &&
      finalItems[i] === finalItems[i + 2] &&
      finalItems[i] === finalItems[i + 3]
    ) {
      return {
        pass: false,
        reason: `[LOOP DETECTED] Непрерывный повтор одного пункта 4+ раза подряд: '${finalItems[i].slice(0, 40)}...'`
      };
    }
  }

  // 2. Чередование пары пунктов ((A B) (A B) (A B))
  for (let i = 0; i <= finalItems.length - 6; i++) {
    if (
      finalItems[i] === finalItems[i + 2] && finalItems[i] === finalItems[i + 4] &&
      finalItems[i + 1] === finalItems[i + 3] && finalItems[i + 1] === finalItems[i + 5]
    ) {
      return {
        pass: false,
        reason: `[LOOP DETECTED] Циклическое чередование пунктов: '${finalItems[i].slice(0, 25)}' / '${finalItems[i + 1].slice(0, 25)}'`
      };
    }
  }

  // 3. Коллапс разнообразия (> 35% дубликатов по всему списку)
  if (finalItems.length >= 40) {
    const unique = new Set(finalItems);
    const dupRatio = (finalItems.length - unique.size) / finalItems.length;
    if (dupRatio > 0.35) {
      return {
        pass: false,
        reason: `[LOOP DETECTED] Коллапс генератора: ${Math.round(dupRatio * 100)}% пунктов списка являются дубликатами`
      };
    }
  }

  // 4. Обрыв по лимиту длины
  if (finishReason === "length") {
    return {
      pass: false,
      reason: `Генерация оборвалась по лимиту длины (успела выдать ${finalItems.length} пунктов). Декодер ушел в бесконечную петлю.`
    };
  }

  // 5. Полнота объема (допуск от 75 пунктов)
  if (finalItems.length < 75) {
    return {
      pass: false,
      reason: `Сгенерировано слишком мало пунктов (${finalItems.length} из 100 требуемых).`
    };
  }

  return { pass: true, reason: `Успешно: сгенерировано ${finalItems.length} уникальных пунктов без зацикливаний` };
}

/**
 * Валидатор Категории 3: Рекурсивные правила и парадоксы
 */
function validateCategory3(scenario, rawText, finishReason) {
  const text = (rawText || "").trim();
  const words = text.split(/\s+/).filter(Boolean);

  if (words.length === 0) {
    return { pass: false, reason: "Отказ генерации: модель не вернула текста (зависание или сбой декодера)" };
  }

  if (words.length < 10) {
    return {
      pass: false,
      reason: `Нарушено условие минимального объема: ответ содержит всего ${words.length} слов (требуется >= 10 слов)`
    };
  }

  const micro = detectMicroLoop(text, finishReason);
  if (micro.isLoop) {
    return { pass: false, reason: `[LOOP DETECTED] ${micro.reason}` };
  }

  const macro = detectMacroLoop(text);
  if (macro.isLoop) {
    return { pass: false, reason: `[LOOP DETECTED] ${macro.reason}` };
  }

  if (finishReason === "length") {
    return { pass: false, reason: "Модель исчерпала лимит токенов в попытке распутать рекурсивный дедлок" };
  }

  return { pass: true, reason: "Успешно: модель справилась с задачей без впадения в петлю генерации" };
}

function validateResponse(scenario, rawText, finishReason) {
  if (scenario.category === "Определение зацикливания") {
    return validateCategory1(scenario, rawText);
  }
  if (scenario.category === "Массовая генерация (100 элементов)") {
    return validateCategory2(scenario, rawText, finishReason);
  }
  if (scenario.category === "Рекурсивные правила и парадоксы") {
    return validateCategory3(scenario, rawText, finishReason);
  }
  return { pass: false, reason: "Неизвестная категория сценария" };
}

function resolveHelpers(context) {
  if (context && typeof context.getRequiredProvider === "function") {
    return context;
  }
  if (context?.helpers && typeof context.helpers.getRequiredProvider === "function") {
    return context.helpers;
  }
  return {
    getRequiredProvider(providerId) {
      const providers = context?.providers || [];
      const found = Array.isArray(providers)
        ? providers.find((p) => p.id === providerId || p.provider === providerId)
        : providers[providerId];
      return found || { baseUrl: "http://127.0.0.1:11434/v1", apiKey: "none" };
    },
    getInferenceEndpoint(modelId) {
      return context?.endpoints?.[modelId] || null;
    }
  };
}

export async function prepare(context) {
  const helpers = resolveHelpers(context);

  return {
    async runScenario(input) {
      const allScenarios = loadScenarios();
      const scenario = allScenarios.find(s => s.id === input.scenario.id);
      if (!scenario) {
        return {
          scenarioId: input.scenario.id,
          status: "fail",
          score: 0,
          summary: "Сценарий не найден",
          rawLog: "error=Scenario not found"
        };
      }

      const provider = helpers.getRequiredProvider(input.model.provider, { enabledOnly: true });
      const inference = helpers.getInferenceEndpoint ? helpers.getInferenceEndpoint(input.model.id) : null;

      const rawBaseUrl = (inference && inference.status === "running" ? inference.baseUrl : provider?.baseUrl) || "http://127.0.0.1:11434/v1";
      const baseUrl = rawBaseUrl.replace(/\/+$/, "");
      const apiKey = provider?.apiKey || "none";

      const requestBody = {
        model: input.model.model,
        messages: [{ role: "user", content: scenario.prompt }],
        temperature: 0
      };

      const response = await fetch(`${baseUrl}/chat/completions`, {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          Authorization: `Bearer ${apiKey}`
        },
        body: JSON.stringify(requestBody)
      });

      const data = await response.json();
      const text = (data.choices?.[0]?.message?.content || "").trim();
      const finishReason = data.choices?.[0]?.finish_reason || "stop";
      const result = validateResponse(scenario, text, finishReason);

      const rawLog = [
        `model=${input.model.model}`,
        `scenario=${scenario.id} ${scenario.name}`,
        `category=${scenario.category}`,
        `finish_reason=${finishReason}`,
        `user_turn_1=${scenario.prompt}`,
        `assistant_turn_1=${text}`,
        `final_answer=${text}`,
        `verdict=${result.pass ? "pass" : "fail"}`,
        `score=${result.pass ? 100 : 0}`,
        `summary=${result.reason}`,
        `\n--- RAW API RESPONSE ---`,
        JSON.stringify(data, null, 2)
      ].join("\n");

      return {
        scenarioId: scenario.id,
        status: result.pass ? "pass" : "fail",
        score: result.pass ? 100 : 0,
        summary: result.reason,
        rawLog: rawLog
      };
    },

    async dispose() {}
  };
}

export function scoreModelResults(results) {
  const scored = results || [];
  const total = scored.reduce((sum, r) => sum + (r.score || 0), 0);
  const max = scored.length * 100;

  const scenarios = loadScenarios();
  const categoryMap = new Map();

  for (const r of scored) {
    const sc = scenarios.find(s => s.id === r.scenarioId);
    const cat = sc?.category || "Общие";
    if (!categoryMap.has(cat)) {
      categoryMap.set(cat, { total: 0, count: 0 });
    }
    const cur = categoryMap.get(cat);
    cur.total += r.score || 0;
    cur.count += 1;
  }

  const categories = Array.from(categoryMap.entries()).map(([name, data]) => ({
    name,
    score: data.count > 0 ? Math.round(data.total / data.count) : 0
  }));

  return {
    totalScore: max > 0 ? Math.round((total / max) * 100) : 0,
    categories
  };
}

export default {
  manifest,
  listScenarios,
  getScenarios,
  prepare,
  createRuntime: prepare,
  scoreModelResults
};