#!/usr/bin/env node

/**
 * Upload manuals assets to any S3-compatible object storage (Cloudflare R2, MinIO, etc.)
 * 
 * Usage:
 *   node scripts/upload-to-r2.js --type manuals --dry-run
 *   node scripts/upload-to-r2.js --type thumbnails
 *   node scripts/upload-to-r2.js --type all
 * 
 * Environment variables required:
 *   S3_ENDPOINT_URL or CLOUDFLARE_R2_ENDPOINT
 *   AWS_ACCESS_KEY_ID / AWS_SECRET_ACCESS_KEY (or CLOUDFLARE_* variants)
 */

import { S3Client, PutObjectCommand, ListObjectsV2Command, HeadObjectCommand } from '@aws-sdk/client-s3';
import { readdir, stat, readFile } from 'fs/promises';
import { join, relative, dirname } from 'path';
import { existsSync } from 'fs';

const ACCOUNT_ID = process.env.CLOUDFLARE_ACCOUNT_ID || 'bd6f76304a840ba11b75f9ced84264f4';
const ENDPOINT =
  process.env.MANUALS_STORAGE_ENDPOINT ||
  process.env.S3_ENDPOINT_URL ||
  process.env.CLOUDFLARE_R2_ENDPOINT ||
  `https://${ACCOUNT_ID}.r2.cloudflarestorage.com`;
const ACCESS_KEY_ID =
  process.env.MANUALS_STORAGE_ACCESS_KEY_ID ||
  process.env.CLOUDFLARE_R2_ACCESS_KEY_ID ||
  process.env.AWS_ACCESS_KEY_ID ||
  process.env.AWS_ACCESS_KEY;
const SECRET_ACCESS_KEY =
  process.env.MANUALS_STORAGE_SECRET_ACCESS_KEY ||
  process.env.CLOUDFLARE_R2_SECRET_ACCESS_KEY ||
  process.env.AWS_SECRET_ACCESS_KEY ||
  process.env.AWS_SECRET_KEY;
const REGION = process.env.MANUALS_STORAGE_REGION || process.env.AWS_REGION || 'us-east-1';
const FORCE_PATH_STYLE = ['1', 'true', 'yes', 'on'].includes(
  String(process.env.MANUALS_STORAGE_FORCE_PATH_STYLE || process.env.AWS_S3_FORCE_PATH_STYLE || 'true').toLowerCase()
);

// Bucket names
const MANUALS_BUCKET = process.env.R2_MANUALS_BUCKET || 'vending-vm-manuals';
const THUMBNAILS_BUCKET = process.env.R2_THUMBNAILS_BUCKET || 'vending-vm-thumbnails';

// Source directories (relative to project root)
const MANUALS_DATA_ROOT = process.env.MANUALS_DATA_ROOT ||
  (existsSync(join(process.cwd(), '..', 'manuals-data'))
    ? join(process.cwd(), '..', 'manuals-data')
    : '/Users/matthewcall/Documents/VS Code Projects/Rocky Mountain Vending/manuals-data');
const MANUALS_SOURCE = join(MANUALS_DATA_ROOT, 'manuals');
const THUMBNAILS_SOURCE = join(MANUALS_DATA_ROOT, 'thumbnails');

// Parse command line arguments
const args = process.argv.slice(2);
const typeArg = args.find(arg => arg.startsWith('--type='))?.split('=')[1] || 
                (args.includes('--type') ? args[args.indexOf('--type') + 1] : null);
const uploadType = typeArg || 'all';
const dryRun = args.includes('--dry-run') || args.includes('-d');
const incremental = args.includes('--incremental') || args.includes('-i');

if (!ACCESS_KEY_ID || !SECRET_ACCESS_KEY || !ENDPOINT) {
  console.error('❌ Error: S3-compatible manuals storage env vars are incomplete');
  console.error('   Set S3_ENDPOINT_URL plus AWS_ACCESS_KEY_ID / AWS_SECRET_ACCESS_KEY (or CLOUDFLARE_* equivalents)');
  process.exit(1);
}

// Initialize S3 client
const s3Client = new S3Client({
  region: REGION,
  endpoint: ENDPOINT,
  forcePathStyle: FORCE_PATH_STYLE,
  credentials: {
    accessKeyId: ACCESS_KEY_ID,
    secretAccessKey: SECRET_ACCESS_KEY,
  },
});

/**
 * Check if object exists in R2
 */
async function objectExists(bucket, key) {
  try {
    await s3Client.send(new HeadObjectCommand({ Bucket: bucket, Key: key }));
    return true;
  } catch (error) {
    if (error.name === 'NotFound' || error.$metadata?.httpStatusCode === 404) {
      return false;
    }
    throw error;
  }
}

/**
 * Get content type based on file extension
 */
function getContentType(filename) {
  const ext = filename.split('.').pop()?.toLowerCase();
  const types = {
    'pdf': 'application/pdf',
    'jpg': 'image/jpeg',
    'jpeg': 'image/jpeg',
    'png': 'image/png',
    'webp': 'image/webp',
    'gif': 'image/gif',
  };
  return types[ext] || 'application/octet-stream';
}

/**
 * Upload a single file to R2
 */
async function uploadFile(bucket, key, filePath, dryRun = false) {
  if (dryRun) {
    console.log(`  [DRY RUN] Would upload: ${key}`);
    return { uploaded: false, skipped: false, key };
  }

  try {
    const fileContent = await readFile(filePath);
    const contentType = getContentType(key);

    await s3Client.send(new PutObjectCommand({
      Bucket: bucket,
      Key: key,
      Body: fileContent,
      ContentType: contentType,
    }));

    return { uploaded: true, skipped: false, key };
  } catch (error) {
    console.error(`  ❌ Error uploading ${key}:`, error.message);
    return { uploaded: false, skipped: false, key, error: error.message };
  }
}

/**
 * Recursively get all files from a directory
 */
async function getAllFiles(dir, baseDir = dir) {
  const files = [];
  const entries = await readdir(dir, { withFileTypes: true });

  for (const entry of entries) {
    const fullPath = join(dir, entry.name);
    if (entry.isDirectory()) {
      const subFiles = await getAllFiles(fullPath, baseDir);
      files.push(...subFiles);
    } else {
      const relativePath = relative(baseDir, fullPath);
      files.push({ fullPath, relativePath });
    }
  }

  return files;
}

/**
 * Upload directory to R2 bucket
 */
async function uploadDirectory(sourceDir, bucket, bucketName, dryRun = false, incremental = false) {
  if (!existsSync(sourceDir)) {
    console.error(`❌ Source directory does not exist: ${sourceDir}`);
    return { uploaded: 0, skipped: 0, failed: 0, total: 0 };
  }

  console.log(`\n📁 Scanning: ${sourceDir}`);
  const files = await getAllFiles(sourceDir);
  console.log(`   Found ${files.length} files`);

  if (files.length === 0) {
    console.log('   No files to upload');
    return { uploaded: 0, skipped: 0, failed: 0, total: 0 };
  }

  let uploaded = 0;
  let skipped = 0;
  let failed = 0;

  console.log(`\n${dryRun ? '🔍 [DRY RUN]' : '⬆️ '} Uploading to bucket: ${bucketName}`);

  for (let i = 0; i < files.length; i++) {
    const { fullPath, relativePath } = files[i];
    const key = relativePath.replace(/\\/g, '/'); // Normalize path separators

    // Check if file exists (incremental mode)
    if (incremental && !dryRun) {
      const exists = await objectExists(bucket, key);
      if (exists) {
        skipped++;
        if ((i + 1) % 50 === 0) {
          process.stdout.write(`\r   Progress: ${i + 1}/${files.length} (${uploaded} uploaded, ${skipped} skipped, ${failed} failed)`);
        }
        continue;
      }
    }

    const result = await uploadFile(bucket, key, fullPath, dryRun);

    if (result.uploaded) {
      uploaded++;
    } else if (result.error) {
      failed++;
    } else if (result.skipped) {
      skipped++;
    }

    // Progress indicator
    if ((i + 1) % 10 === 0 || i + 1 === files.length) {
      process.stdout.write(`\r   Progress: ${i + 1}/${files.length} (${uploaded} uploaded, ${skipped} skipped, ${failed} failed)`);
    }
  }

  console.log('\n');

  return { uploaded, skipped, failed, total: files.length };
}

/**
 * Main upload function
 */
async function main() {
  console.log('🚀 Manuals Object Storage Upload Script');
  console.log(`   Endpoint: ${ENDPOINT}`);
  console.log(`   Mode: ${dryRun ? 'DRY RUN' : 'UPLOAD'}`);
  console.log(`   Incremental: ${incremental ? 'Yes' : 'No'}`);
  console.log(`   Type: ${uploadType}`);

  const results = {
    manuals: { uploaded: 0, skipped: 0, failed: 0, total: 0 },
    thumbnails: { uploaded: 0, skipped: 0, failed: 0, total: 0 },
  };

  if (uploadType === 'manuals' || uploadType === 'all') {
    console.log('\n📚 Uploading manuals...');
    results.manuals = await uploadDirectory(
      MANUALS_SOURCE,
      MANUALS_BUCKET,
      MANUALS_BUCKET,
      dryRun,
      incremental
    );
  }

  if (uploadType === 'thumbnails' || uploadType === 'all') {
    console.log('\n🖼️  Uploading thumbnails...');
    results.thumbnails = await uploadDirectory(
      THUMBNAILS_SOURCE,
      THUMBNAILS_BUCKET,
      THUMBNAILS_BUCKET,
      dryRun,
      incremental
    );
  }

  // Summary
  console.log('\n📊 Upload Summary:');
  if (uploadType === 'manuals' || uploadType === 'all') {
    console.log(`   Manuals: ${results.manuals.uploaded} uploaded, ${results.manuals.skipped} skipped, ${results.manuals.failed} failed (${results.manuals.total} total)`);
  }
  if (uploadType === 'thumbnails' || uploadType === 'all') {
    console.log(`   Thumbnails: ${results.thumbnails.uploaded} uploaded, ${results.thumbnails.skipped} skipped, ${results.thumbnails.failed} failed (${results.thumbnails.total} total)`);
  }

  const totalUploaded = results.manuals.uploaded + results.thumbnails.uploaded;
  const totalFailed = results.manuals.failed + results.thumbnails.failed;

  if (totalFailed > 0) {
    console.log(`\n⚠️  ${totalFailed} file(s) failed to upload`);
    process.exit(1);
  } else if (dryRun) {
    console.log('\n✅ Dry run completed. Remove --dry-run to actually upload files.');
  } else {
    console.log(`\n✅ Successfully uploaded ${totalUploaded} file(s) to R2`);
  }
}

main().catch(error => {
  console.error('\n❌ Fatal error:', error);
  process.exit(1);
});