import { describe, expect, test } from "bun:test";
import fs from "node:fs";
import path from "node:path";

import { parseRuntimeEnv } from "../src/config/env";
import {
  ADMIN_LOGIN_PATH,
  ADMIN_PASSWORD_MAX_BYTES,
  ADMIN_PASSWORD_MAX_LENGTH,
  ADMIN_PASSWORD_MIN_LENGTH,
  ADMIN_USERNAME_CHARSET,
  ADMIN_USERNAME_MAX_LENGTH,
  ADMIN_USERNAME_MIN_LENGTH,
  ADMIN_USERNAME_PATTERN,
  isValidAdminPassword
} from "../src/config/profile";
import { baselineConfig, envText } from "./fixtures";

/**
 * Контракт учётных данных администратора на стороне оркестратора.
 *
 * Оркестратор ПОРОЖДАЕТ имя и первый пароль администратора, а принимает их
 * панель — по правилам, которых он раньше не знал вовсе. RC2 показал, чем это
 * заканчивается: установка завершается `INSTALL EXIT CODE: 0`, а войти в панель
 * нельзя. Отказ обязан приходить установщику, которому он чинится одной строкой
 * в hy2xs.env, а не оператору на форме входа, где чинить его уже нечем.
 */

const REPO_ROOT = path.resolve(import.meta.dir, "..", "..");

function goContract(): string {
  return fs.readFileSync(
    path.join(REPO_ROOT, "apps", "credential", "admin.go"),
    "utf8"
  );
}

function goConst(name: string): string {
  const source = goContract();
  const numeric = source.match(new RegExp(`\\b${name}\\s*=\\s*(\\d+)`));
  if (numeric) {
    return numeric[1];
  }
  const backticked = source.match(new RegExp(`\\b${name}\\s*=\\s*\`([^\`]*)\``));
  if (backticked) {
    return backticked[1];
  }
  throw new Error(`константа ${name} не найдена в apps/credential/admin.go`);
}

/**
 * Содержимое файла без комментариев.
 *
 * Проверять положено КОД, а не упоминания: комментарий, объясняющий, почему
 * убранной конструкции здесь больше нет, обязан называть её по имени, иначе он
 * бесполезен, — и проверка «такой конструкции в файле нет» начинает падать
 * ровно на той документации, которая описывает выполненную ею же работу.
 */
function codeOf(source: string): string {
  return source
    .split("\n")
    .filter((line) => !/^\s*(\/\/|\/?\*)/.test(line))
    .join("\n");
}

describe("контракт учётных данных совпадает с админкой", () => {
  // Копия контракта в TypeScript неизбежна: оркестратор собирается отдельно от
  // Go-бинарника и импортировать его константы не может. Проверяется поэтому
  // не отсутствие копии, а её совпадение с оригиналом — сверкой по исходнику.
  test("границы совпадают с credential.Admin*", () => {
    expect(String(ADMIN_USERNAME_MIN_LENGTH)).toBe(goConst("AdminUsernameMinLength"));
    expect(String(ADMIN_USERNAME_MAX_LENGTH)).toBe(goConst("AdminUsernameMaxLength"));
    expect(String(ADMIN_PASSWORD_MIN_LENGTH)).toBe(goConst("AdminPasswordMinLength"));
    expect(String(ADMIN_PASSWORD_MAX_LENGTH)).toBe(goConst("AdminPasswordMaxLength"));
    // Предел bcrypt — ОТДЕЛЬНАЯ константа и отдельная сверка: пока его тут не
    // было, оркестратор пропускал в hy2xs.env пароль, который админка не могла
    // захешировать, и установка заканчивалась сервером без администратора.
    expect(String(ADMIN_PASSWORD_MAX_BYTES)).toBe(goConst("AdminPasswordMaxBytes"));
  });

  test("набор символов логина совпадает с классом из Go", () => {
    // Класс сравнивается как ЗНАЧЕНИЕ строки, а не как запись: в Go он живёт в
    // raw-строке, в TypeScript — в обычной, где обратный слеш удваивается.
    const declared = goConst("adminUsernameCharacterClass");
    const mirrored = ADMIN_USERNAME_PATTERN.source.replace(
      new RegExp(`^\\^\\[|\\]\\{${ADMIN_USERNAME_MIN_LENGTH},${ADMIN_USERNAME_MAX_LENGTH}\\}\\$$`, "g"),
      ""
    );
    expect(mirrored).toBe(declared);
  });

  test("человекочитаемый набор совпадает с показываемым админкой", () => {
    expect(ADMIN_USERNAME_CHARSET).toBe(goConst("AdminUsernameCharset"));
  });

  // Дефис в классе символов ЭКРАНИРОВАН. Без экранирования `+-=` образует
  // диапазон и молча впускает `, - . / 0-9 : ; < =` — ровно тот дефект, из-за
  // которого фактическое множество разошлось с задуманным на всех четырёх
  // сторонах продукта.
  test("дефис в классе экранирован, а не образует диапазон", () => {
    expect(ADMIN_USERNAME_PATTERN.source).toContain("\\-");
    expect(ADMIN_USERNAME_PATTERN.source).not.toContain("+-=");
  });

  test("путь формы входа собран из базового пространства имён API", () => {
    expect(ADMIN_LOGIN_PATH).toBe("/api/auth/login");

    const router = fs.readFileSync(path.join(REPO_ROOT, "apps", "router", "auth.go"), "utf8");
    expect(router).toContain('auth.POST("/login"');
    expect(router).toContain('authApi.Group("/auth")');
  });
});

describe("HY2XS_ADMIN_USER проверяется при разборе окружения", () => {
  test("значение по умолчанию проходит контракт панели", () => {
    const config = parseRuntimeEnv(envText({ HY2XS_ADMIN_USER: null }));
    expect(config.adminUser).toBe("hy2xsadmin");
    expect(ADMIN_USERNAME_PATTERN.test(config.adminUser)).toBe(true);
  });

  // Регрессия: умолчанием здесь стояло `admin` — пять символов при минимуме в
  // шесть. Установка проходила целиком, а панель не впускала никого.
  test("значение по умолчанию не короче минимума", () => {
    const config = parseRuntimeEnv(envText({ HY2XS_ADMIN_USER: null }));
    expect(config.adminUser.length).toBeGreaterThanOrEqual(ADMIN_USERNAME_MIN_LENGTH);
  });

  // Умолчание обязано совпадать с запасным значением админки: иначе установка
  // без явного HY2XS_ADMIN_USER создаёт одну учётную запись, а админка при
  // повреждённом окружении ищет другую.
  test("умолчание совпадает с запасным значением админки и с packaged env", () => {
    const dao = fs.readFileSync(path.join(REPO_ROOT, "apps", "dao", "sqlite.go"), "utf8");
    expect(dao).toContain('adminUser = "hy2xsadmin"');

    const packaged = fs.readFileSync(
      path.join(REPO_ROOT, "package", "config", "hy2xs.env"),
      "utf8"
    );
    expect(packaged).toContain("HY2XS_ADMIN_USER=hy2xsadmin");
  });

  test("слишком короткий логин роняет установку", () => {
    expect(() => baselineConfig({ HY2XS_ADMIN_USER: "admin" })).toThrow(
      /invalid HY2XS_ADMIN_USER/
    );
  });

  test("слишком длинный логин роняет установку", () => {
    expect(() =>
      baselineConfig({ HY2XS_ADMIN_USER: "a".repeat(ADMIN_USERNAME_MAX_LENGTH + 1) })
    ).toThrow(/invalid HY2XS_ADMIN_USER/);
  });

  test("логин с пробелом, кириллицей или переводом строки роняет установку", () => {
    for (const rejected of ["hy2xs admin", "админ12", "hy2xs\tadmin"]) {
      expect(() => baselineConfig({ HY2XS_ADMIN_USER: rejected })).toThrow(
        /invalid HY2XS_ADMIN_USER/
      );
    }
  });

  test("отказ называет и границы, и набор символов", () => {
    expect(() => baselineConfig({ HY2XS_ADMIN_USER: "admin" })).toThrow(
      new RegExp(`${ADMIN_USERNAME_MIN_LENGTH}.*${ADMIN_USERNAME_MAX_LENGTH}`)
    );
    expect(() => baselineConfig({ HY2XS_ADMIN_USER: "admin" })).toThrow(/a-z A-Z 0-9/);
  });

  // Значение уезжает в hy2xs.env и оттуда в базу. Пробел по краям превращался
  // бы в часть имени учётной записи, и вход отказывал бы «неверным логином» —
  // отказом, который невозможно связать с причиной.
  test("окружающие пробелы снимаются, а не уезжают в имя учётной записи", () => {
    expect(baselineConfig({ HY2XS_ADMIN_USER: "  hy2xsadmin  " }).adminUser).toBe("hy2xsadmin");
  });

  test("точка в логине принимается: набор не сужается задним числом", () => {
    expect(baselineConfig({ HY2XS_ADMIN_USER: "admin.ops" }).adminUser).toBe("admin.ops");
  });
});

describe("HY2XS_ADMIN_INITIAL_PASSWORD проверяется при разборе окружения", () => {
  test("сгенерированный пароль проходит контракт панели", () => {
    for (const raw of ["", "__GENERATE__"]) {
      const config = parseRuntimeEnv(envText({ HY2XS_ADMIN_INITIAL_PASSWORD: raw }));
      const length = [...config.adminInitialPassword].length;
      expect(length).toBeGreaterThanOrEqual(ADMIN_PASSWORD_MIN_LENGTH);
      expect(length).toBeLessThanOrEqual(ADMIN_PASSWORD_MAX_LENGTH);
    }
  });

  test("слишком короткий пароль роняет установку", () => {
    expect(() => baselineConfig({ HY2XS_ADMIN_INITIAL_PASSWORD: "12345" })).toThrow(
      /invalid HY2XS_ADMIN_INITIAL_PASSWORD/
    );
  });

  test("слишком длинный пароль роняет установку", () => {
    expect(() =>
      baselineConfig({
        HY2XS_ADMIN_INITIAL_PASSWORD: "a".repeat(ADMIN_PASSWORD_MAX_LENGTH + 1)
      })
    ).toThrow(/invalid HY2XS_ADMIN_INITIAL_PASSWORD/);
  });

  // Набор символов пароля сервером не ограничивается, и оркестратор не имеет
  // права быть строже: отвергнутый здесь пароль сервер принял бы.
  test("пароль из произвольных символов принимается", () => {
    for (const password of ["p@ssw0rd?!", "пароль-администратора", "a b c d e f"]) {
      expect(baselineConfig({ HY2XS_ADMIN_INITIAL_PASSWORD: password }).adminInitialPassword).toBe(
        password
      );
    }
  });

  // Границ ДВЕ, и они в разных единицах.
  //
  // Здесь стоял тест «длина считается в символах, а не в байтах», требовавший
  // приёма 64 кириллических букв. Он закреплял как ожидаемое ровно то значение,
  // на котором продукт ломался: 64 символа — это 128 байт, а
  // bcrypt.GenerateFromPassword отвечает ErrPasswordTooLong строго при длине
  // больше 72 байт. Установка проходила целиком, а первая учётная запись
  // администратора не создавалась вовсе.
  //
  // Длина по-прежнему считается в СИМВОЛАХ — иначе оркестратор был бы строже
  // панели, — но байтовая граница существует одновременно с ней.
  test("границы пароля проверяются и в символах, и в байтах", () => {
    // Проверка самой таблицы: если «я» перестанет быть двухбайтовой, случаи
    // ниже проверяли бы не то, что написано.
    expect(Buffer.byteLength("я".repeat(36), "utf8")).toBe(ADMIN_PASSWORD_MAX_BYTES);
    expect(Buffer.byteLength("😀".repeat(18), "utf8")).toBe(ADMIN_PASSWORD_MAX_BYTES);

    const accepted = [
      "a".repeat(ADMIN_PASSWORD_MIN_LENGTH),
      "a".repeat(ADMIN_PASSWORD_MAX_LENGTH),
      "я".repeat(36),
      "😀".repeat(18),
      "abcde ",
      " ".repeat(ADMIN_PASSWORD_MIN_LENGTH)
    ];
    for (const password of accepted) {
      expect(isValidAdminPassword(password)).toBe(true);
      expect(baselineConfig({ HY2XS_ADMIN_INITIAL_PASSWORD: `"${password}"` }).adminInitialPassword).toBe(
        password
      );
    }

    const rejected = [
      "a".repeat(ADMIN_PASSWORD_MIN_LENGTH - 1),
      "a".repeat(ADMIN_PASSWORD_MAX_LENGTH + 1),
      "я".repeat(37),
      "😀".repeat(19),
      "я".repeat(ADMIN_PASSWORD_MAX_LENGTH)
    ];
    for (const password of rejected) {
      expect(isValidAdminPassword(password)).toBe(false);
      expect(() => baselineConfig({ HY2XS_ADMIN_INITIAL_PASSWORD: `"${password}"` })).toThrow(
        /invalid HY2XS_ADMIN_INITIAL_PASSWORD/
      );
    }
  });

  // Отказ обязан НАЗЫВАТЬ обе границы: пароль из 40 эмодзи укладывается в 64
  // символа и не укладывается в 72 байта, и сообщение «не длиннее 64 символов»
  // отправило бы оператора сокращать пароль, отвергнутый не за это.
  test("отказ называет и символы, и байты", () => {
    const tooManyBytes = `"${"я".repeat(ADMIN_PASSWORD_MAX_LENGTH)}"`;
    expect(() => baselineConfig({ HY2XS_ADMIN_INITIAL_PASSWORD: tooManyBytes })).toThrow(
      new RegExp(`${ADMIN_PASSWORD_MAX_BYTES} байт`)
    );
    expect(() => baselineConfig({ HY2XS_ADMIN_INITIAL_PASSWORD: tooManyBytes })).toThrow(
      new RegExp(`${ADMIN_PASSWORD_MIN_LENGTH}.*${ADMIN_PASSWORD_MAX_LENGTH}`)
    );
  });

  // Управляющий символ отвергается контрактом, а не теряется транспортом.
  test("управляющий символ в пароле роняет установку", () => {
    expect(isValidAdminPassword("abcde\n")).toBe(false);
    expect(isValidAdminPassword("abcde\t")).toBe(false);
  });

  // Сгенерированный пароль обязан проходить контракт ЦЕЛИКОМ, включая байты:
  // генератор — такой же источник значения, как и оператор.
  test("сгенерированный пароль проходит контракт целиком", () => {
    for (let i = 0; i < 50; i += 1) {
      const config = parseRuntimeEnv(envText({ HY2XS_ADMIN_INITIAL_PASSWORD: "__GENERATE__" }));
      expect(isValidAdminPassword(config.adminInitialPassword)).toBe(true);
    }
  });
});

describe("smoke выполняет настоящий вход в панель", () => {
  const smoke = () =>
    fs.readFileSync(path.join(REPO_ROOT, "orchestrator", "src", "steps", "smoke.ts"), "utf8");

  // Главный барьер этого релиза. Пока установка отвечала на вопрос «работает ли
  // панель» только фактом LISTEN и ответом /healthz, RC2 объявлял успешной
  // установку с полностью недоступной панелью.
  test("smoke обращается к форме входа, а не только к healthz", () => {
    const source = smoke();
    expect(source).toContain("ADMIN_LOGIN_PATH");
    expect(source).toContain("assertAdminLoginWorks");
    expect(source).toContain("isSuccessfulLogin");
  });

  test("успех определяется конвертом ответа и выданным токеном", () => {
    // Админка отвечает HTTP 200 и на отказ: проверка по коду HTTP приняла бы за
    // успешный вход любой отказ.
    const source = smoke();
    expect(source).toMatch(/"code"\\s\*:\\s\*20000/);
    expect(source).toMatch(/accessToken/);
  });

  test("учётные данные не попадают ни в команду ошибки, ни в сообщение", () => {
    const source = smoke();
    const start = source.indexOf("async function assertAdminLoginWorks");
    expect(start).toBeGreaterThan(-1);
    const body = source.slice(start, source.indexOf("\nfunction isSuccessfulLogin"));

    // runReadOnly (без Secret) кладёт команду в текст ошибки, а команда несёт
    // пароль администратора.
    expect(body).not.toMatch(/(?<!Secret)runReadOnly`/);
    expect(body).toMatch(/runReadOnlySecret`/);

    // Подстановка в tagged template — это НЕ утечка: значения там проходят
    // через shellQuote и в текст ошибки не попадают. Утечкой была бы подстановка
    // секрета в сообщение — в info() или в new Error(), — потому что оно уезжает
    // в журнал установки и в diagnostics-бандл.
    const messages = [
      ...body.matchAll(/\binfo\(([\s\S]*?)\);/g),
      ...body.matchAll(/new Error\(([\s\S]*?)\);/g)
    ].map((match) => match[1]);
    expect(messages.length).toBeGreaterThan(0);

    for (const message of messages) {
      for (const secret of ["adminPassword", "payload", "response", "body}"]) {
        expect(message).not.toContain(`\${${secret}`);
      }
    }

    // Тело успешного ответа несёт токен доступа, поэтому наружу отдаётся только
    // разбор ответа, а не он сам.
    expect(body).toContain("describeLoginFailure(body, error)");
    expect(body).toContain("describeIssuedToken(response)");
  });

  test("тело запроса собирается JSON.stringify, а не интерполяцией", () => {
    // Пароль задаёт оператор: кавычка или обратный слеш в нём сломали бы сам
    // запрос, и проверка объявила бы рабочую установку сломанной.
    const body = smoke();
    expect(body).toContain("JSON.stringify({ username: adminUser, pass: adminPassword })");
  });

  test("отрицательная проба не зависит от режима операции", () => {
    // Пароль в bootstrap-admin.secret устаревает в момент, когда оператор сменил
    // его в панели, поэтому положительная проба install-only. Отрицательная от
    // пароля не зависит и обязана работать всегда: именно она воспроизводит
    // дефект RC2.
    const source = smoke();
    const start = source.indexOf("async function assertAdminLoginWorks");
    const body = source.slice(start, source.indexOf("\nfunction isSuccessfulLogin"));

    const rejected = body.indexOf("admin login rejects wrong credentials");
    const modeGate = body.indexOf('context.mode !== "install"');
    expect(rejected).toBeGreaterThan(-1);
    expect(modeGate).toBeGreaterThan(rejected);
  });

  // Отрицательная проба обязана доказывать ОТКАЗ.
  //
  // Она проверяла `code.trim() === "200"`, то есть ровно одно: что запрос не
  // закончился пятисоткой. Админка отвечает HTTP 200 и на успешный вход тоже,
  // поэтому «неверные учётные данные отвергнуты» этой проверкой не следовало.
  test("отрицательная проба сверяет конверт отказа, а не код HTTP", () => {
    const source = smoke();

    expect(source).toContain("isRejectedLogin");
    // Код конверта отказа, доменная причина и ОТСУТСТВИЕ токена — три признака,
    // и каждый закрывает свой способ ошибиться.
    expect(source).toMatch(/"code"\\s\*:\\s\*50000/);
    expect(source).toContain('INVALID_CREDENTIALS_CODE = "invalid_credentials"');

    const start = source.indexOf("function isRejectedLogin");
    const body = source.slice(start, source.indexOf("\n/**", start));
    expect(body).toContain("!/\"accessToken\"");
  });

  // Доменный код обязан совпадать с тем, который объявляет админка.
  test("код причины отказа совпадает с constant.ErrCodeInvalidCredentials", () => {
    const goErrors = fs.readFileSync(
      path.join(REPO_ROOT, "apps", "model", "constant", "error.go"),
      "utf8"
    );
    const declared = goErrors.match(/ErrCodeInvalidCredentials\s+string\s*=\s*"([^"]+)"/);
    expect(declared).not.toBeNull();
    expect(smoke()).toContain(`INVALID_CREDENTIALS_CODE = "${declared![1]}"`);
  });

  // Пароль отрицательной пробы не имеет права быть литералом: записанное в
  // исходнике значение теоретически может оказаться настоящим паролем, и тогда
  // проверка «неверные данные отвергаются» отчиталась бы об успешном ВХОДЕ.
  test("пароль отрицательной пробы генерируется, а не записан в исходнике", () => {
    const source = smoke();
    // Считается КОД, а не упоминания: комментарий, объясняющий, почему прежнего
    // литерала здесь больше нет, обязан называть его по имени — иначе он
    // бесполезен. Тот же урок уже записан в code_without_comments в
    // acceptance.sh и в codeOf во frontend-contract.test.ts.
    expect(codeOf(source)).not.toContain("definitely-not-the-admin-password");
    expect(source).toContain('randomBytes(24).toString("base64url")');
    expect(source).toContain("negative login probe accidentally used the real admin password");
  });

  // Bootstrap-секрет читается ПАРСЕРОМ того же формата, которым он написан.
  //
  // Прежнее `grep … | cut -d= -f2-` с `.trim()` было третьим по счёту слоем,
  // срезающим краевые пробелы у пароля, набор символов которого объявлен
  // неограниченным: положительная проба брала не тот пароль и объявляла бы
  // рабочую установку сломанной.
  test("bootstrap-секрет читается парсером формата, а не шелл-конвейером", () => {
    const source = smoke();

    expect(source).toContain("readBootstrapAdminSecret");
    expect(source).toContain("parseEnvFile(await readText(context.config.bootstrapAdminSecretPath))");

    // Извлечения значения шеллом не остаётся ни одного. Проверки НАЛИЧИЯ
    // ключей (`grep -q '^ADMIN_USER='`) при этом законны и остаются: они
    // отвечают на другой вопрос — цел ли файл, — и значения не читают.
    expect(codeOf(source)).not.toContain("cut -d= -f2-");
  });
});