import { Validator } from '@syntropysoft/praetorian';

// Create a validator with custom rules
const validator = new Validator({
  plugins: ['security', 'compliance'],
  rules: {
    'no-secrets': true,
    'required-fields': true,
    'format-validation': true
  }
});

// Validate a YAML configuration file
const result = await validator.validate({
  config: { /* your config object */ },
  context: {
    config: { /* config object */ },
    environment: 'production',
    project: 'my-app',
    timestamp: new Date(),
    metadata: {}
  }
});

console.log(result.success ? '✅ Configuration Valid' : '❌ Configuration Invalid');

// Security Rules
const securityRules = {
  'no-secrets-in-code': {
    description: 'Detect hardcoded secrets in configuration',
    severity: 'error',
    validate: (config) => {
      // Check for API keys, passwords, tokens
    }
  },
  'required-security-headers': {
    description: 'Ensure security headers are configured',
    severity: 'warning',
    validate: (config) => {
      // Validate security headers
    }
  }
};

// Compliance Rules
const complianceRules = {
  'required-fields': {
    description: 'Ensure all required fields are present',
    severity: 'error',
    validate: (config) => {
      // Check required fields
    }
  },
  'format-validation': {
    description: 'Validate configuration format',
    severity: 'warning',
    validate: (config) => {
      // Validate format
    }
  }
};

import { BasePlugin } from '@syntropysoft/praetorian';

class CustomValidationPlugin extends BasePlugin {
  protected initializeRules() {
    this.addRule({
      id: 'custom-yaml-structure',
      name: 'Custom YAML Structure Validation',
      description: 'Validate specific YAML structure for your project',
      category: 'custom',
      severity: 'error',
      enabled: true
    });
  }

  protected async executeRule(rule, config, context) {
    // Your custom validation logic here
    if (rule.id === 'custom-yaml-structure') {
      // Validate your specific YAML structure
      return this.validateYamlStructure(config);
    }
  }

  private validateYamlStructure(config) {
    // Custom validation logic
    const errors = [];
    
    // Example: Check if required sections exist
    if (!config.database) {
      errors.push({
        code: 'MISSING_DATABASE_SECTION',
        message: 'Database configuration section is required',
        severity: 'error'
      });
    }

    return {
      success: errors.length === 0,
      errors,
      warnings: []
    };
  }
}

const yamlRules = {
  'database-credentials': {
    description: 'Database credentials must use environment variables',
    validate: (config) => {
      const errors = [];
      if (config.database?.credentials?.password && 
          !config.database.credentials.password.startsWith('${')) {
        errors.push({
          code: 'HARDCODED_PASSWORD',
          message: 'Database password should use environment variable',
          path: 'database.credentials.password'
        });
      }
      return { success: errors.length === 0, errors };
    }
  },
  'security-headers': {
    description: 'Required security headers must be present',
    validate: (config) => {
      const requiredHeaders = ['x-frame-options', 'x-content-type-options'];
      const errors = [];
      
      requiredHeaders.forEach(header => {
        if (!config.security?.headers?.[header]) {
          errors.push({
            code: 'MISSING_SECURITY_HEADER',
            message: `Missing required security header: ${header}`,
            path: `security.headers.${header}`
          });
        }
      });
      
      return { success: errors.length === 0, errors };
    }
  }
};