const fs = require('fs').promises
const path = require('path')
const { glob } = require('glob')

// Dynamic imports for ES modules
let chalk, ora, inquirer

// Initialize ES modules
async function initializeModules () {
  chalk = (await import('chalk')).default
  ora = (await import('ora')).default
  inquirer = (await import('inquirer')).default
}

class V3ToV4Upgrader {
  constructor () {
    // Constructor remains empty
  }

  async upgrade (options = {}) {
    try {
      // Initialize ES modules
      await initializeModules()
      // Keep readline open throughout the process
      process.stdin.resume()

      // 1. Welcome message
      console.log(
        chalk.bold('\nWelcome to BMad-Method V3 to V4 Upgrade Tool\n')
      )
      console.log(
        'This tool will help you upgrade your BMad-Method V3 project to V4.\n'
      )
      console.log(chalk.cyan('What this tool does:'))
      console.log('- Creates a backup of your V3 files (.bmad-v3-backup/)')
      console.log('- Installs the new V4 .bmad-core structure')
      console.log(
        '- Preserves your PRD, Architecture, and Stories in the new format\n'
      )
      console.log(chalk.yellow('What this tool does NOT do:'))
      console.log(
        '- Modify your document content (use doc-migration-task after upgrade)'
      )
      console.log('- Touch any files outside bmad-agent/ and docs/\n')

      // 2. Get project path
      const projectPath = await this.getProjectPath(options.projectPath)

      // 3. Validate V3 structure
      const validation = await this.validateV3Project(projectPath)
      if (!validation.isValid) {
        console.error(
          chalk.red("\nError: This doesn't appear to be a V3 project.")
        )
        console.error('Expected to find:')
        console.error('- bmad-agent/ directory')
        console.error('- docs/ directory\n')
        console.error(
          "Please check you're in the correct directory and try again."
        )
        return
      }

      // 4. Pre-flight check
      const analysis = await this.analyzeProject(projectPath)
      await this.showPreflightCheck(analysis, options)

      if (!options.dryRun) {
        const { confirm } = await inquirer.prompt([
          {
            type: 'confirm',
            name: 'confirm',
            message: 'Continue with upgrade?',
            default: true
          }
        ])

        if (!confirm) {
          console.log('Upgrade cancelled.')
          return
        }
      }

      // 5. Create backup
      if (options.backup !== false && !options.dryRun) {
        await this.createBackup(projectPath)
      }

      // 6. Install V4 structure
      if (!options.dryRun) {
        await this.installV4Structure(projectPath)
      }

      // 7. Migrate documents
      if (!options.dryRun) {
        await this.migrateDocuments(projectPath, analysis)
      }

      // 8. Setup IDE
      if (!options.dryRun) {
        await this.setupIDE(projectPath, options.ides)
      }

      // 9. Show completion report
      this.showCompletionReport(projectPath, analysis)

      process.exit(0)
    } catch (error) {
      console.error(chalk.red('\nUpgrade error:'), error.message)
      process.exit(1)
    }
  }

  async getProjectPath (providedPath) {
    if (providedPath) {
      return path.resolve(providedPath)
    }

    const { projectPath } = await inquirer.prompt([
      {
        type: 'input',
        name: 'projectPath',
        message: 'Please enter the path to your V3 project:',
        default: process.cwd()
      }
    ])

    return path.resolve(projectPath)
  }

  async validateV3Project (projectPath) {
    const spinner = ora('Validating project structure...').start()

    try {
      const bmadAgentPath = path.join(projectPath, 'bmad-agent')
      const docsPath = path.join(projectPath, 'docs')

      const hasBmadAgent = await this.pathExists(bmadAgentPath)
      const hasDocs = await this.pathExists(docsPath)

      if (hasBmadAgent) {
        spinner.text = '✓ Found bmad-agent/ directory'
        console.log(chalk.green('\n✓ Found bmad-agent/ directory'))
      }

      if (hasDocs) {
        console.log(chalk.green('✓ Found docs/ directory'))
      }

      const isValid = hasBmadAgent && hasDocs

      if (isValid) {
        spinner.succeed('This appears to be a valid V3 project')
      } else {
        spinner.fail('Invalid V3 project structure')
      }

      return { isValid, hasBmadAgent, hasDocs }
    } catch (error) {
      spinner.fail('Validation failed')
      throw error
    }
  }

  async analyzeProject (projectPath) {
    const docsPath = path.join(projectPath, 'docs')
    const bmadAgentPath = path.join(projectPath, 'bmad-agent')

    // Find PRD
    const prdCandidates = ['prd.md', 'PRD.md', 'product-requirements.md']
    let prdFile = null
    for (const candidate of prdCandidates) {
      const candidatePath = path.join(docsPath, candidate)
      if (await this.pathExists(candidatePath)) {
        prdFile = candidate
        break
      }
    }

    // Find Architecture
    const archCandidates = [
      'architecture.md',
      'Architecture.md',
      'technical-architecture.md'
    ]
    let archFile = null
    for (const candidate of archCandidates) {
      const candidatePath = path.join(docsPath, candidate)
      if (await this.pathExists(candidatePath)) {
        archFile = candidate
        break
      }
    }

    // Find Front-end Architecture (V3 specific)
    const frontEndCandidates = [
      'front-end-architecture.md',
      'frontend-architecture.md',
      'ui-architecture.md'
    ]
    let frontEndArchFile = null
    for (const candidate of frontEndCandidates) {
      const candidatePath = path.join(docsPath, candidate)
      if (await this.pathExists(candidatePath)) {
        frontEndArchFile = candidate
        break
      }
    }

    // Find UX/UI spec
    const uxSpecCandidates = [
      'ux-ui-spec.md',
      'ux-ui-specification.md',
      'ui-spec.md',
      'ux-spec.md'
    ]
    let uxSpecFile = null
    for (const candidate of uxSpecCandidates) {
      const candidatePath = path.join(docsPath, candidate)
      if (await this.pathExists(candidatePath)) {
        uxSpecFile = candidate
        break
      }
    }

    // Find v0 prompt or UX prompt
    const uxPromptCandidates = [
      'v0-prompt.md',
      'ux-prompt.md',
      'ui-prompt.md',
      'design-prompt.md'
    ]
    let uxPromptFile = null
    for (const candidate of uxPromptCandidates) {
      const candidatePath = path.join(docsPath, candidate)
      if (await this.pathExists(candidatePath)) {
        uxPromptFile = candidate
        break
      }
    }

    // Find epic files
    const epicFiles = await glob('epic*.md', { cwd: docsPath })

    // Find story files
    const storiesPath = path.join(docsPath, 'stories')
    let storyFiles = []
    if (await this.pathExists(storiesPath)) {
      storyFiles = await glob('*.md', { cwd: storiesPath })
    }

    // Count custom files in bmad-agent
    const bmadAgentFiles = await glob('**/*.md', {
      cwd: bmadAgentPath,
      ignore: ['node_modules/**']
    })

    return {
      prdFile,
      archFile,
      frontEndArchFile,
      uxSpecFile,
      uxPromptFile,
      epicFiles,
      storyFiles,
      customFileCount: bmadAgentFiles.length
    }
  }

  async showPreflightCheck (analysis, options) {
    console.log(chalk.bold('\nProject Analysis:'))
    console.log(
      `- PRD found: ${
        analysis.prdFile
          ? `docs/${analysis.prdFile}`
          : chalk.yellow('Not found')
      }`
    )
    console.log(
      `- Architecture found: ${
        analysis.archFile
          ? `docs/${analysis.archFile}`
          : chalk.yellow('Not found')
      }`
    )
    if (analysis.frontEndArchFile) {
      console.log(
        `- Front-end Architecture found: docs/${analysis.frontEndArchFile}`
      )
    }
    console.log(
      `- UX/UI Spec found: ${
        analysis.uxSpecFile
          ? `docs/${analysis.uxSpecFile}`
          : chalk.yellow('Not found')
      }`
    )
    console.log(
      `- UX/Design Prompt found: ${
        analysis.uxPromptFile
          ? `docs/${analysis.uxPromptFile}`
          : chalk.yellow('Not found')
      }`
    )
    console.log(
      `- Epic files found: ${analysis.epicFiles.length} files (epic*.md)`
    )
    console.log(
      `- Stories found: ${analysis.storyFiles.length} files in docs/stories/`
    )
    console.log(`- Custom files in bmad-agent/: ${analysis.customFileCount}`)

    if (!options.dryRun) {
      console.log('\nThe following will be backed up to .bmad-v3-backup/:')
      console.log('- bmad-agent/ (entire directory)')
      console.log('- docs/ (entire directory)')

      if (analysis.epicFiles.length > 0) {
        console.log(
          chalk.green(
            '\nNote: Epic files found! They will be placed in docs/prd/ with an index.md file.'
          )
        )
        console.log(
          chalk.green(
            "Since epic files exist, you won't need to shard the PRD after upgrade."
          )
        )
      }
    }
  }

  async createBackup (projectPath) {
    const spinner = ora('Creating backup...').start()

    try {
      const backupPath = path.join(projectPath, '.bmad-v3-backup')

      // Check if backup already exists
      if (await this.pathExists(backupPath)) {
        spinner.fail('Backup directory already exists')
        console.error(
          chalk.red(
            '\nError: Backup directory .bmad-v3-backup/ already exists.'
          )
        )
        console.error('\nThis might mean an upgrade was already attempted.')
        console.error(
          'Please remove or rename the existing backup and try again.'
        )
        throw new Error('Backup already exists')
      }

      // Create backup directory
      await fs.mkdir(backupPath, { recursive: true })
      spinner.text = '✓ Created .bmad-v3-backup/'
      console.log(chalk.green('\n✓ Created .bmad-v3-backup/'))

      // Move bmad-agent
      const bmadAgentSrc = path.join(projectPath, 'bmad-agent')
      const bmadAgentDest = path.join(backupPath, 'bmad-agent')
      await fs.rename(bmadAgentSrc, bmadAgentDest)
      console.log(chalk.green('✓ Moved bmad-agent/ to backup'))

      // Move docs
      const docsSrc = path.join(projectPath, 'docs')
      const docsDest = path.join(backupPath, 'docs')
      await fs.rename(docsSrc, docsDest)
      console.log(chalk.green('✓ Moved docs/ to backup'))

      spinner.succeed('Backup created successfully')
    } catch (error) {
      spinner.fail('Backup failed')
      throw error
    }
  }

  async installV4Structure (projectPath) {
    const spinner = ora('Installing V4 structure...').start()

    try {
      // Get the source bmad-core directory (without dot prefix)
      const sourcePath = path.join(__dirname, '..', '..', 'bmad-core')
      const destPath = path.join(projectPath, '.bmad-core')

      // Copy .bmad-core
      await this.copyDirectory(sourcePath, destPath)
      spinner.text = '✓ Copied fresh .bmad-core/ directory from V4'
      console.log(
        chalk.green('\n✓ Copied fresh .bmad-core/ directory from V4')
      )

      // Create docs directory
      const docsPath = path.join(projectPath, 'docs')
      await fs.mkdir(docsPath, { recursive: true })
      console.log(chalk.green('✓ Created new docs/ directory'))

      // Create install manifest for future updates
      await this.createInstallManifest(projectPath)
      console.log(chalk.green('✓ Created install manifest'))

      console.log(
        chalk.yellow(
          '\nNote: Your V3 bmad-agent content has been backed up and NOT migrated.'
        )
      )
      console.log(
        chalk.yellow(
          'The new V4 agents are completely different and look for different file structures.'
        )
      )

      spinner.succeed('V4 structure installed successfully')
    } catch (error) {
      spinner.fail('V4 installation failed')
      throw error
    }
  }

  async migrateDocuments (projectPath, analysis) {
    const spinner = ora('Migrating your project documents...').start()

    try {
      const backupDocsPath = path.join(projectPath, '.bmad-v3-backup', 'docs')
      const newDocsPath = path.join(projectPath, 'docs')
      let copiedCount = 0

      // Copy PRD
      if (analysis.prdFile) {
        const src = path.join(backupDocsPath, analysis.prdFile)
        const dest = path.join(newDocsPath, analysis.prdFile)
        await fs.copyFile(src, dest)
        console.log(chalk.green(`\n✓ Copied PRD to docs/${analysis.prdFile}`))
        copiedCount++
      }

      // Copy Architecture
      if (analysis.archFile) {
        const src = path.join(backupDocsPath, analysis.archFile)
        const dest = path.join(newDocsPath, analysis.archFile)
        await fs.copyFile(src, dest)
        console.log(
          chalk.green(`✓ Copied Architecture to docs/${analysis.archFile}`)
        )
        copiedCount++
      }

      // Copy Front-end Architecture if exists
      if (analysis.frontEndArchFile) {
        const src = path.join(backupDocsPath, analysis.frontEndArchFile)
        const dest = path.join(newDocsPath, analysis.frontEndArchFile)
        await fs.copyFile(src, dest)
        console.log(
          chalk.green(
            `✓ Copied Front-end Architecture to docs/${analysis.frontEndArchFile}`
          )
        )
        console.log(
          chalk.yellow(
            'Note: V4 uses a single full-stack-architecture.md - use doc-migration-task to merge'
          )
        )
        copiedCount++
      }

      // Copy UX/UI Spec if exists
      if (analysis.uxSpecFile) {
        const src = path.join(backupDocsPath, analysis.uxSpecFile)
        const dest = path.join(newDocsPath, analysis.uxSpecFile)
        await fs.copyFile(src, dest)
        console.log(
          chalk.green(`✓ Copied UX/UI Spec to docs/${analysis.uxSpecFile}`)
        )
        copiedCount++
      }

      // Copy UX/Design Prompt if exists
      if (analysis.uxPromptFile) {
        const src = path.join(backupDocsPath, analysis.uxPromptFile)
        const dest = path.join(newDocsPath, analysis.uxPromptFile)
        await fs.copyFile(src, dest)
        console.log(
          chalk.green(
            `✓ Copied UX/Design Prompt to docs/${analysis.uxPromptFile}`
          )
        )
        copiedCount++
      }

      // Copy stories
      if (analysis.storyFiles.length > 0) {
        const storiesDir = path.join(newDocsPath, 'stories')
        await fs.mkdir(storiesDir, { recursive: true })

        for (const storyFile of analysis.storyFiles) {
          const src = path.join(backupDocsPath, 'stories', storyFile)
          const dest = path.join(storiesDir, storyFile)
          await fs.copyFile(src, dest)
        }
        console.log(
          chalk.green(
            `✓ Copied ${analysis.storyFiles.length} story files to docs/stories/`
          )
        )
        copiedCount += analysis.storyFiles.length
      }

      // Copy epic files to prd subfolder
      if (analysis.epicFiles.length > 0) {
        const prdDir = path.join(newDocsPath, 'prd')
        await fs.mkdir(prdDir, { recursive: true })

        for (const epicFile of analysis.epicFiles) {
          const src = path.join(backupDocsPath, epicFile)
          const dest = path.join(prdDir, epicFile)
          await fs.copyFile(src, dest)
        }
        console.log(
          chalk.green(
            `✓ Found and copied ${analysis.epicFiles.length} epic files to docs/prd/`
          )
        )

        // Create index.md for the prd folder
        await this.createPrdIndex(projectPath, analysis)
        console.log(chalk.green('✓ Created index.md in docs/prd/'))

        console.log(
          chalk.green(
            '\nNote: Epic files detected! These are compatible with V4 and have been copied.'
          )
        )
        console.log(
          chalk.green(
            "You won't need to shard the PRD since epics already exist."
          )
        )
        copiedCount += analysis.epicFiles.length
      }

      spinner.succeed(`Migrated ${copiedCount} documents successfully`)
    } catch (error) {
      spinner.fail('Document migration failed')
      throw error
    }
  }

  async setupIDE (projectPath, selectedIdes) {
    // Use the IDE selections passed from the installer
    if (!selectedIdes || selectedIdes.length === 0) {
      console.log(chalk.dim('No IDE setup requested - skipping'))
      return
    }

    const ideSetup = require('../installer/lib/ide-setup')
    const spinner = ora('Setting up IDE rules for all agents...').start()

    try {
      const ideMessages = {
        cursor: 'Rules created in .cursor/rules/',
        'claude-code': 'Commands created in .claude/commands/BMad/',
        windsurf: 'Rules created in .windsurf/rules/',
        trae: 'Rules created in.trae/rules/',
        roo: 'Custom modes created in .roomodes',
        cline: 'Rules created in .clinerules/'
      }

      // Setup each selected IDE
      for (const ide of selectedIdes) {
        spinner.text = `Setting up ${ide}...`
        await ideSetup.setup(ide, projectPath)
        console.log(chalk.green(`\n✓ ${ideMessages[ide]}`))
      }

      spinner.succeed(`IDE setup complete for ${selectedIdes.length} IDE(s)!`)
    } catch (error) {
      spinner.fail('IDE setup failed')
      console.error(
        chalk.yellow('IDE setup failed, but upgrade is complete.')
      )
    }
  }

  showCompletionReport (projectPath, analysis) {
    console.log(chalk.bold.green('\n✓ Upgrade Complete!\n'))
    console.log(chalk.bold('Summary:'))
    console.log('- V3 files backed up to: .bmad-v3-backup/')
    console.log('- V4 structure installed: .bmad-core/ (fresh from V4)')

    const totalDocs =
      (analysis.prdFile ? 1 : 0) +
      (analysis.archFile ? 1 : 0) +
      (analysis.frontEndArchFile ? 1 : 0) +
      (analysis.uxSpecFile ? 1 : 0) +
      (analysis.uxPromptFile ? 1 : 0) +
      analysis.storyFiles.length
    console.log(
      `- Documents migrated: ${totalDocs} files${
        analysis.epicFiles.length > 0
          ? ` + ${analysis.epicFiles.length} epics`
          : ''
      }`
    )

    console.log(chalk.bold('\nImportant Changes:'))
    console.log(
      '- The V4 agents (sm, dev, etc.) expect different file structures than V3'
    )
    console.log(
      "- Your V3 bmad-agent content was NOT migrated (it's incompatible)"
    )
    if (analysis.epicFiles.length > 0) {
      console.log(
        '- Epic files were found and copied - no PRD sharding needed!'
      )
    }
    if (analysis.frontEndArchFile) {
      console.log(
        '- Front-end architecture found - V4 uses full-stack-architecture.md, migration needed'
      )
    }
    if (analysis.uxSpecFile || analysis.uxPromptFile) {
      console.log(
        '- UX/UI design files found and copied - ready for use with V4'
      )
    }

    console.log(chalk.bold('\nNext Steps:'))
    console.log('1. Review your documents in the new docs/ folder')
    console.log(
      '2. Use @bmad-master agent to run the doc-migration-task to align your documents with V4 templates'
    )
    if (analysis.epicFiles.length === 0) {
      console.log(
        '3. Use @bmad-master agent to shard the PRD to create epic files'
      )
    }

    console.log(
      chalk.dim(
        '\nYour V3 backup is preserved in .bmad-v3-backup/ and can be restored if needed.'
      )
    )
  }

  async pathExists (filePath) {
    try {
      await fs.access(filePath)
      return true
    } catch {
      return false
    }
  }

  async copyDirectory (src, dest) {
    await fs.mkdir(dest, { recursive: true })
    const entries = await fs.readdir(src, { withFileTypes: true })

    for (const entry of entries) {
      const srcPath = path.join(src, entry.name)
      const destPath = path.join(dest, entry.name)

      if (entry.isDirectory()) {
        await this.copyDirectory(srcPath, destPath)
      } else {
        await fs.copyFile(srcPath, destPath)
      }
    }
  }

  async createPrdIndex (projectPath, analysis) {
    const prdIndexPath = path.join(projectPath, 'docs', 'prd', 'index.md')
    const prdPath = path.join(
      projectPath,
      'docs',
      analysis.prdFile || 'prd.md'
    )

    let indexContent = '# Product Requirements Document\n\n'

    // Try to read the PRD to get the title and intro content
    if (analysis.prdFile && (await this.pathExists(prdPath))) {
      try {
        const prdContent = await fs.readFile(prdPath, 'utf8')
        const lines = prdContent.split('\n')

        // Find the first heading
        const titleMatch = lines.find((line) => line.startsWith('# '))
        if (titleMatch) {
          indexContent = titleMatch + '\n\n'
        }

        // Get any content before the first ## section
        let introContent = ''
        let foundFirstSection = false
        for (const line of lines) {
          if (line.startsWith('## ')) {
            foundFirstSection = true
            break
          }
          if (!line.startsWith('# ')) {
            introContent += line + '\n'
          }
        }

        if (introContent.trim()) {
          indexContent += introContent.trim() + '\n\n'
        }
      } catch (error) {
        // If we can't read the PRD, just use default content
      }
    }

    // Add sections list
    indexContent += '## Sections\n\n'

    // Sort epic files for consistent ordering
    const sortedEpics = [...analysis.epicFiles].sort()

    for (const epicFile of sortedEpics) {
      // Extract epic name from filename
      const epicName = epicFile
        .replace(/\.md$/, '')
        .replace(/^epic-?/i, '')
        .replace(/-/g, ' ')
        .replace(/^\d+\s*/, '') // Remove leading numbers
        .trim()

      const displayName = epicName.charAt(0).toUpperCase() + epicName.slice(1)
      indexContent += `- [${
        displayName || epicFile.replace('.md', '')
      }](./${epicFile})\n`
    }

    await fs.writeFile(prdIndexPath, indexContent)
  }

  async createInstallManifest (projectPath) {
    const fileManager = require('../installer/lib/file-manager')
    const { glob } = require('glob')

    // Get all files in .bmad-core for the manifest
    const bmadCorePath = path.join(projectPath, '.bmad-core')
    const files = await glob('**/*', {
      cwd: bmadCorePath,
      nodir: true,
      ignore: ['**/.git/**', '**/node_modules/**']
    })

    // Prepend .bmad-core/ to file paths for manifest
    const manifestFiles = files.map((file) => path.join('.bmad-core', file))

    const config = {
      installType: 'full',
      agent: null,
      ide: null // Will be set if IDE setup is done later
    }

    await fileManager.createManifest(projectPath, config, manifestFiles)
  }
}

module.exports = V3ToV4Upgrader