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 {
  ADMIN_LOGIN_SMOKE_USER_AGENT,
  buildAdminLoginRequest,
  isRejectedLogin,
  isSuccessfulLogin,
} from "../src/steps/smoke";
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("успех определяется конвертом ответа и выданным токеном", () => {
    expect(
      isSuccessfulLogin(
        JSON.stringify({
          code: 20000,
          type: "ok",
          data: { accessToken: "jwt", tokenType: "Bearer" },
        }),
      ),
    ).toBe(true);
    expect(
      isSuccessfulLogin(
        JSON.stringify({ code: 50000, data: { accessToken: "jwt" } }),
      ),
    ).toBe(false);
    expect(
      isSuccessfulLogin(
        JSON.stringify({ code: 20000, data: { accessToken: "" } }),
      ),
    ).toBe(false);
    expect(isSuccessfulLogin("not json")).toBe(false);
  });

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

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

    // Подстановка в 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",
        "request.body",
        "response",
        "body}",
      ]) {
        expect(message).not.toContain(`\${${secret}`);
      }
    }

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

  test("обе пробы используют один wire-helper", () => {
    const source = codeOf(smoke());
    expect(source.match(/requestAdminLogin\(/g)).toHaveLength(3); // два вызова и определение
    const helperStart = source.indexOf("async function requestAdminLogin");
    const helper = source.slice(
      helperStart,
      source.indexOf("type JsonObject", helperStart),
    );
    expect(helperStart).toBeGreaterThan(-1);
    expect(helper.match(/runReadOnlySecret`curl/g)).toHaveLength(1);
  });

  test("wire-тело содержит pass, а не несовместимый alias password", () => {
    const request = buildAdminLoginRequest('admin"name', "pass\\word ");
    expect(JSON.parse(request.body)).toEqual({
      username: 'admin"name',
      pass: "pass\\word ",
    });
    expect(request.body).not.toContain('"password"');
    expect(request.contentType).toBe("application/json");
  });

  test("UA smoke проходит действующее scanner-правило", () => {
    const filter = fs.readFileSync(
      path.join(REPO_ROOT, "apps", "middleware", "filter.go"),
      "utf8",
    );
    const declared = filter.match(/regexp\.MatchString\(`\(\?i\)([^`]+)`/);
    expect(declared).not.toBeNull();
    const scannerPattern = new RegExp(declared![1], "i");

    expect(scannerPattern.test("curl/8.10.1")).toBe(true);
    expect(scannerPattern.test(ADMIN_LOGIN_SMOKE_USER_AGENT)).toBe(false);
    expect(buildAdminLoginRequest("hy2xsadmin", "secret1").userAgent).toBe(
      ADMIN_LOGIN_SMOKE_USER_AGENT,
    );
  });

  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 rejected = {
      code: 50000,
      type: "no",
      errors: [{ code: "invalid_credentials", message: "wrong password" }],
      data: null,
    };
    expect(isRejectedLogin(JSON.stringify(rejected))).toBe(true);
    expect(isRejectedLogin(JSON.stringify({ ...rejected, code: 50001 }))).toBe(
      false,
    );
    expect(
      isRejectedLogin(
        JSON.stringify({ ...rejected, errors: [{ code: "required" }] }),
      ),
    ).toBe(false);
    expect(
      isRejectedLogin(
        JSON.stringify({
          ...rejected,
          data: { accessToken: "unexpected-token" },
        }),
      ),
    ).toBe(false);
    expect(isRejectedLogin(JSON.stringify({ ...rejected, data: { accessToken: "" } }))).toBe(
      false,
    );
    expect(
      isRejectedLogin(
        JSON.stringify({
          code: 50000,
          message: 'fake {"code":"invalid_credentials"}',
          data: null,
        }),
      ),
    ).toBe(false);
    expect(isRejectedLogin("not json")).toBe(false);
  });

  // Доменный код обязан совпадать с тем, который объявляет админка.
  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-");
  });
});