const path = require('node:path');
const { BaseIdeSetup } = require('./_base-ide');
const chalk = require('chalk');
const { getProjectRoot, getSourcePath, getModulePath } = require('../../../lib/project-root');
const { WorkflowCommandGenerator } = require('./workflow-command-generator');

/**
 * Claude Code IDE setup handler
 */
class ClaudeCodeSetup extends BaseIdeSetup {
  constructor() {
    super('claude-code', 'Claude Code', true); // preferred IDE
    this.configDir = '.claude';
    this.commandsDir = 'commands';
    this.agentsDir = 'agents';
  }

  /**
   * Collect configuration choices before installation
   * @param {Object} options - Configuration options
   * @returns {Object} Collected configuration
   */
  async collectConfiguration(options = {}) {
    const config = {
      subagentChoices: null,
      installLocation: null,
    };

    const sourceModulesPath = getSourcePath('modules');
    const modules = options.selectedModules || [];

    for (const moduleName of modules) {
      // Check for Claude Code sub-module injection config in SOURCE directory
      const injectionConfigPath = path.join(sourceModulesPath, moduleName, 'sub-modules', 'claude-code', 'injections.yaml');

      if (await this.exists(injectionConfigPath)) {
        const fs = require('fs-extra');
        const yaml = require('js-yaml');

        try {
          // Load injection configuration
          const configContent = await fs.readFile(injectionConfigPath, 'utf8');
          const injectionConfig = yaml.load(configContent);

          // Ask about subagents if they exist and we haven't asked yet
          if (injectionConfig.subagents && !config.subagentChoices) {
            config.subagentChoices = await this.promptSubagentInstallation(injectionConfig.subagents);

            if (config.subagentChoices.install !== 'none') {
              // Ask for installation location
              const inquirer = require('inquirer');
              const locationAnswer = await inquirer.prompt([
                {
                  type: 'list',
                  name: 'location',
                  message: 'Where would you like to install Claude Code subagents?',
                  choices: [
                    { name: 'Project level (.claude/agents/)', value: 'project' },
                    { name: 'User level (~/.claude/agents/)', value: 'user' },
                  ],
                  default: 'project',
                },
              ]);
              config.installLocation = locationAnswer.location;
            }
          }
        } catch (error) {
          console.log(chalk.yellow(`  Warning: Failed to process ${moduleName} features: ${error.message}`));
        }
      }
    }

    return config;
  }

  /**
   * Setup Claude Code IDE configuration
   * @param {string} projectDir - Project directory
   * @param {string} bmadDir - BMAD installation directory
   * @param {Object} options - Setup options
   */
  async setup(projectDir, bmadDir, options = {}) {
    // Store project directory for use in processContent
    this.projectDir = projectDir;

    console.log(chalk.cyan(`Setting up ${this.name}...`));

    // Create .claude/commands directory structure
    const claudeDir = path.join(projectDir, this.configDir);
    const commandsDir = path.join(claudeDir, this.commandsDir);
    const bmadCommandsDir = path.join(commandsDir, 'bmad');

    await this.ensureDir(bmadCommandsDir);

    // Get agents and tasks from INSTALLED bmad/ directory
    // Base installer has already built .md files from .agent.yaml sources
    const agents = await this.getAgentsFromBmad(bmadDir, options.selectedModules || []);
    const tasks = await this.getTasksFromBmad(bmadDir, options.selectedModules || []);

    // Create directories for each module
    const modules = new Set();
    for (const item of [...agents, ...tasks]) modules.add(item.module);

    for (const module of modules) {
      await this.ensureDir(path.join(bmadCommandsDir, module));
      await this.ensureDir(path.join(bmadCommandsDir, module, 'agents'));
      await this.ensureDir(path.join(bmadCommandsDir, module, 'tasks'));
    }

    // Copy agents from bmad/ to .claude/commands/
    let agentCount = 0;
    for (const agent of agents) {
      const sourcePath = agent.path;
      const targetPath = path.join(bmadCommandsDir, agent.module, 'agents', `${agent.name}.md`);

      const content = await this.readAndProcess(sourcePath, {
        module: agent.module,
        name: agent.name,
      });

      await this.writeFile(targetPath, content);
      agentCount++;
    }

    // Copy tasks from bmad/ to .claude/commands/
    let taskCount = 0;
    for (const task of tasks) {
      const sourcePath = task.path;
      const targetPath = path.join(bmadCommandsDir, task.module, 'tasks', `${task.name}.md`);

      const content = await this.readAndProcess(sourcePath, {
        module: task.module,
        name: task.name,
      });

      await this.writeFile(targetPath, content);
      taskCount++;
    }

    // Process Claude Code specific injections for installed modules
    // Use pre-collected configuration if available
    if (options.preCollectedConfig) {
      await this.processModuleInjectionsWithConfig(projectDir, bmadDir, options, options.preCollectedConfig);
    } else {
      await this.processModuleInjections(projectDir, bmadDir, options);
    }

    // Skip CLAUDE.md creation - let user manage their own CLAUDE.md file
    // await this.createClaudeConfig(projectDir, modules);

    // Generate workflow commands from manifest (if it exists)
    const workflowGen = new WorkflowCommandGenerator();
    const workflowResult = await workflowGen.generateWorkflowCommands(projectDir, bmadDir);

    console.log(chalk.green(`✓ ${this.name} configured:`));
    console.log(chalk.dim(`  - ${agentCount} agents installed`));
    console.log(chalk.dim(`  - ${taskCount} tasks installed`));
    if (workflowResult.generated > 0) {
      console.log(chalk.dim(`  - ${workflowResult.generated} workflow commands generated`));
    }
    console.log(chalk.dim(`  - Commands directory: ${path.relative(projectDir, bmadCommandsDir)}`));

    return {
      success: true,
      agents: agentCount,
      tasks: taskCount,
    };
  }

  // Method removed - CLAUDE.md file management left to user

  /**
   * Read and process file content
   */
  async readAndProcess(filePath, metadata) {
    const fs = require('fs-extra');
    const content = await fs.readFile(filePath, 'utf8');
    return this.processContent(content, metadata);
  }

  /**
   * Override processContent to use the actual project directory path
   */
  processContent(content, metadata = {}) {
    // Use the base class method with the actual project directory
    return super.processContent(content, metadata, this.projectDir);
  }

  /**
   * Get agents from installed bmad/ directory
   */
  async getAgentsFromBmad(bmadDir, selectedModules) {
    const fs = require('fs-extra');
    const agents = [];

    // Add core agents
    if (await fs.pathExists(path.join(bmadDir, 'core', 'agents'))) {
      const coreAgents = await this.getAgentsFromDir(path.join(bmadDir, 'core', 'agents'), 'core');
      agents.push(...coreAgents);
    }

    // Add module agents
    for (const moduleName of selectedModules) {
      const agentsPath = path.join(bmadDir, moduleName, 'agents');

      if (await fs.pathExists(agentsPath)) {
        const moduleAgents = await this.getAgentsFromDir(agentsPath, moduleName);
        agents.push(...moduleAgents);
      }
    }

    return agents;
  }

  /**
   * Get tasks from installed bmad/ directory
   */
  async getTasksFromBmad(bmadDir, selectedModules) {
    const fs = require('fs-extra');
    const tasks = [];

    // Add core tasks
    if (await fs.pathExists(path.join(bmadDir, 'core', 'tasks'))) {
      const coreTasks = await this.getTasksFromDir(path.join(bmadDir, 'core', 'tasks'), 'core');
      tasks.push(...coreTasks);
    }

    // Add module tasks
    for (const moduleName of selectedModules) {
      const tasksPath = path.join(bmadDir, moduleName, 'tasks');

      if (await fs.pathExists(tasksPath)) {
        const moduleTasks = await this.getTasksFromDir(tasksPath, moduleName);
        tasks.push(...moduleTasks);
      }
    }

    return tasks;
  }

  /**
   * Get agents from source modules (not installed location)
   */
  async getAgentsFromSource(sourceDir, selectedModules) {
    const fs = require('fs-extra');
    const agents = [];

    // Add core agents
    const corePath = getModulePath('core');
    if (await fs.pathExists(path.join(corePath, 'agents'))) {
      const coreAgents = await this.getAgentsFromDir(path.join(corePath, 'agents'), 'core');
      agents.push(...coreAgents);
    }

    // Add module agents
    for (const moduleName of selectedModules) {
      const modulePath = path.join(sourceDir, moduleName);
      const agentsPath = path.join(modulePath, 'agents');

      if (await fs.pathExists(agentsPath)) {
        const moduleAgents = await this.getAgentsFromDir(agentsPath, moduleName);
        agents.push(...moduleAgents);
      }
    }

    return agents;
  }

  /**
   * Get tasks from source modules (not installed location)
   */
  async getTasksFromSource(sourceDir, selectedModules) {
    const fs = require('fs-extra');
    const tasks = [];

    // Add core tasks
    const corePath = getModulePath('core');
    if (await fs.pathExists(path.join(corePath, 'tasks'))) {
      const coreTasks = await this.getTasksFromDir(path.join(corePath, 'tasks'), 'core');
      tasks.push(...coreTasks);
    }

    // Add module tasks
    for (const moduleName of selectedModules) {
      const modulePath = path.join(sourceDir, moduleName);
      const tasksPath = path.join(modulePath, 'tasks');

      if (await fs.pathExists(tasksPath)) {
        const moduleTasks = await this.getTasksFromDir(tasksPath, moduleName);
        tasks.push(...moduleTasks);
      }
    }

    return tasks;
  }

  /**
   * Get agents from a specific directory
   * When reading from bmad/, this returns built .md files
   */
  async getAgentsFromDir(dirPath, moduleName) {
    const fs = require('fs-extra');
    const agents = [];

    const files = await fs.readdir(dirPath);

    for (const file of files) {
      // Only process .md files (base installer has already built .agent.yaml to .md)
      if (file.endsWith('.md')) {
        // Skip customize templates
        if (file.includes('.customize.')) {
          continue;
        }

        const baseName = file.replace('.md', '');
        const filePath = path.join(dirPath, file);
        const content = await fs.readFile(filePath, 'utf8');

        // Skip web-only agents
        if (content.includes('localskip="true"')) {
          continue;
        }

        agents.push({
          path: filePath,
          name: baseName,
          module: moduleName,
        });
      }
    }

    return agents;
  }

  /**
   * Get tasks from a specific directory
   */
  async getTasksFromDir(dirPath, moduleName) {
    const fs = require('fs-extra');
    const tasks = [];

    const files = await fs.readdir(dirPath);
    for (const file of files) {
      if (file.endsWith('.md')) {
        tasks.push({
          path: path.join(dirPath, file),
          name: file.replace('.md', ''),
          module: moduleName,
        });
      }
    }

    return tasks;
  }

  /**
   * Process module injections with pre-collected configuration
   */
  async processModuleInjectionsWithConfig(projectDir, bmadDir, options, preCollectedConfig) {
    const fs = require('fs-extra');
    const yaml = require('js-yaml');

    // Get list of installed modules
    const modules = options.selectedModules || [];
    const { subagentChoices, installLocation } = preCollectedConfig;

    // Get the actual source directory (not the installation directory)
    const sourceModulesPath = getSourcePath('modules');

    for (const moduleName of modules) {
      // Check for Claude Code sub-module injection config in SOURCE directory
      const injectionConfigPath = path.join(sourceModulesPath, moduleName, 'sub-modules', 'claude-code', 'injections.yaml');

      if (await this.exists(injectionConfigPath)) {
        try {
          // Load injection configuration
          const configContent = await fs.readFile(injectionConfigPath, 'utf8');
          const config = yaml.load(configContent);

          // Process content injections based on user choices
          if (config.injections && subagentChoices && subagentChoices.install !== 'none') {
            for (const injection of config.injections) {
              // Check if this injection is related to a selected subagent
              if (this.shouldInject(injection, subagentChoices)) {
                await this.injectContent(projectDir, injection, subagentChoices);
              }
            }
          }

          // Copy selected subagents
          if (config.subagents && subagentChoices && subagentChoices.install !== 'none') {
            await this.copySelectedSubagents(
              projectDir,
              path.dirname(injectionConfigPath),
              config.subagents,
              subagentChoices,
              installLocation,
            );
          }
        } catch (error) {
          console.log(chalk.yellow(`  Warning: Failed to process ${moduleName} features: ${error.message}`));
        }
      }
    }
  }

  /**
   * Process Claude Code specific injections for installed modules
   * Looks for injections.yaml in each module's claude-code sub-module
   */
  async processModuleInjections(projectDir, bmadDir, options) {
    const fs = require('fs-extra');
    const yaml = require('js-yaml');
    const inquirer = require('inquirer');

    // Get list of installed modules
    const modules = options.selectedModules || [];
    let subagentChoices = null;
    let installLocation = null;

    // Get the actual source directory (not the installation directory)
    const sourceModulesPath = getSourcePath('modules');

    for (const moduleName of modules) {
      // Check for Claude Code sub-module injection config in SOURCE directory
      const injectionConfigPath = path.join(sourceModulesPath, moduleName, 'sub-modules', 'claude-code', 'injections.yaml');

      if (await this.exists(injectionConfigPath)) {
        console.log(chalk.cyan(`\nConfiguring ${moduleName} Claude Code features...`));

        try {
          // Load injection configuration
          const configContent = await fs.readFile(injectionConfigPath, 'utf8');
          const config = yaml.load(configContent);

          // Ask about subagents if they exist and we haven't asked yet
          if (config.subagents && !subagentChoices) {
            subagentChoices = await this.promptSubagentInstallation(config.subagents);

            if (subagentChoices.install !== 'none') {
              // Ask for installation location
              const locationAnswer = await inquirer.prompt([
                {
                  type: 'list',
                  name: 'location',
                  message: 'Where would you like to install Claude Code subagents?',
                  choices: [
                    { name: 'Project level (.claude/agents/)', value: 'project' },
                    { name: 'User level (~/.claude/agents/)', value: 'user' },
                  ],
                  default: 'project',
                },
              ]);
              installLocation = locationAnswer.location;
            }
          }

          // Process content injections based on user choices
          if (config.injections && subagentChoices && subagentChoices.install !== 'none') {
            for (const injection of config.injections) {
              // Check if this injection is related to a selected subagent
              if (this.shouldInject(injection, subagentChoices)) {
                await this.injectContent(projectDir, injection, subagentChoices);
              }
            }
          }

          // Copy selected subagents
          if (config.subagents && subagentChoices && subagentChoices.install !== 'none') {
            await this.copySelectedSubagents(
              projectDir,
              path.dirname(injectionConfigPath),
              config.subagents,
              subagentChoices,
              installLocation,
            );
          }
        } catch (error) {
          console.log(chalk.yellow(`  Warning: Failed to process ${moduleName} features: ${error.message}`));
        }
      }
    }
  }

  /**
   * Prompt user for subagent installation preferences
   */
  async promptSubagentInstallation(subagentConfig) {
    const inquirer = require('inquirer');

    // First ask if they want to install subagents
    const { install } = await inquirer.prompt([
      {
        type: 'list',
        name: 'install',
        message: 'Would you like to install Claude Code subagents for enhanced functionality?',
        choices: [
          { name: 'Yes, install all subagents', value: 'all' },
          { name: 'Yes, let me choose specific subagents', value: 'selective' },
          { name: 'No, skip subagent installation', value: 'none' },
        ],
        default: 'all',
      },
    ]);

    if (install === 'selective') {
      // Show list of available subagents with descriptions
      const subagentInfo = {
        'market-researcher.md': 'Market research and competitive analysis',
        'requirements-analyst.md': 'Requirements extraction and validation',
        'technical-evaluator.md': 'Technology stack evaluation',
        'epic-optimizer.md': 'Epic and story breakdown optimization',
        'document-reviewer.md': 'Document quality review',
      };

      const { selected } = await inquirer.prompt([
        {
          type: 'checkbox',
          name: 'selected',
          message: 'Select subagents to install:',
          choices: subagentConfig.files.map((file) => ({
            name: `${file.replace('.md', '')} - ${subagentInfo[file] || 'Specialized assistant'}`,
            value: file,
            checked: true,
          })),
        },
      ]);

      return { install: 'selective', selected };
    }

    return { install };
  }

  /**
   * Check if an injection should be applied based on user choices
   */
  shouldInject(injection, subagentChoices) {
    // If user chose no subagents, no injections
    if (subagentChoices.install === 'none') {
      return false;
    }

    // If user chose all subagents, all injections apply
    if (subagentChoices.install === 'all') {
      return true;
    }

    // For selective installation, check the 'requires' field
    if (subagentChoices.install === 'selective') {
      // If injection requires 'any' subagent and user selected at least one
      if (injection.requires === 'any' && subagentChoices.selected.length > 0) {
        return true;
      }

      // Check if the required subagent was selected
      if (injection.requires) {
        const requiredAgent = injection.requires + '.md';
        return subagentChoices.selected.includes(requiredAgent);
      }

      // Fallback: check if injection mentions a selected agent
      const selectedAgentNames = subagentChoices.selected.map((f) => f.replace('.md', ''));
      for (const agentName of selectedAgentNames) {
        if (injection.point && injection.point.includes(agentName)) {
          return true;
        }
      }
    }

    return false;
  }

  /**
   * Inject content at specified point in file
   */
  async injectContent(projectDir, injection, subagentChoices = null) {
    const fs = require('fs-extra');
    const targetPath = path.join(projectDir, injection.file);

    if (await this.exists(targetPath)) {
      let content = await fs.readFile(targetPath, 'utf8');
      const marker = `<!-- IDE-INJECT-POINT: ${injection.point} -->`;

      if (content.includes(marker)) {
        let injectionContent = injection.content;

        // Filter content if selective subagents chosen
        if (subagentChoices && subagentChoices.install === 'selective' && injection.point === 'pm-agent-instructions') {
          injectionContent = this.filterAgentInstructions(injection.content, subagentChoices.selected);
        }

        content = content.replace(marker, injectionContent);
        await fs.writeFile(targetPath, content);
        console.log(chalk.dim(`    Injected: ${injection.point} → ${injection.file}`));
      }
    }
  }

  /**
   * Filter agent instructions to only include selected subagents
   */
  filterAgentInstructions(content, selectedFiles) {
    const selectedAgents = selectedFiles.map((f) => f.replace('.md', ''));
    const lines = content.split('\n');
    const filteredLines = [];

    let includeNextLine = true;
    for (const line of lines) {
      // Always include structural lines
      if (line.includes('<llm') || line.includes('</llm>')) {
        filteredLines.push(line);
        includeNextLine = true;
      }
      // Check if line mentions a subagent
      else if (line.includes('subagent')) {
        let shouldInclude = false;
        for (const agent of selectedAgents) {
          if (line.includes(agent)) {
            shouldInclude = true;
            break;
          }
        }
        if (shouldInclude) {
          filteredLines.push(line);
        }
      }
      // Include general instructions
      else if (line.includes('When creating PRDs') || line.includes('ACTIVELY delegate')) {
        filteredLines.push(line);
      }
    }

    // Only return content if we have actual instructions
    if (filteredLines.length > 2) {
      // More than just llm tags
      return filteredLines.join('\n');
    }
    return ''; // Return empty if no relevant content
  }

  /**
   * Copy selected subagents to appropriate Claude agents directory
   */
  async copySelectedSubagents(projectDir, moduleClaudeDir, subagentConfig, choices, location) {
    const fs = require('fs-extra');
    const sourceDir = path.join(moduleClaudeDir, subagentConfig.source);

    // Determine target directory based on user choice
    let targetDir;
    if (location === 'user') {
      targetDir = path.join(require('node:os').homedir(), '.claude', 'agents');
      console.log(chalk.dim(`  Installing subagents globally to: ~/.claude/agents/`));
    } else {
      targetDir = path.join(projectDir, '.claude', 'agents');
      console.log(chalk.dim(`  Installing subagents to project: .claude/agents/`));
    }

    // Ensure target directory exists
    await this.ensureDir(targetDir);

    // Determine which files to copy
    let filesToCopy = [];
    if (choices.install === 'all') {
      filesToCopy = subagentConfig.files;
    } else if (choices.install === 'selective') {
      filesToCopy = choices.selected;
    }

    // Recursively find all matching files in source directory
    const findFileInSource = async (filename) => {
      const { glob } = require('glob');
      const pattern = path.join(sourceDir, '**', filename);
      const files = await glob(pattern);
      return files[0]; // Return first match
    };

    // Copy selected subagent files
    let copiedCount = 0;
    for (const file of filesToCopy) {
      try {
        const sourcePath = await findFileInSource(file);

        if (sourcePath && (await this.exists(sourcePath))) {
          // Extract subfolder name if file is in a subfolder
          const relPath = path.relative(sourceDir, sourcePath);
          const subFolder = path.dirname(relPath);

          // Create corresponding subfolder in target if needed
          let targetPath;
          if (subFolder && subFolder !== '.') {
            const targetSubDir = path.join(targetDir, subFolder);
            await this.ensureDir(targetSubDir);
            targetPath = path.join(targetSubDir, file);
          } else {
            targetPath = path.join(targetDir, file);
          }

          await fs.copyFile(sourcePath, targetPath);
          console.log(chalk.green(`    ✓ Installed: ${subFolder === '.' ? '' : subFolder + '/'}${file.replace('.md', '')}`));
          copiedCount++;
        } else {
          console.log(chalk.yellow(`    ⚠ Not found: ${file}`));
        }
      } catch (error) {
        console.log(chalk.yellow(`    ⚠ Error copying ${file}: ${error.message}`));
      }
    }

    if (copiedCount > 0) {
      console.log(chalk.dim(`  Total subagents installed: ${copiedCount}`));
    }
  }
}

module.exports = { ClaudeCodeSetup };