#!/usr/bin/env node

const fs = require('fs');
const path = require('path');

// Color output helpers
const colors = {
  red: '\x1b[31m',
  green: '\x1b[32m',
  yellow: '\x1b[33m',
  blue: '\x1b[34m',
  reset: '\x1b[0m'
};

function log(message, color = 'reset') {
  console.log(`${colors[color]}${message}${colors.reset}`);
}

function error(message) {
  log(`❌ ${message}`, 'red');
}

function success(message) {
  log(`✅ ${message}`, 'green');
}

function warn(message) {
  log(`⚠️  ${message}`, 'yellow');
}

function info(message) {
  log(`ℹ️  ${message}`, 'blue');
}

// Plugin schema validation
function validatePlugin(pluginPath) {
  if (!fs.existsSync(pluginPath)) {
    throw new Error(`Plugin file not found: ${pluginPath}`);
  }

  let plugin;
  try {
    plugin = JSON.parse(fs.readFileSync(pluginPath, 'utf8'));
  } catch (e) {
    throw new Error(`Invalid JSON syntax: ${e.message}`);
  }

  const errors = [];
  const warnings = [];

  // Required fields validation
  const requiredFields = [
    'robotId',
    'name',
    'platform',
    'version',
    'pluginApiVersion',
    'hriStudioVersion',
    'trustLevel',
    'category'
  ];

  requiredFields.forEach(field => {
    if (!plugin[field]) {
      errors.push(`Missing required field: ${field}`);
    }
  });

  // Field format validation
  if (plugin.robotId && !/^[a-z0-9-]+$/.test(plugin.robotId)) {
    errors.push('robotId must be lowercase with hyphens only');
  }

  if (plugin.version && !/^\d+\.\d+\.\d+/.test(plugin.version)) {
    errors.push('version must follow semantic versioning (e.g., 1.0.0)');
  }

  if (plugin.trustLevel && !['official', 'verified', 'community'].includes(plugin.trustLevel)) {
    errors.push(`Invalid trustLevel: ${plugin.trustLevel}. Must be: official, verified, or community`);
  }

  // Category validation
  const validCategories = [
    'mobile-robot',
    'humanoid-robot',
    'manipulator',
    'drone',
    'sensor-platform',
    'simulation'
  ];

  if (plugin.category && !validCategories.includes(plugin.category)) {
    errors.push(`Invalid category: ${plugin.category}. Valid categories: ${validCategories.join(', ')}`);
  }

  // Actions validation
  if (!plugin.actions || !Array.isArray(plugin.actions)) {
    errors.push('Plugin must have an actions array');
  } else if (plugin.actions.length === 0) {
    warnings.push('Plugin has no actions defined');
  } else {
    plugin.actions.forEach((action, index) => {
      const actionErrors = validateAction(action, index);
      errors.push(...actionErrors);
    });
  }

  // Assets validation
  if (plugin.assets) {
    if (!plugin.assets.thumbnailUrl) {
      errors.push('assets.thumbnailUrl is required');
    }

    // Check if asset paths exist
    const assetChecks = [
      ['thumbnailUrl', plugin.assets.thumbnailUrl],
      ['main image', plugin.assets.images?.main],
      ['logo', plugin.assets.images?.logo]
    ];

    if (plugin.assets.images?.angles) {
      Object.entries(plugin.assets.images.angles).forEach(([angle, assetPath]) => {
        assetChecks.push([`${angle} angle`, assetPath]);
      });
    }

    assetChecks.forEach(([description, assetPath]) => {
      if (assetPath && assetPath.startsWith('assets/')) {
        const fullPath = path.resolve(path.dirname(pluginPath), '..', assetPath);
        if (!fs.existsSync(fullPath)) {
          warnings.push(`Asset not found: ${description} (${assetPath})`);
        }
      }
    });
  } else {
    errors.push('Plugin must have assets definition');
  }

  // Manufacturer validation
  if (!plugin.manufacturer?.name) {
    warnings.push('manufacturer.name is recommended');
  }

  return { errors, warnings, plugin };
}

function validateAction(action, index) {
  const errors = [];

  // Required action fields
  const requiredFields = ['id', 'name', 'category', 'parameterSchema'];
  requiredFields.forEach(field => {
    if (!action[field]) {
      errors.push(`Action ${index}: missing required field '${field}'`);
    }
  });

  // Action ID format
  if (action.id && !/^[a-z_]+$/.test(action.id)) {
    errors.push(`Action ${index}: id must be snake_case (lowercase with underscores)`);
  }

  // Action category validation
  const validActionCategories = ['movement', 'interaction', 'sensors', 'logic'];
  if (action.category && !validActionCategories.includes(action.category)) {
    errors.push(`Action ${index}: invalid category '${action.category}'. Valid: ${validActionCategories.join(', ')}`);
  }

  // Parameter schema validation
  if (action.parameterSchema) {
    if (action.parameterSchema.type !== 'object') {
      errors.push(`Action ${index}: parameterSchema.type must be 'object'`);
    }

    if (!action.parameterSchema.properties) {
      errors.push(`Action ${index}: parameterSchema must have properties`);
    }

    if (!Array.isArray(action.parameterSchema.required)) {
      errors.push(`Action ${index}: parameterSchema.required must be an array`);
    }
  }

  // Communication protocol validation
  const hasRos2 = action.ros2;
  const hasNaoqi = action.naoqi;
  const hasRestApi = action.restApi;

  if (!hasRos2 && !hasNaoqi && !hasRestApi) {
    errors.push(`Action ${index}: must have at least one communication protocol (ros2, naoqi, or restApi)`);
  }

  return errors;
}

// Repository validation
function validateRepository() {
  const repoPath = path.resolve('repository.json');

  if (!fs.existsSync(repoPath)) {
    throw new Error('repository.json not found');
  }

  let repo;
  try {
    repo = JSON.parse(fs.readFileSync(repoPath, 'utf8'));
  } catch (e) {
    throw new Error(`Invalid repository.json: ${e.message}`);
  }

  const errors = [];
  const warnings = [];

  // Required repository fields
  const requiredFields = ['id', 'name', 'apiVersion', 'pluginApiVersion', 'trust'];
  requiredFields.forEach(field => {
    if (!repo[field]) {
      errors.push(`Missing required repository field: ${field}`);
    }
  });

  // Validate plugin count
  const indexPath = path.resolve('plugins/index.json');
  if (fs.existsSync(indexPath)) {
    const index = JSON.parse(fs.readFileSync(indexPath, 'utf8'));
    const actualCount = index.length;
    const reportedCount = repo.stats?.plugins || 0;

    if (actualCount !== reportedCount) {
      errors.push(`Plugin count mismatch: reported ${reportedCount}, actual ${actualCount}`);
    }
  }

  return { errors, warnings, repo };
}

// Update plugin index
function updateIndex() {
  const pluginsDir = path.resolve('plugins');
  const indexPath = path.join(pluginsDir, 'index.json');

  if (!fs.existsSync(pluginsDir)) {
    throw new Error('plugins directory not found');
  }

  const pluginFiles = fs.readdirSync(pluginsDir)
    .filter(file => file.endsWith('.json') && file !== 'index.json')
    .sort();

  fs.writeFileSync(indexPath, JSON.stringify(pluginFiles, null, 2));
  success(`Updated index.json with ${pluginFiles.length} plugins`);

  // Update repository stats
  const repoPath = path.resolve('repository.json');
  if (fs.existsSync(repoPath)) {
    const repo = JSON.parse(fs.readFileSync(repoPath, 'utf8'));
    repo.stats = repo.stats || {};
    repo.stats.plugins = pluginFiles.length;
    fs.writeFileSync(repoPath, JSON.stringify(repo, null, 2));
    success(`Updated repository stats: ${pluginFiles.length} plugins`);
  }
}

// Main CLI
function main() {
  const args = process.argv.slice(2);
  const command = args[0];

  try {
    switch (command) {
      case 'validate':
        const pluginPath = args[1];
        if (!pluginPath) {
          error('Usage: validate <plugin-file>');
          process.exit(1);
        }

        info(`Validating plugin: ${pluginPath}`);
        const { errors, warnings } = validatePlugin(pluginPath);

        if (errors.length > 0) {
          error('Validation failed:');
          errors.forEach(err => console.log(`  - ${err}`));
        }

        if (warnings.length > 0) {
          warn('Warnings:');
          warnings.forEach(warn => console.log(`  - ${warn}`));
        }

        if (errors.length === 0) {
          success('Plugin validation passed!');
          if (warnings.length === 0) {
            success('No warnings found');
          }
        } else {
          process.exit(1);
        }
        break;

      case 'validate-all':
        info('Validating all plugins...');

        // Validate repository
        const repoResult = validateRepository();
        if (repoResult.errors.length > 0) {
          error('Repository validation failed:');
          repoResult.errors.forEach(err => console.log(`  - ${err}`));
          process.exit(1);
        }

        // Validate all plugins
        const indexPath = path.resolve('plugins/index.json');
        if (!fs.existsSync(indexPath)) {
          error('plugins/index.json not found');
          process.exit(1);
        }

        const index = JSON.parse(fs.readFileSync(indexPath, 'utf8'));
        let allValid = true;

        for (const pluginFile of index) {
          const pluginPath = path.resolve('plugins', pluginFile);
          try {
            const { errors } = validatePlugin(pluginPath);
            if (errors.length > 0) {
              error(`${pluginFile}: ${errors.length} errors`);
              errors.forEach(err => console.log(`    - ${err}`));
              allValid = false;
            } else {
              success(`${pluginFile}: valid`);
            }
          } catch (e) {
            error(`${pluginFile}: ${e.message}`);
            allValid = false;
          }
        }

        if (allValid) {
          success('All plugins are valid!');
        } else {
          process.exit(1);
        }
        break;

      case 'update-index':
        info('Updating plugin index...');
        updateIndex();
        break;

      case 'help':
      default:
        console.log(`
HRIStudio Plugin Validator

Usage:
  validate <plugin-file>    Validate a single plugin file
  validate-all             Validate all plugins and repository
  update-index            Update plugins/index.json with all plugin files
  help                    Show this help message

Examples:
  ./scripts/validate-plugin.js validate plugins/my-robot.json
  ./scripts/validate-plugin.js validate-all
  ./scripts/validate-plugin.js update-index
        `);
        break;
    }
  } catch (e) {
    error(`Error: ${e.message}`);
    process.exit(1);
  }
}

if (require.main === module) {
  main();
}

module.exports = {
  validatePlugin,
  validateRepository,
  updateIndex
};