import chalk from 'chalk';
import inquirer from 'inquirer';
import { resolve, join, basename } from 'path';
import { existsSync, writeFileSync, mkdirSync } from 'fs';
import { detectProject } from '../detectors/index.js';
import { createProjectConfig, saveProjectConfig, loadGlobalConfig } from '../utils/config-manager.js';
import { processTemplate, getTemplateFiles, buildTemplateContext, loadTemplate, renderTemplate, TEMPLATES_DIR } from '../utils/template-engine.js';

/**
 * Init command - initialize Docker configuration for a project
 */
export async function initCommand(path, options) {
  const projectPath = resolve(path);

  if (!existsSync(projectPath)) {
    throw new Error(`Path does not exist: ${projectPath}`);
  }

  const projectName = basename(projectPath);
  console.log(chalk.blue('Initializing Docker configuration for:'), projectName);
  console.log();

  // Detect project type
  let detection;
  if (options.type) {
    // Force specific type
    detection = {
      type: options.type,
      dockerizable: true,
      template: options.type.replace('-', '/'),
      port: options.port || 3000,
      projectName,
      projectPath
    };
    console.log(chalk.yellow('Using forced type:'), options.type);
  } else {
    detection = await detectProject(projectPath);
  }

  if (!detection.dockerizable) {
    console.log(chalk.red('✗ Project is not dockerizable:'), detection.reason);
    return;
  }

  console.log(chalk.green('✓ Detected:'), detection.description || detection.type);
  console.log();

  // Check for existing files
  const existingFiles = checkExistingFiles(projectPath);
  if (existingFiles.length > 0 && !options.overwrite) {
    console.log(chalk.yellow('Existing Docker files found:'));
    existingFiles.forEach(f => console.log(chalk.gray(`  - ${f}`)));
    console.log();

    if (options.interactive !== false) {
      const { proceed } = await inquirer.prompt([{
        type: 'confirm',
        name: 'proceed',
        message: 'Overwrite existing files?',
        default: false
      }]);

      if (!proceed) {
        console.log(chalk.yellow('Cancelled.'));
        return;
      }
    } else {
      console.log(chalk.yellow('Use --overwrite to replace existing files.'));
      return;
    }
  }

  // Interactive configuration
  let config;
  if (options.interactive !== false) {
    config = await interactiveConfig(projectName, detection, options);
  } else {
    config = createProjectConfig(projectName, detection, {
      port: options.port,
      name: options.name
    });
  }

  // Dry run - just show what would be generated
  if (options.dryRun) {
    console.log(chalk.blue('Dry run - would generate:'));
    console.log();
    const files = getFilesToGenerate(detection, config);
    files.forEach(f => console.log(chalk.gray(`  - ${f.output}`)));
    console.log();
    console.log(chalk.gray('Configuration:'));
    console.log(JSON.stringify(config, null, 2));
    return;
  }

  // Generate files
  console.log();
  console.log(chalk.blue('Generating files...'));

  const generatedFiles = await generateFiles(projectPath, detection, config);

  console.log();
  generatedFiles.forEach(file => {
    console.log(chalk.green('✓'), file);
  });

  console.log();
  console.log(chalk.green('Docker configuration initialized successfully!'));
  console.log();
  console.log(chalk.blue('Next steps:'));
  console.log(chalk.gray('  1. Review generated files'));
  console.log(chalk.gray('  2. Create .env file from .env.example (if needed)'));
  console.log(chalk.gray('  3. Build and test locally:'), 'docker compose up --build');
  console.log(chalk.gray('  4. Deploy using:'), '.\\deploy-docker-auto.ps1', chalk.gray('or'), '.\\build-image-tar.ps1');
}

/**
 * Interactive configuration prompts
 */
async function interactiveConfig(projectName, detection, options) {
  const globalConfig = loadGlobalConfig();

  const sanitizedName = projectName.toLowerCase().replace(/[^a-z0-9-]/g, '-');

  const answers = await inquirer.prompt([
    {
      type: 'input',
      name: 'containerName',
      message: 'Container name:',
      default: options.name || sanitizedName
    },
    {
      type: 'number',
      name: 'port',
      message: 'Application port:',
      default: options.port || detection.port || 3000
    },
    {
      type: 'confirm',
      name: 'useEnvFile',
      message: 'Use .env file for configuration?',
      default: true
    },
    {
      type: 'confirm',
      name: 'configureSSH',
      message: 'Configure SSH deployment?',
      default: true
    }
  ]);

  let sshConfig = {};
  if (answers.configureSSH) {
    sshConfig = await inquirer.prompt([
      {
        type: 'input',
        name: 'sshHost',
        message: 'SSH host:',
        default: globalConfig.deployment?.sshHost || '192.168.8.178'
      },
      {
        type: 'input',
        name: 'sshUser',
        message: 'SSH user:',
        default: globalConfig.deployment?.sshUser || 'deployer'
      }
    ]);
  }

  // Ask about volumes for projects that might need persistence
  let volumes = [];
  if (detection.type.includes('express') || detection.type.includes('python')) {
    const { needsVolumes } = await inquirer.prompt([{
      type: 'confirm',
      name: 'needsVolumes',
      message: 'Does this project need persistent data volumes?',
      default: false
    }]);

    if (needsVolumes) {
      const { volumePath } = await inquirer.prompt([{
        type: 'input',
        name: 'volumePath',
        message: 'Volume mount (local:container):',
        default: './data:/app/data'
      }]);
      volumes = [volumePath];
    }
  }

  return createProjectConfig(projectName, detection, {
    name: answers.containerName,
    port: answers.port,
    envFile: answers.useEnvFile,
    sshHost: sshConfig.sshHost,
    sshUser: sshConfig.sshUser,
    volumes
  });
}

/**
 * Check for existing Docker files
 */
function checkExistingFiles(projectPath) {
  const filesToCheck = [
    'Dockerfile',
    'docker-compose.yml',
    'docker-compose.yaml',
    '.dockerignore',
    'docker-deployment.json'
  ];

  return filesToCheck.filter(f => existsSync(join(projectPath, f)));
}

/**
 * Get list of files to generate
 */
function getFilesToGenerate(detection, config) {
  const files = [
    { output: 'Dockerfile' },
    { output: 'docker-compose.yml' },
    { output: '.dockerignore' },
    { output: 'docker-deployment.json' },
    { output: '.env.example' },
    { output: 'deploy-docker-auto.ps1' },
    { output: 'build-image-tar.ps1' },
    { output: 'README.DOCKER.md' }
  ];

  // Add nginx.conf for static sites
  if (detection.type === 'static-nginx' || detection.type === 'flutter-web') {
    files.push({ output: 'nginx.conf' });
  }

  return files;
}

/**
 * Generate all Docker files for the project
 */
async function generateFiles(projectPath, detection, config) {
  const context = buildTemplateContext(config, detection);
  const generatedFiles = [];

  // 1. Generate Dockerfile
  try {
    const dockerfileTemplate = loadTemplate(`${detection.template}/Dockerfile.template`);
    const dockerfile = renderTemplate(dockerfileTemplate, context);
    writeFileSync(join(projectPath, 'Dockerfile'), dockerfile);
    generatedFiles.push('Dockerfile');
  } catch (error) {
    console.log(chalk.yellow(`Warning: Could not generate Dockerfile: ${error.message}`));
    // Use fallback template
    const fallbackDockerfile = generateFallbackDockerfile(detection, context);
    writeFileSync(join(projectPath, 'Dockerfile'), fallbackDockerfile);
    generatedFiles.push('Dockerfile (fallback)');
  }

  // 2. Generate docker-compose.yml
  try {
    const composeTemplate = loadTemplate(`${detection.template}/docker-compose.yml.template`);
    const compose = renderTemplate(composeTemplate, context);
    writeFileSync(join(projectPath, 'docker-compose.yml'), compose);
    generatedFiles.push('docker-compose.yml');
  } catch (error) {
    const fallbackCompose = generateFallbackCompose(detection, context);
    writeFileSync(join(projectPath, 'docker-compose.yml'), fallbackCompose);
    generatedFiles.push('docker-compose.yml (fallback)');
  }

  // 3. Generate .dockerignore
  try {
    const ignoreTemplate = loadTemplate(`${detection.template}/.dockerignore.template`);
    const dockerignore = renderTemplate(ignoreTemplate, context);
    writeFileSync(join(projectPath, '.dockerignore'), dockerignore);
    generatedFiles.push('.dockerignore');
  } catch (error) {
    const fallbackIgnore = generateFallbackDockerignore(detection);
    writeFileSync(join(projectPath, '.dockerignore'), fallbackIgnore);
    generatedFiles.push('.dockerignore (fallback)');
  }

  // 4. Generate nginx.conf for static sites
  if (detection.type === 'static-nginx' || detection.type === 'flutter-web') {
    try {
      const nginxTemplate = loadTemplate(`${detection.template}/nginx.conf.template`);
      const nginx = renderTemplate(nginxTemplate, context);
      writeFileSync(join(projectPath, 'nginx.conf'), nginx);
      generatedFiles.push('nginx.conf');
    } catch (error) {
      const fallbackNginx = generateFallbackNginxConf();
      writeFileSync(join(projectPath, 'nginx.conf'), fallbackNginx);
      generatedFiles.push('nginx.conf (fallback)');
    }
  }

  // 5. Save project config
  saveProjectConfig(projectPath, config);
  generatedFiles.push('docker-deployment.json');

  // 6. Generate .env.example
  const envExample = generateEnvExample(detection, context);
  writeFileSync(join(projectPath, '.env.example'), envExample);
  generatedFiles.push('.env.example');

  // 7. Generate PowerShell scripts
  const deployScript = generateDeployScript(context);
  writeFileSync(join(projectPath, 'deploy-docker-auto.ps1'), deployScript);
  generatedFiles.push('deploy-docker-auto.ps1');

  const buildScript = generateBuildScript(context);
  writeFileSync(join(projectPath, 'build-image-tar.ps1'), buildScript);
  generatedFiles.push('build-image-tar.ps1');

  // 8. Generate README.DOCKER.md
  const readme = generateDockerReadme(detection, context, config);
  writeFileSync(join(projectPath, 'README.DOCKER.md'), readme);
  generatedFiles.push('README.DOCKER.md');

  return generatedFiles;
}

/**
 * Generate fallback Dockerfile when template is not found
 */
function generateFallbackDockerfile(detection, context) {
  if (detection.type.startsWith('nodejs')) {
    return `FROM node:${context.NODE_VERSION}-alpine

WORKDIR /app

COPY package.json package-lock.json ./
RUN npm ci --omit=dev

COPY . .

ENV NODE_ENV=production
ENV PORT=${context.PORT}

EXPOSE ${context.PORT}

CMD ["node", "${context.ENTRY_POINT}"]
`;
  }

  if (detection.type.startsWith('python')) {
    return `FROM python:${context.PYTHON_VERSION}-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

ENV PYTHONUNBUFFERED=1

EXPOSE ${context.PORT}

CMD ["python", "${context.ENTRY_POINT}"]
`;
  }

  if (detection.type.startsWith('dotnet')) {
    return `FROM mcr.microsoft.com/dotnet/sdk:${context.DOTNET_VERSION} AS build
WORKDIR /src
COPY . .
RUN dotnet restore
RUN dotnet publish -c Release -o /app/publish

FROM mcr.microsoft.com/dotnet/aspnet:${context.DOTNET_VERSION}
WORKDIR /app
COPY --from=build /app/publish .
ENV ASPNETCORE_URLS=http://+:${context.PORT}
EXPOSE ${context.PORT}
ENTRYPOINT ["dotnet", "${context.ENTRY_POINT}"]
`;
  }

  // Static site fallback
  return `FROM nginx:alpine
COPY . /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]
`;
}

/**
 * Generate fallback docker-compose.yml
 */
function generateFallbackCompose(detection, context) {
  let compose = `services:
  ${context.PROJECT_NAME}:
    build: .
    container_name: ${context.PROJECT_NAME}
    restart: unless-stopped
    ports:
      - "\${HOST_PORT:-${context.PORT}}:${context.PORT}"
`;

  if (context.USE_ENV_FILE) {
    compose += `    env_file:
      - .env
`;
  }

  compose += `    environment:
      NODE_ENV: production
`;

  if (context.HAS_VOLUMES && context.VOLUMES.length > 0) {
    compose += `    volumes:\n`;
    context.VOLUMES.forEach(vol => {
      compose += `      - ${vol}\n`;
    });
  }

  if (context.EXTRA_HOSTS) {
    compose += `    extra_hosts:
      - "host.docker.internal:host-gateway"
`;
  }

  return compose;
}

/**
 * Generate fallback .dockerignore
 */
function generateFallbackDockerignore(detection) {
  return `node_modules
npm-debug.log
.git
.gitignore
.env
.env.local
*.tar
*.tar.gz
Dockerfile
docker-compose.yml
docker-compose.yaml
.dockerignore
README.md
README.DOCKER.md
.vscode
.idea
coverage
.nyc_output
*.log
`;
}

/**
 * Generate fallback nginx.conf
 */
function generateFallbackNginxConf() {
  return `server {
    listen 80;
    server_name localhost;

    root /usr/share/nginx/html;
    index index.html;

    location / {
        try_files $uri $uri/ /index.html;
    }

    location ~* \\.(jpg|jpeg|png|gif|ico|css|js|svg|woff|woff2|ttf|eot)$ {
        expires 1y;
        add_header Cache-Control "public, immutable";
    }

    gzip on;
    gzip_vary on;
    gzip_types text/plain text/css application/json application/javascript text/xml application/xml;
}
`;
}

/**
 * Generate .env.example file
 */
function generateEnvExample(detection, context) {
  let env = `# Application Configuration
PORT=${context.PORT}
NODE_ENV=production

# Docker Host Port (change to avoid conflicts)
HOST_PORT=${context.PORT}
`;

  if (context.HAS_SSH) {
    env += `
# SSH Deployment (used by deploy-docker-auto.ps1)
SSH_HOST=${context.SSH_HOST}
SSH_USER=${context.SSH_USER}
`;
  }

  return env;
}

/**
 * Generate deploy-docker-auto.ps1 (SSH automation)
 */
function generateDeployScript(context) {
  return `# Docker Deploy Script (SSH Automation)
# Generated by docker-deployment-manager

param(
    [string]$Platform = "linux/amd64",
    [string]$ImageTag = "${context.PROJECT_NAME}:latest",
    [string]$TarFile = "${context.PROJECT_NAME}.tar",
    [switch]$SkipBuild,
    [switch]$SkipDeploy
)

$ErrorActionPreference = "Stop"

# Load config if exists
$config = $null
if (Test-Path "docker-deployment.json") {
    $config = Get-Content "docker-deployment.json" | ConvertFrom-Json
}

if (-not $SkipBuild) {
    Write-Host "Building Docker image..." -ForegroundColor Cyan
    docker buildx build --platform $Platform -t $ImageTag --load .
    if ($LASTEXITCODE -ne 0) { throw "Docker build failed" }

    Write-Host "Saving image to tar..." -ForegroundColor Cyan
    docker save -o $TarFile $ImageTag
    if ($LASTEXITCODE -ne 0) { throw "Docker save failed" }

    Write-Host "Created: $TarFile" -ForegroundColor Green
}

if (-not $SkipDeploy) {
    $sshHost = if ($config) { $config.deployment.sshHost } else { "${context.SSH_HOST}" }
    $sshUser = if ($config) { $config.deployment.sshUser } else { "${context.SSH_USER}" }
    $targetPath = if ($config) { $config.deployment.targetPath } else { "${context.TARGET_PATH}" }

    if (-not $sshHost -or -not $sshUser) {
        Write-Host "SSH not configured. Use build-image-tar.ps1 for manual deployment." -ForegroundColor Yellow
        exit 0
    }

    $sshTarget = "\${sshUser}@\${sshHost}"

    Write-Host "Creating target directory on server..." -ForegroundColor Cyan
    ssh $sshTarget "mkdir -p $targetPath"

    Write-Host "Copying files to server..." -ForegroundColor Cyan
    scp $TarFile "\${sshTarget}:\${targetPath}/"
    scp docker-compose.yml "\${sshTarget}:\${targetPath}/"
    if (Test-Path ".env") {
        scp .env "\${sshTarget}:\${targetPath}/"
    }

    Write-Host "Loading and starting container on server..." -ForegroundColor Cyan
    ssh $sshTarget "cd $targetPath && docker load -i $TarFile && docker compose down 2>/dev/null; docker compose up -d"

    Write-Host ""
    Write-Host "Deployment complete!" -ForegroundColor Green
    Write-Host "View logs: ssh $sshTarget 'cd $targetPath && docker compose logs -f'" -ForegroundColor Gray
}
`;
}

/**
 * Generate build-image-tar.ps1 (manual workflow)
 */
function generateBuildScript(context) {
  return `# Docker Build Script (Manual Workflow)
# Generated by docker-deployment-manager

param(
    [string]$Platform = "linux/amd64",
    [string]$ImageTag = "${context.PROJECT_NAME}:latest",
    [string]$TarFile = "${context.PROJECT_NAME}.tar"
)

$ErrorActionPreference = "Stop"

Write-Host "Building Docker image..." -ForegroundColor Cyan
docker buildx build --platform $Platform -t $ImageTag --load .
if ($LASTEXITCODE -ne 0) { throw "Docker build failed" }

Write-Host "Saving image to tar..." -ForegroundColor Cyan
docker save -o $TarFile $ImageTag
if ($LASTEXITCODE -ne 0) { throw "Docker save failed" }

Write-Host ""
Write-Host "Build complete!" -ForegroundColor Green
Write-Host "Created: $TarFile" -ForegroundColor Green
Write-Host ""
Write-Host "Manual deployment instructions:" -ForegroundColor Yellow
Write-Host "1. scp $TarFile user@server:~/containers/${context.PROJECT_NAME}/files/" -ForegroundColor Gray
Write-Host "2. scp docker-compose.yml user@server:~/containers/${context.PROJECT_NAME}/files/" -ForegroundColor Gray
Write-Host "3. ssh user@server" -ForegroundColor Gray
Write-Host "4. cd ~/containers/${context.PROJECT_NAME}/files" -ForegroundColor Gray
Write-Host "5. docker load -i $TarFile" -ForegroundColor Gray
Write-Host "6. docker compose up -d" -ForegroundColor Gray
`;
}

/**
 * Generate README.DOCKER.md
 */
function generateDockerReadme(detection, context, config) {
  return `# Docker Deployment

This project is configured for Docker deployment.

## Project Info

- **Type:** ${detection.description || detection.type}
- **Port:** ${context.PORT}
- **Image:** ${context.PROJECT_NAME}:latest

## Quick Start

### Build and Run Locally

\`\`\`bash
docker compose up --build
\`\`\`

Then visit: http://localhost:${context.PORT}

### Deploy to Server

**Option 1: Automated SSH Deployment**

\`\`\`powershell
.\\deploy-docker-auto.ps1
\`\`\`

**Option 2: Manual Deployment**

\`\`\`powershell
# Build
.\\build-image-tar.ps1

# Copy to server
scp ${context.PROJECT_NAME}.tar user@server:~/containers/${context.PROJECT_NAME}/files/
scp docker-compose.yml user@server:~/containers/${context.PROJECT_NAME}/files/

# On server
ssh user@server
cd ~/containers/${context.PROJECT_NAME}/files
docker load -i ${context.PROJECT_NAME}.tar
docker compose up -d
\`\`\`

## Configuration

### Environment Variables

Copy \`.env.example\` to \`.env\` and configure:

\`\`\`bash
cp .env.example .env
\`\`\`

Key variables:
- \`PORT\` - Application port (default: ${context.PORT})
- \`HOST_PORT\` - Docker host port mapping

### Deployment Settings

Edit \`docker-deployment.json\` to configure:
- SSH host and user
- Target deployment path
- Build settings

## Files

- \`Dockerfile\` - Container build instructions
- \`docker-compose.yml\` - Container runtime configuration
- \`.dockerignore\` - Files excluded from image
- \`docker-deployment.json\` - Deployment configuration
- \`deploy-docker-auto.ps1\` - Automated SSH deployment script
- \`build-image-tar.ps1\` - Manual build script

## Useful Commands

\`\`\`bash
# View logs
docker compose logs -f

# Stop container
docker compose down

# Rebuild and restart
docker compose up --build -d

# Shell into container
docker compose exec ${context.PROJECT_NAME} sh
\`\`\`

---
Generated by docker-deployment-manager
`;
}