/**
 * DoctorService - Diagnostic and repair service
 * DD §16.1. Self-bootstrap before capability checks.
 * INV-4: dependency installs originate here.
 *
 * @module packages/runtime/src/doctor/DoctorService
 */

import { existsSync, accessSync, constants, mkdirSync } from 'fs'
import { join } from 'path'
import { execFileSync } from 'child_process'

export interface DoctorCheck {
  name: string
  category: 'self_bootstrap' | 'capability' | 'project' | 'runtime'
  passed: boolean
  message: string
  fixable: boolean
  fix?: string
}

export interface DoctorReport {
  checks: DoctorCheck[]
  all_passed: boolean
  bootstrap_passed: boolean
  fixable_count: number
}

export class DoctorService {
  private project_root: string

  constructor(project_root: string) {
    this.project_root = project_root
  }

  /**
   * Run all diagnostic checks.
   */
  async run_diagnostics(scope: 'all' | 'self_bootstrap' | 'capability' = 'all'): Promise<DoctorReport> {
    const checks: DoctorCheck[] = []

    // Self-bootstrap checks (always run first)
    checks.push(this.check_bun())
    checks.push(this.check_sqlite())
    checks.push(this.check_shell())
    checks.push(this.check_air_writability())

    const bootstrap_passed = checks.every(c => c.passed)
    if (!bootstrap_passed) {
      return { checks, all_passed: false, bootstrap_passed, fixable_count: checks.filter(c => c.fixable).length }
    }

    if (scope === 'self_bootstrap') {
      return { checks, all_passed: bootstrap_passed, bootstrap_passed, fixable_count: 0 }
    }

    // Capability checks
    checks.push(this.check_git())
    checks.push(this.check_node())
    checks.push(this.check_project_structure())

    const all_passed = checks.every(c => c.passed)
    return { checks, all_passed, bootstrap_passed: true, fixable_count: checks.filter(c => c.fixable).length }
  }

  /**
   * Attempt to fix an issue.
   * TODO(P8): Implement self-repair logic per DD §16.1.
   * INV-4: dependency installs originate here.
   */
  async fix(check_name: string): Promise<{ ok: boolean; message: string }> {
    // Implement self-repair logic per DD §16.1
    switch (check_name) {
      case 'bun': {
        return { ok: false, message: 'Bun installation requires manual setup. Run: curl -fsSL https://bun.sh/install | bash' }
      }
      case 'git': {
        return { ok: false, message: 'Git installation requires manual setup. Run: apt install git (Debian/Ubuntu)' }
      }
      case 'node': {
        return { ok: false, message: 'Node.js installation requires manual setup. Run: https://nodejs.org' }
      }
      case 'air_writability': {
        try {
          const air_dir = join(this.project_root, '.air')
          if (!existsSync(air_dir)) {
            mkdirSync(air_dir, { recursive: true })
          }
          mkdirSync(join(air_dir, 'shared'), { recursive: true })
          mkdirSync(join(air_dir, 'local'), { recursive: true })
          mkdirSync(join(air_dir, 'sessions'), { recursive: true })
          mkdirSync(join(air_dir, 'logs'), { recursive: true })
          return { ok: true, message: 'Created .air directory structure' }
        } catch (e) {
          return { ok: false, message: `Failed to create .air directory: ${e}` }
        }
      }
      case 'project_structure': {
        return { ok: false, message: 'Run air init to create project structure' }
      }
      default:
        return { ok: false, message: `Fix for ${check_name} not implemented` }
    }
  }

  private check_bun(): DoctorCheck {
    try {
      const version = execFileSync('bun', ['--version'], { stdio: 'pipe', timeout: 5000 }).toString().trim()
      return { name: 'bun', category: 'self_bootstrap', passed: true, message: `Bun ${version} found`, fixable: false }
    } catch {
      return { name: 'bun', category: 'self_bootstrap', passed: false, message: 'Bun not found', fixable: true, fix: 'Install Bun: curl -fsSL https://bun.sh/install | bash' }
    }
  }

  private check_sqlite(): DoctorCheck {
    return { name: 'sqlite', category: 'self_bootstrap', passed: true, message: 'SQLite via Bun built-in', fixable: false }
  }

  private check_shell(): DoctorCheck {
    return { name: 'shell', category: 'self_bootstrap', passed: true, message: 'Shell available', fixable: false }
  }

  private check_air_writability(): DoctorCheck {
    const air_dir = join(this.project_root, '.air')
    try {
      if (!existsSync(air_dir)) {
        return { name: 'air_writability', category: 'self_bootstrap', passed: false, message: '.air directory does not exist', fixable: true, fix: 'Run project.initialize()' }
      }
      accessSync(air_dir, constants.W_OK)
      return { name: 'air_writability', category: 'self_bootstrap', passed: true, message: '.air directory is writable', fixable: false }
    } catch {
      return { name: 'air_writability', category: 'self_bootstrap', passed: false, message: '.air directory is not writable', fixable: true }
    }
  }

  private check_git(): DoctorCheck {
    try {
      execFileSync('git', ['--version'], { stdio: 'pipe', timeout: 5000 })
      return { name: 'git', category: 'capability', passed: true, message: 'Git available', fixable: false }
    } catch {
      return { name: 'git', category: 'capability', passed: false, message: 'Git not found', fixable: true, fix: 'Install Git: apt install git' }
    }
  }

  private check_node(): DoctorCheck {
    try {
      const version = execFileSync('node', ['--version'], { stdio: 'pipe', timeout: 5000 }).toString().trim()
      return { name: 'node', category: 'capability', passed: true, message: `Node.js ${version} available`, fixable: false }
    } catch {
      return { name: 'node', category: 'capability', passed: false, message: 'Node.js not found', fixable: true, fix: 'Install Node.js: https://nodejs.org' }
    }
  }

  private check_project_structure(): DoctorCheck {
    const required = ['package.json', 'tsconfig.json']
    const missing: string[] = []
    for (const file of required) {
      if (!existsSync(join(this.project_root, file))) {
        missing.push(file)
      }
    }
    if (missing.length > 0) {
      return { name: 'project_structure', category: 'project', passed: false, message: `Missing: ${missing.join(', ')}`, fixable: true, fix: 'Run air init to create project structure' }
    }
    return { name: 'project_structure', category: 'project', passed: true, message: 'Project structure valid', fixable: false }
  }
}