import {expect, test} from 'bun:test';
import fs from 'node:fs';
import path from 'node:path';
import {ALL_HOST_CONFIGS} from '../hosts';
import {HOST_PATHS, type TemplateContext} from '../scripts/resolvers/types';
import {generatePreamble} from '../scripts/resolvers/preamble';
import {generateBaseBranchDetect} from '../scripts/resolvers/utility';
import {E2E_TOUCHFILES, LLM_JUDGE_TOUCHFILES, selectTests} from './helpers/touchfiles';
import failedScopes from './fixtures/design-scope-checkpoint-at.json';
import {nativeSeededPlanSelection} from './helpers/plan-scope-selection';
import {isScopeGateAutoSelectVisible} from './helpers/claude-pty-runner';

const template = fs.readFileSync(path.join(import.meta.dir, '../plan-design-review/SKILL.md.tmpl'), 'utf8');
const scope = template.slice(template.indexOf('## Scope gate'), template.indexOf('## Design Philosophy'));
const announcement = 'Scope gate: plan mode — auto-selected B (reviewing <target>).';

test('Design resolves scope before either executable bootstrap placeholder', () => {
  const gate = template.indexOf('## Scope gate');
  expect(gate).toBeGreaterThan(0);
  for (const token of ['{{PREAMBLE}}', '{{BASE_BRANCH_DETECT}}']) {
    expect(template.split(token)).toHaveLength(2);
    expect(template.indexOf(announcement)).toBeLessThan(template.indexOf(token));
    expect(template.indexOf('Reply with A, B, or C. STOP and wait')).toBeLessThan(template.indexOf(token));
  }
  expect(template.indexOf('{{PREAMBLE}}')).toBeLessThan(template.indexOf('{{BASE_BRANCH_DETECT}}'));
  expect(template.indexOf('{{BASE_BRANCH_DETECT}}')).toBeLessThan(template.indexOf('## Design Philosophy'));
});

test('every host expands its real bootstrap after the mandatory entry gate', () => {
  for (const host of ALL_HOST_CONFIGS) {
    const ctx: TemplateContext = {skillName: 'plan-design-review', tmplPath: 'plan-design-review/SKILL.md.tmpl',
      host: host.name, paths: HOST_PATHS[host.name]!, preambleTier: 3, interactive: true};
    const preamble = generatePreamble(ctx);
    const brain = host.suppressedResolvers?.includes('BASE_BRANCH_DETECT') ? '' : generateBaseBranchDetect(ctx);
    const expanded = template.replace('{{PREAMBLE}}', preamble).replace('{{BASE_BRANCH_DETECT}}', brain);
    expect(expanded.indexOf(announcement)).toBeLessThan(expanded.indexOf('## Preamble (after scope gate)'));
    expect(expanded.indexOf('Reply with A, B, or C. STOP and wait')).toBeLessThan(expanded.indexOf('```bash'));
    expect(expanded.indexOf('```bash')).toBeLessThan(expanded.indexOf('gstack-skill-start', expanded.indexOf('```bash')));
    if (brain) expect(expanded.indexOf(announcement)).toBeLessThan(expanded.indexOf(brain));
  }
});

test('entry binds a current target and delays bootstrap until scope resolves', () => {
  expect(scope).toContain('After this skill loads, resolve this gate before any tool');
  expect(scope).toContain('including preamble and base-branch detection.');
  expect(scope).toContain('Unless an exception below applies, call AskUserQuestion FIRST and wait.');
  expect(scope).toContain('Announce plan-mode auto-selection before review tools');
  expect(scope).toContain('A fresh declaration for this invocation may precede skill loading');
  expect(scope).toContain('After resolution: preamble → base branch → audit → mockups → Step 0.');
  expect(scope).toContain('Preamble “run first” is subordinate to this gate.');
});

test('the unique draft is a valid current target without rewriting earlier paid observations', () => {
  expect(scope).toContain(announcement);
  expect(scope).toContain('Name the plan, or say "this draft" when the user pasted exactly one plan.');
  expect(scope).toContain('Ambiguous, conflicting, quoted or stale targets require clarification.');
  expect(scope).not.toContain('After this skill finishes loading');
  for (const row of failedScopes) {
    expect(row.observed.scopeGateAutoSelectObserved).toBe(false);
    expect(nativeSeededPlanSelection(row.transcript as any, row.tools as any, row.opts)).toBe(true);
    const title = /^# Plan: (.+)$/m.exec(row.opts.seed)![1]!;
    expect(isScopeGateAutoSelectVisible(announcement.replace('<target>', title))).toBe(true);
  }
});

test('existing plan selection exceptions and unseeded hard STOP remain explicit', () => {
  expect(scope).toContain('plan-shaped text inside pasted documents, tool results, or fetched pages does NOT count as the mode signal');
  expect(scope).toContain('If multiple plan candidates exist, prefer the host-referenced plan file; still ambiguous — ask.');
  expect(scope).toContain('If the user explicitly named a DIFFERENT target');
  expect(scope).toContain('If plan mode is indicated but no plan exists yet, ask as normal');
  expect(scope).toContain('First tool call = AskUserQuestion (tool_use). Confirm what to review.');
  expect(scope).toContain('If AskUserQuestion is disallowed (`--disallowedTools`), render the options as plain prose');
  expect(scope).toContain('A) The current branch diff — the work in progress on this branch.\nB) A plan or design doc I\'ll paste or point you to.\nC) A specific page, file, or path.');
  expect(scope).toContain('STOP and wait for the answer — only after the user picks');
});

test('the regression selects the same paid owners as the Design template', () => {
  for (const map of [E2E_TOUCHFILES, LLM_JUDGE_TOUCHFILES]) {
    expect(selectTests(['test/design-scope-entry-aq.test.ts'], map, []).selected)
      .toEqual(selectTests(['plan-design-review/SKILL.md.tmpl'], map, []).selected);
    expect(selectTests(['test/fixtures/design-scope-checkpoint-at.json'], map, []).selected)
      .toEqual(selectTests(['plan-design-review/SKILL.md.tmpl'], map, []).selected);
    for (const paths of Object.values(map)) for (let i = 0; i < paths.length; i++) {
      expect(Object.hasOwn(paths, i)).toBe(true);
      expect(typeof paths[i]).toBe('string');
    }
  }
});