/**
 * Shalloteer Game Validator
 * Provides real-time validation and feedback for generated game code
 */

interface ValidationResult {
  valid: boolean;
  errors: string[];
  warnings: string[];
  suggestions: string[];
}


const VALID_ENTITY_TAGS = [
  'world', 'entity', 'static-part', 'dynamic-part', 'kinematic-part',
  'player', 'tween', 'animation', 'collider', 'renderer', 'transform'
];

const VALID_ATTRIBUTES = {
  'world': ['canvas', 'sky', 'fog', 'gravity'],
  'static-part': ['pos', 'euler', 'size', 'shape', 'color', 'mass', 'restitution', 'friction'],
  'dynamic-part': ['pos', 'euler', 'size', 'shape', 'color', 'mass', 'restitution', 'friction', 'linear-damping', 'angular-damping'],
  'kinematic-part': ['pos', 'euler', 'size', 'shape', 'color'],
  'player': ['pos', 'speed', 'jump-height'],
  'tween': ['target', 'from', 'to', 'duration', 'ease', 'loop', 'delay'],
  'entity': ['pos', 'euler', 'scale', 'transform', 'body', 'collider', 'renderer'],
};

const VALID_SHAPES = ['box', 'sphere', 'capsule', 'cylinder', 'cone'];
const VALID_EASE_TYPES = ['linear', 'sine-in', 'sine-out', 'sine-in-out', 'quad-in', 'quad-out', 'quad-in-out'];
const VALID_LOOP_TYPES = ['none', 'repeat', 'ping-pong'];

export function validateShalloteerGame(html: string): ValidationResult {
  const result: ValidationResult = {
    valid: true,
    errors: [],
    warnings: [],
    suggestions: []
  };

  try {
    // Extract world tag content
    const worldMatch = html.match(/<world[^>]*>([\s\S]*?)<\/world>/);
    if (!worldMatch) {
      result.valid = false;
      result.errors.push("Missing <world> tag. All game content must be inside a <world> tag.");
      result.suggestions.push("Wrap your game entities in: <world canvas=\"#game-canvas\" sky=\"0x87ceeb\">...</world>");
      return result;
    }

    // Check for canvas attribute
    const canvasMatch = worldMatch[0].match(/canvas="([^"]*)"/);
    if (!canvasMatch) {
      result.warnings.push("Missing canvas attribute on <world> tag.");
      result.suggestions.push("Add canvas=\"#game-canvas\" to your <world> tag.");
    }

    // Validate entity tags
    const entityRegex = /<([\w-]+)([^>]*)>/g;
    let match;
    const usedTags = new Set<string>();

    while ((match = entityRegex.exec(worldMatch[1])) !== null) {
      const [, tagName, attributes] = match;
      usedTags.add(tagName);

      if (!VALID_ENTITY_TAGS.includes(tagName)) {
        result.errors.push(`Invalid tag: <${tagName}>. Valid tags are: ${VALID_ENTITY_TAGS.join(', ')}`);
        result.valid = false;
      }

      // Validate attributes for known tags
      if (VALID_ATTRIBUTES[tagName as keyof typeof VALID_ATTRIBUTES]) {
        const validAttrs = VALID_ATTRIBUTES[tagName as keyof typeof VALID_ATTRIBUTES];
        const attrRegex = /(\w+(?:-\w+)*)="([^"]*)"/g;
        let attrMatch;

        while ((attrMatch = attrRegex.exec(attributes)) !== null) {
          const [, attrName, attrValue] = attrMatch;

          if (!validAttrs.includes(attrName) && !['id', 'class'].includes(attrName)) {
            result.warnings.push(`Unknown attribute '${attrName}' on <${tagName}>. Valid attributes: ${validAttrs.join(', ')}`);
          }

          // Validate specific attribute values
          if (attrName === 'shape' && !VALID_SHAPES.includes(attrValue)) {
            result.errors.push(`Invalid shape '${attrValue}'. Valid shapes: ${VALID_SHAPES.join(', ')}`);
            result.valid = false;
          }

          if (attrName === 'ease' && !VALID_EASE_TYPES.includes(attrValue)) {
            result.warnings.push(`Unknown ease type '${attrValue}'. Valid types: ${VALID_EASE_TYPES.join(', ')}`);
          }

          if (attrName === 'loop' && !VALID_LOOP_TYPES.includes(attrValue)) {
            result.warnings.push(`Unknown loop type '${attrValue}'. Valid types: ${VALID_LOOP_TYPES.join(', ')}`);
          }
        }
      }
    }

    // Provide suggestions based on what's missing
    if (!usedTags.has('static-part') && !usedTags.has('dynamic-part')) {
      result.suggestions.push("Add some objects to your game! Use <static-part> for platforms and <dynamic-part> for physics objects.");
    }

    if (!html.includes('GAME.run()') && !html.includes('GAME.withSystem')) {
      result.errors.push("Missing GAME initialization. Add GAME.run() in a script tag.");
      result.valid = false;
    }

    // Check for common mistakes
    if (html.includes('/>') && (html.includes('static-part />') || html.includes('dynamic-part />'))) {
      result.warnings.push("Use explicit closing tags (e.g., </static-part>) instead of self-closing for better compatibility.");
    }

    if (!html.includes('#game-canvas')) {
      result.errors.push("Missing canvas element. Add <canvas id=\"game-canvas\"></canvas> before the <world> tag.");
      result.valid = false;
    }

  } catch (error) {
    result.valid = false;
    result.errors.push(`Parsing error: ${error}`);
  }

  return result;
}

export function generateCorrectionPrompt(validation: ValidationResult, originalPrompt: string): string {
  let prompt = "The generated game code has some issues that need to be fixed:\n\n";

  if (validation.errors.length > 0) {
    prompt += "**ERRORS (must fix):**\n";
    validation.errors.forEach(error => {
      prompt += `- ${error}\n`;
    });
    prompt += "\n";
  }

  if (validation.warnings.length > 0) {
    prompt += "**WARNINGS (should fix):**\n";
    validation.warnings.forEach(warning => {
      prompt += `- ${warning}\n`;
    });
    prompt += "\n";
  }

  if (validation.suggestions.length > 0) {
    prompt += "**SUGGESTIONS:**\n";
    validation.suggestions.forEach(suggestion => {
      prompt += `- ${suggestion}\n`;
    });
    prompt += "\n";
  }

  prompt += `Please regenerate the game code fixing these issues. Original request: "${originalPrompt}"`;

  return prompt;
}

export function createGameExamples(): string {
  return `
## Working Shalloteer Game Examples:

### Example 1: Basic Platformer
\`\`\`html
<world canvas="#game-canvas" sky="0x87ceeb">
  <!-- Ground -->
  <static-part pos="0 -0.5 0" shape="box" size="20 1 20" color="0x90ee90"></static-part>
  
  <!-- Platforms -->
  <static-part pos="5 2 0" shape="box" size="3 0.5 3" color="0x8b4513"></static-part>
  <static-part pos="-5 4 0" shape="box" size="3 0.5 3" color="0x8b4513"></static-part>
  
  <!-- Collectible -->
  <dynamic-part pos="0 5 0" shape="sphere" color="0xffd700"></dynamic-part>
</world>
\`\`\`

### Example 2: Moving Platform
\`\`\`html
<kinematic-part pos="0 3 5" shape="box" size="4 0.5 2" color="0x9370db">
  <tween target="body.pos-x" from="-5" to="5" duration="4" ease="sine-in-out" loop="ping-pong"></tween>
</kinematic-part>
\`\`\`

### Example 3: Physics Objects
\`\`\`html
<dynamic-part pos="0 8 0" shape="sphere" size="1" color="0xff4500" mass="2" restitution="0.8"></dynamic-part>
<dynamic-part pos="2 8 2" shape="box" size="1 1 1" color="0x4169e1" mass="1"></dynamic-part>
\`\`\`

Remember:
- ALL game entities must be inside <world> tags
- Use explicit closing tags (</static-part>) not self-closing (<static-part />)
- Include canvas element and GAME.run() script
- Player controller is auto-created if not specified
`;
}