// 🚀 Smart File Rebuilder Handler v20 - BRAIN UNIFIED
// Enhanced with v20 Brain Integration, Structural Refactoring & Complex Component Logic
// .vscode-extension/cipher-autonomous-dev/src/handlers/core/smartFileRebuilderHandler.ts

import * as path from "path";
import * as vscode from "vscode";
import {
  RebuildRecommendation,
  RebuildStrategy,
  SupportedFileType,
} from "../../shared/types";
import {
  calculateComplexity,
  ensureDirectoryExists,
  getBrainInterface,
  getFileType,
} from "../../shared/utils";

/**
 * 🔧 v20 ENHANCED: Smart File Rebuilding with Brain Integration
 * Now includes structural refactoring, conditional hook fixes, and brain learning
 */
export async function smartFileRebuilderHandler(): Promise<void> {
  console.log(
    "🚀 [v20] SmartFileRebuilder BRAIN UNIFIED - Starting intelligent rebuild..."
  );

  const editor = vscode.window.activeTextEditor;
  if (!editor) {
    vscode.window.showErrorMessage("No active file to rebuild");
    return;
  }

  const fileName = editor.document.fileName;
  const baseName = path.basename(fileName);
  const content = editor.document.getText();

  // ✅ v20 BRAIN INITIALIZATION
  await initializeBrainSystem();

  try {
    // Check if file type is supported
    if (!isFileTypeSupported(fileName, "rebuild")) {
      const fileType = getFileTypeSupport(fileName);
      if (fileType && fileType.canAnalyze) {
        const action = await vscode.window.showWarningMessage(
          `🔍 ${baseName} can be analyzed but not auto-rebuilt yet. Would you like to analyze instead?`,
          "Analyze File",
          "Manual Review",
          "Cancel"
        );

        if (action === "Analyze File") {
          await analyzeCurrentFileForRebuild(editor);
          await performBrainLearning("analyze-unsupported-type", true, {
            fileName: baseName,
            fileType: path.extname(fileName),
            action: "delegated-to-analysis",
          });
        } else if (action === "Manual Review") {
          vscode.window.showInformationMessage(
            `📝 ${baseName} requires manual review. Consider using Claude for complex rebuilds.`
          );
          await performBrainLearning("manual-review-required", true, {
            fileName: baseName,
            reason: "complex-file-type",
          });
        }
        return;
      } else {
        vscode.window.showErrorMessage(
          `❌ File type ${path.extname(fileName)} not supported for analysis or rebuilding yet.`
        );
        await performBrainLearning("unsupported-file-type", false, {
          fileName: baseName,
          fileType: path.extname(fileName),
        });
        return;
      }
    }

    // ✅ v20 ENHANCED: Assess complexity and structural issues
    const complexity = calculateComplexity(content);
    const structuralIssues = await assessStructuralIssues(content, fileName);

    console.log(
      `🔍 [v20] File complexity: ${complexity}/10, Structural issues: ${structuralIssues.length}`
    );

    const strategy = await selectRebuildStrategy(editor, structuralIssues);
    if (!strategy) {
      await performBrainLearning("strategy-selection-cancelled", false, {
        fileName: baseName,
      });
      return;
    }

    vscode.window.showInformationMessage(
      `🔄 Smart rebuilding ${baseName} with ${strategy.type} strategy...`
    );

    let rebuildSuccess = false;
    let rebuildMetadata: any = {};

    if (strategy.type === "smart") {
      rebuildMetadata = await smartRebuildFile(
        editor,
        strategy,
        structuralIssues
      );
      rebuildSuccess = true;
    } else if (strategy.type === "full") {
      rebuildMetadata = await fullRebuildFile(
        editor,
        strategy,
        structuralIssues
      );
      rebuildSuccess = true;
    } else {
      rebuildMetadata = await preservativeRebuildFile(
        editor,
        strategy,
        structuralIssues
      );
      rebuildSuccess = true;
    }

    // ✅ v20 BRAIN LEARNING: Learn from rebuild success
    await performBrainLearning(`rebuild-${strategy.type}`, rebuildSuccess, {
      fileName: baseName,
      complexity,
      structuralIssues: structuralIssues.length,
      strategy: strategy.type,
      enhancedTypes: strategy.enhanceTypes,
      performanceOptimized: strategy.addPerformanceOptimizations,
      ...rebuildMetadata,
    });

    vscode.window.showInformationMessage(
      `✅ ${baseName} rebuilt successfully with ${strategy.type} strategy!`
    );
  } catch (error) {
    console.error(`🚨 [v20] Rebuild failed:`, error);
    vscode.window.showErrorMessage(`Rebuild failed: ${error}`);

    await performBrainLearning("rebuild-error", false, {
      fileName: baseName,
      error: error?.toString(),
      errorType: "unexpected-error",
    });
  }
}

/**
 * 🧠 v20 BRAIN INITIALIZATION
 */
async function initializeBrainSystem(): Promise<void> {
  console.log(`🧠 [v20] CRITICAL FIX: Calling initializeBrainSystem()...`);
  try {
    const { initializeBrainSystem } = await import("../../shared/utils");
    const initialized = await initializeBrainSystem();
    console.log(
      `🧠 [v20] Brain initialization result: ${initialized ? "✅ SUCCESS" : "❌ FAILED"}`
    );
  } catch (initError) {
    console.log(`🧠 [v20] Brain initialization failed: ${initError}`);
  }
}

/**
 * 🧠 v20 BRAIN LEARNING
 */
async function performBrainLearning(
  action: string,
  success: boolean,
  metadata: any
): Promise<void> {
  console.log(
    `🚀 [v20] SmartFileRebuilder Brain Learning - Action: ${action}, Success: ${success}`
  );

  try {
    const brainInterface = getBrainInterface();
    if (brainInterface) {
      await brainInterface.learnFromAction(
        `smart-rebuild-${action}`,
        success ? "success" : "failure",
        {
          handler: "SmartFileRebuilder",
          timestamp: new Date().toISOString(),
          ...metadata,
        }
      );
      console.log(`✅ [v20] Brain learning SUCCESS for ${action}`);
    } else {
      console.log(`⚠️ [v20] Brain interface not available for learning`);
    }
  } catch (error) {
    console.log(`🚨 [v20] Brain learning failed: ${error}`);
  }
}

/**
 * 🔍 v20 ENHANCED: Assess Structural Issues
 * Detects conditional hooks, component architecture problems, etc.
 */
async function assessStructuralIssues(
  content: string,
  fileName: string
): Promise<StructuralIssue[]> {
  const issues: StructuralIssue[] = [];
  const lines = content.split("\n");
  const isReact =
    fileName.includes(".tsx") ||
    fileName.includes(".jsx") ||
    content.includes("React");

  if (isReact) {
    // ✅ DETECT CONDITIONAL HOOKS (BadHooks.tsx case!)
    lines.forEach((line, index) => {
      if (
        line.includes("if") &&
        (line.includes("useState") || line.includes("useEffect"))
      ) {
        issues.push({
          type: "conditional-hook",
          line: index + 1,
          description: "Hook called conditionally - violates Rules of Hooks",
          severity: "error",
          fixStrategy: "move-hooks-to-top-level",
        });
      }
    });

    // ✅ DETECT MISSING DEPENDENCY ARRAYS
    let inUseEffect = false;
    let useEffectStart = -1;
    lines.forEach((line, index) => {
      if (line.includes("useEffect")) {
        inUseEffect = true;
        useEffectStart = index;
      }
      if (inUseEffect && line.includes("});") && !line.includes(", [")) {
        issues.push({
          type: "missing-dependency-array",
          line: index + 1,
          description: "useEffect missing dependency array",
          severity: "warning",
          fixStrategy: "add-dependency-array",
        });
        inUseEffect = false;
      }
    });

    // ✅ DETECT COMPONENT STRUCTURE ISSUES
    const hasMultipleReturns = (content.match(/return \(/g) || []).length > 1;
    if (hasMultipleReturns) {
      issues.push({
        type: "multiple-returns",
        line: -1,
        description: "Component has multiple return statements",
        severity: "warning",
        fixStrategy: "consolidate-returns",
      });
    }
  }

  console.log(`🔍 [v20] Structural assessment found ${issues.length} issues`);
  return issues;
}

interface StructuralIssue {
  type: string;
  line: number;
  description: string;
  severity: "error" | "warning";
  fixStrategy: string;
}

/**
 * 🎯 v20 ENHANCED: Select Rebuild Strategy with Structural Awareness
 */
async function selectRebuildStrategy(
  editor: vscode.TextEditor,
  structuralIssues: StructuralIssue[]
): Promise<RebuildStrategy | undefined> {
  const fileName = path.basename(editor.document.fileName);
  const content = editor.document.getText();
  const complexity = calculateComplexity(content);
  const fileType = getFileType(fileName);

  const recommendations: RebuildRecommendation[] = [];
  const hasStructuralIssues = structuralIssues.length > 0;
  const hasConditionalHooks = structuralIssues.some(
    (i) => i.type === "conditional-hook"
  );

  // ✅ v20 ENHANCED: Recommendations based on structural issues
  if (hasConditionalHooks) {
    recommendations.push({
      label: "🚀 Smart Structural Rebuild (REQUIRED)",
      description: `Fix ${structuralIssues.length} structural issues including conditional hooks`,
      strategy: {
        type: "smart",
        preserveComments: true,
        enhanceTypes: true,
        addPerformanceOptimizations: true,
        includeTests: false,
        fixStructuralIssues: true,
      },
    });
  } else if (complexity <= 3 && !hasStructuralIssues) {
    recommendations.push({
      label: "🔧 Smart Rebuild (Recommended)",
      description: "Intelligent enhancement with type safety and performance",
      strategy: {
        type: "smart",
        preserveComments: true,
        enhanceTypes: true,
        addPerformanceOptimizations: true,
        includeTests: false,
        fixStructuralIssues: false,
      },
    });
  }

  recommendations.push({
    label: "🚀 Full Architectural Rebuild",
    description: `Complete reconstruction with all modern features${hasStructuralIssues ? " + structural fixes" : ""}`,
    strategy: {
      type: "full",
      preserveComments: false,
      enhanceTypes: true,
      addPerformanceOptimizations: true,
      includeTests: true,
      fixStructuralIssues: true,
    },
  });

  if (!hasConditionalHooks) {
    recommendations.push({
      label: "🛡️ Preservative Rebuild",
      description: "Careful enhancement while preserving existing structure",
      strategy: {
        type: "preserve",
        preserveComments: true,
        enhanceTypes: false,
        addPerformanceOptimizations: false,
        includeTests: false,
        fixStructuralIssues: false,
      },
    });
  }

  const issuesSummary = hasStructuralIssues
    ? ` | Issues: ${structuralIssues.length} (${structuralIssues.map((i) => i.type).join(", ")})`
    : "";

  const selected = await vscode.window.showQuickPick(recommendations, {
    placeHolder: `Select rebuild strategy for ${fileName} (Complexity: ${complexity}/10${issuesSummary})`,
  });

  return selected?.strategy;
}

/**
 * 🧠 v20 ENHANCED: Smart Rebuild with Structural Fixes
 */
async function smartRebuildFile(
  editor: vscode.TextEditor,
  strategy: RebuildStrategy,
  structuralIssues: StructuralIssue[]
): Promise<any> {
  const fileName = editor.document.fileName;
  const fileType = getFileTypeSupport(fileName);
  const content = editor.document.getText();
  const isReact = fileName.includes(".tsx") || fileName.includes(".jsx");

  let rebuiltContent: string;
  let rebuildMetadata: any = {
    originalLines: content.split("\n").length,
    structuralIssuesFixed: 0,
  };

  // ✅ v20 STRUCTURAL FIXES: Handle React components with conditional hooks
  if (isReact && structuralIssues.some((i) => i.type === "conditional-hook")) {
    console.log("🔧 [v20] Applying structural fixes for conditional hooks...");
    rebuiltContent = await rebuildReactComponentWithStructuralFixes(
      fileName,
      content,
      strategy,
      structuralIssues
    );
    rebuildMetadata.structuralIssuesFixed = structuralIssues.filter(
      (i) => i.type === "conditional-hook"
    ).length;
    rebuildMetadata.fixType = "structural-react-component";
  } else {
    // ✅ Standard rebuild based on file type
    switch (fileType?.parser) {
      case "typescript":
        rebuiltContent = await rebuildTypeScriptFile(
          fileName,
          content,
          strategy
        );
        rebuildMetadata.fixType = "typescript-enhancement";
        break;
      case "javascript":
        rebuiltContent = await rebuildJavaScriptFile(
          fileName,
          content,
          strategy
        );
        rebuildMetadata.fixType = "javascript-enhancement";
        break;
      case "json":
        rebuiltContent = await rebuildJsonFile(fileName, content, strategy);
        rebuildMetadata.fixType = "json-enhancement";
        break;
      case "markdown":
        rebuiltContent = await rebuildMarkdownFile(fileName, content, strategy);
        rebuildMetadata.fixType = "markdown-enhancement";
        break;
      default:
        rebuiltContent = await rebuildGenericFile(fileName, content, strategy);
        rebuildMetadata.fixType = "generic-enhancement";
    }
  }

  rebuildMetadata.finalLines = rebuiltContent.split("\n").length;
  rebuildMetadata.linesChanged = Math.abs(
    rebuildMetadata.finalLines - rebuildMetadata.originalLines
  );

  await applyFileChanges(editor, rebuiltContent);

  // Generate companion files if requested
  if (strategy.includeTests) {
    await generateCompanionTestFile(fileName, content);
    rebuildMetadata.testsGenerated = true;
  }

  return rebuildMetadata;
}

/**
 * 🚀 v20 NEW: React Component Structural Fixes (BadHooks.tsx solution!)
 */
async function rebuildReactComponentWithStructuralFixes(
  fileName: string,
  originalContent: string,
  strategy: RebuildStrategy,
  structuralIssues: StructuralIssue[]
): Promise<string> {
  const componentName = path.basename(fileName).replace(/\.(tsx?|jsx?)$/, "");
  const lines = originalContent.split("\n");

  // ✅ EXTRACT HOOK DECLARATIONS FROM CONDITIONALS
  const extractedHooks: string[] = [];
  const conditionalHookIssues = structuralIssues.filter(
    (i) => i.type === "conditional-hook"
  );

  conditionalHookIssues.forEach((issue) => {
    const line = lines[issue.line - 1];
    if (line) {
      // Extract the hook declaration
      const hookMatch = line.match(/(const \[.*?\] = use\w+.*?;)/);
      if (hookMatch) {
        extractedHooks.push(hookMatch[1].trim());
      }
    }
  });

  console.log(
    `🔧 [v20] Extracted ${extractedHooks.length} hooks from conditionals`
  );

  // ✅ GENERATE ENHANCED COMPONENT WITH PROPER HOOK PLACEMENT
  return generateStructurallyFixedReactComponent(
    componentName,
    originalContent,
    strategy,
    extractedHooks
  );
}

/**
 * ⚛️ v20 ENHANCED: Generate Structurally Fixed React Component
 */
function generateStructurallyFixedReactComponent(
  componentName: string,
  originalContent: string,
  strategy: RebuildStrategy,
  extractedHooks: string[]
): string {
  const hasHooks =
    originalContent.includes("useState") ||
    originalContent.includes("useEffect") ||
    extractedHooks.length > 0;
  const hasProps =
    originalContent.includes("Props") || originalContent.includes("props");
  const preserveComments = strategy.preserveComments;

  const typeDefinitions = strategy.enhanceTypes
    ? `
interface ${componentName}Props {
  ${hasProps ? "// Enhanced prop definitions with strict typing" : "// Add your props here"}
  className?: string;
  children?: React.ReactNode;
}

interface ${componentName}State {
  isLoaded: boolean;
  isActive: boolean;
  error?: string;
}`
    : "";

  const imports = strategy.addPerformanceOptimizations
    ? `import React, { memo, useCallback, useMemo, useRef, useLayoutEffect, useState, useEffect } from 'react';`
    : `import React, { useState, useEffect } from 'react';`;

  // ✅ v20 STRUCTURAL FIX: Hooks at top level (no conditionals!)
  const hooksAtTopLevel =
    extractedHooks.length > 0
      ? `
  // ✅ v20 STRUCTURAL FIX: Moved hooks to top level (Rules of Hooks compliance)
  ${extractedHooks.join("\n  ")}
  `
      : "";

  const componentLogic = hasHooks
    ? `
  ${hooksAtTopLevel}
  const [state, setState] = useState<${componentName}State>({
    isLoaded: false,
    isActive: false
  });
  
  const componentRef = useRef<HTMLDivElement>(null);

  ${
    strategy.addPerformanceOptimizations
      ? `
  // ✅ v20 PERFORMANCE: Memoized event handlers
  const handleAction = useCallback(() => {
    setState(prev => ({ ...prev, isActive: !prev.isActive }));
  }, []);

  const handleLoad = useCallback(() => {
    setState(prev => ({ ...prev, isLoaded: true }));
  }, []);

  // ✅ v20 PERFORMANCE: Memoized computed values
  const computedProps = useMemo(() => ({
    status: state.isActive ? 'active' : 'inactive',
    className: \`\${className} \${state.isActive ? 'active' : ''}\`.trim()
  }), [state.isActive, className]);`
      : `
  const handleAction = () => {
    setState(prev => ({ ...prev, isActive: !prev.isActive }));
  };

  const handleLoad = () => {
    setState(prev => ({ ...prev, isLoaded: true }));
  };`
  }

  // ✅ v20 STRUCTURAL FIX: Proper useEffect with dependency array
  useEffect(() => {
    handleLoad();
  }, [${strategy.addPerformanceOptimizations ? "handleLoad" : ""}]);`
    : `
  const [isLoaded, setIsLoaded] = useState(false);
  const [isActive, setIsActive] = useState(false);

  useEffect(() => {
    setIsLoaded(true);
  }, []);`;

  return `// 🚀 ${componentName} - v20 Structurally Enhanced by Cipher Smart Rebuild
${preserveComments ? `// Original implementation preserved and enhanced with structural fixes` : ""}
${imports}
${typeDefinitions}

const ${componentName}: React.FC<${strategy.enhanceTypes ? `${componentName}Props` : "any"}> = (${
    strategy.enhanceTypes
      ? `{ 
  className = '', 
  children,
  ...props 
}`
      : "props"
  }) => {
  ${componentLogic}

  ${
    strategy.addPerformanceOptimizations && hasHooks
      ? `
  // ✅ v20 PERFORMANCE: Development monitoring
  useLayoutEffect(() => {
    if (process.env.NODE_ENV === 'development') {
      console.log('🚀 ${componentName} rendered with structural fixes');
    }
  });`
      : ""
  }

  if (!${hasHooks ? "state.isLoaded" : "isLoaded"}) {
    return (
      <div className="flex items-center justify-center min-h-screen">
        <div className="text-white text-xl animate-pulse">Loading ${componentName}...</div>
      </div>
    );
  }

  return (
    <div 
      ref={componentRef}
      className={\`min-h-screen bg-gradient-to-br from-purple-900 via-blue-900 to-indigo-900 text-white p-6 \${${strategy.addPerformanceOptimizations ? "computedProps.className" : "className"}}\`}
      {...props}
    >
      <div className="container mx-auto">
        <div className="text-center mb-8">
          <h1 className="text-4xl font-bold mb-4 bg-gradient-to-r from-cyan-400 to-blue-500 bg-clip-text text-transparent">
            🚀 ${componentName}
          </h1>
          <p className="text-gray-300 text-lg">
            v20 Structurally Enhanced by Cipher Smart Rebuild
          </p>
        </div>

        <div className="bg-gray-800/50 backdrop-blur rounded-xl p-8 border border-gray-700">
          <div className="grid grid-cols-1 md:grid-cols-2 gap-6">
            <div className="bg-gray-900 rounded-lg p-6">
              <h3 className="text-xl font-semibold mb-3">🎯 Structural Enhancements</h3>
              <ul className="text-gray-400 space-y-2">
                <li>✅ Hooks moved to top-level (Rules of Hooks compliance)</li>
                <li>✅ Proper dependency arrays in useEffect</li>
                <li>✅ Modern React patterns with TypeScript</li>
                ${strategy.addPerformanceOptimizations ? "<li>✅ Performance optimizations applied</li>" : ""}
              </ul>
              <button 
                onClick={${strategy.addPerformanceOptimizations ? "handleAction" : hasHooks ? "handleAction" : "() => setIsActive(!isActive)"}}
                className={\`w-full mt-4 px-4 py-2 rounded-lg transition-all duration-200 \${
                  ${hasHooks ? "state.isActive" : "isActive"} 
                    ? 'bg-red-600 hover:bg-red-700' 
                    : 'bg-blue-600 hover:bg-blue-700'
                }\`}
              >
                {${hasHooks ? "state.isActive" : "isActive"} ? '⏹️ Stop' : '▶️ Start'} ${componentName}
              </button>
            </div>
            
            <div className="bg-gray-900 rounded-lg p-6">
              <h3 className="text-xl font-semibold mb-3">📊 Status</h3>
              <div className="space-y-2">
                <div className="flex justify-between">
                  <span>Status:</span>
                  <span className={${hasHooks ? "state.isActive" : "isActive"} ? 'text-green-400' : 'text-gray-400'}>
                    {${strategy.addPerformanceOptimizations ? "computedProps.status" : hasHooks ? 'state.isActive ? "active" : "inactive"' : 'isActive ? "active" : "inactive"'}}
                  </span>
                </div>
                <div className="flex justify-between">
                  <span>Loaded:</span>
                  <span className="text-green-400">✅ Ready</span>
                </div>
                <div className="flex justify-between">
                  <span>Structurally Fixed:</span>
                  <span className="text-blue-400">🚀 v20 Enhanced</span>
                </div>
                ${
                  strategy.addPerformanceOptimizations
                    ? `
                <div className="flex justify-between">
                  <span>Optimized:</span>
                  <span className="text-purple-400">⚡ Performance Enhanced</span>
                </div>`
                    : ""
                }
              </div>
            </div>
          </div>

          {children && (
            <div className="mt-6">
              {children}
            </div>
          )}

          <div className="mt-8 text-center text-sm text-gray-400">
            🚀 v20 Structurally Enhanced by Cipher Smart Rebuild | ${new Date().toLocaleDateString()}
            ${strategy.addPerformanceOptimizations ? " | ⚡ Performance Optimized" : ""}
          </div>
        </div>
      </div>
    </div>
  );
};

export default ${strategy.addPerformanceOptimizations ? `memo(${componentName})` : componentName};

${
  preserveComments
    ? `
// Original implementation preserved as reference:
/*
${originalContent}
*/`
    : ""
}`;
}

// ✅ Continue with existing methods but enhanced...
/**
 * 🏗️ TypeScript File Rebuilding (Enhanced)
 */
async function rebuildTypeScriptFile(
  fileName: string,
  content: string,
  strategy: RebuildStrategy
): Promise<string> {
  const baseName = path.basename(fileName).replace(/\.(tsx?|jsx?)$/, "");
  const isReact = fileName.includes(".tsx") || fileName.includes(".jsx");

  if (isReact) {
    return generateEnhancedReactComponent(baseName, content, strategy);
  } else {
    return generateEnhancedTypeScriptModule(baseName, content, strategy);
  }
}

/**
 * ⚛️ Enhanced React Component Generation (Existing but enhanced)
 */
function generateEnhancedReactComponent(
  componentName: string,
  originalContent: string,
  strategy: RebuildStrategy
): string {
  const hasHooks =
    originalContent.includes("useState") ||
    originalContent.includes("useEffect");
  const hasProps =
    originalContent.includes("Props") || originalContent.includes("props");
  const preserveComments = strategy.preserveComments;

  const typeDefinitions = strategy.enhanceTypes
    ? `
interface ${componentName}Props {
  ${hasProps ? "// Enhanced prop definitions with strict typing" : "// Add your props here"}
  className?: string;
  children?: React.ReactNode;
}

interface ${componentName}State {
  isLoaded: boolean;
  isActive: boolean;
  error?: string;
}`
    : "";

  const performanceOptimizations = strategy.addPerformanceOptimizations
    ? `
import React, { memo, useCallback, useMemo, useRef, useLayoutEffect, useState, useEffect } from 'react';`
    : `
import React, { useState, useEffect } from 'react';`;

  const componentLogic = hasHooks
    ? `
  const [state, setState] = useState<${componentName}State>({
    isLoaded: false,
    isActive: false
  });
  
  const componentRef = useRef<HTMLDivElement>(null);

  ${
    strategy.addPerformanceOptimizations
      ? `
  // Memoized event handlers for performance
  const handleAction = useCallback(() => {
    setState(prev => ({ ...prev, isActive: !prev.isActive }));
  }, []);

  const handleLoad = useCallback(() => {
    setState(prev => ({ ...prev, isLoaded: true }));
  }, []);

  // Memoized computed values
  const computedProps = useMemo(() => ({
    status: state.isActive ? 'active' : 'inactive',
    className: \`\${className} \${state.isActive ? 'active' : ''}\`.trim()
  }), [state.isActive, className]);`
      : `
  const handleAction = () => {
    setState(prev => ({ ...prev, isActive: !prev.isActive }));
  };

  const handleLoad = () => {
    setState(prev => ({ ...prev, isLoaded: true }));
  };`
  }

  useEffect(() => {
    handleLoad();
  }, [${strategy.addPerformanceOptimizations ? "handleLoad" : ""}]);`
    : `
  const [isLoaded, setIsLoaded] = useState(false);
  const [isActive, setIsActive] = useState(false);

  useEffect(() => {
    setIsLoaded(true);
  }, []);`;

  return `// 🎵 ${componentName} - Enhanced by Cipher Smart Rebuild
${preserveComments ? `// Original implementation preserved and enhanced` : ""}
${performanceOptimizations}
${typeDefinitions}

const ${componentName}: React.FC<${strategy.enhanceTypes ? `${componentName}Props` : "any"}> = (${
    strategy.enhanceTypes
      ? `{ 
  className = '', 
  children,
  ...props 
}`
      : "props"
  }) => {
  ${componentLogic}

  ${
    strategy.addPerformanceOptimizations && hasHooks
      ? `
  // Performance monitoring
  useLayoutEffect(() => {
    if (process.env.NODE_ENV === 'development') {
      console.log('🎵 ${componentName} rendered');
    }
  });`
      : ""
  }

  if (!${hasHooks ? "state.isLoaded" : "isLoaded"}) {
    return (
      <div className="flex items-center justify-center min-h-screen">
        <div className="text-white text-xl animate-pulse">Loading ${componentName}...</div>
      </div>
    );
  }

  return (
    <div 
      ref={componentRef}
      className={\`min-h-screen bg-gradient-to-br from-purple-900 via-blue-900 to-indigo-900 text-white p-6 \${${strategy.addPerformanceOptimizations ? "computedProps.className" : "className"}}\`}
      {...props}
    >
      <div className="container mx-auto">
        <div className="text-center mb-8">
          <h1 className="text-4xl font-bold mb-4 bg-gradient-to-r from-cyan-400 to-blue-500 bg-clip-text text-transparent">
            🎵 ${componentName}
          </h1>
          <p className="text-gray-300 text-lg">
            Enhanced by Cipher Smart Rebuild
          </p>
        </div>

        <div className="bg-gray-800/50 backdrop-blur rounded-xl p-8 border border-gray-700">
          <div className="grid grid-cols-1 md:grid-cols-2 gap-6">
            <div className="bg-gray-900 rounded-lg p-6">
              <h3 className="text-xl font-semibold mb-3">🎯 Enhanced Features</h3>
              <p className="text-gray-400 mb-4">
                Smart rebuilding with modern patterns and optimizations
              </p>
              <button 
                onClick={${strategy.addPerformanceOptimizations ? "handleAction" : hasHooks ? "handleAction" : "() => setIsActive(!isActive)"}}
                className={\`w-full px-4 py-2 rounded-lg transition-all duration-200 \${
                  ${hasHooks ? "state.isActive" : "isActive"} 
                    ? 'bg-red-600 hover:bg-red-700' 
                    : 'bg-blue-600 hover:bg-blue-700'
                }\`}
              >
                {${hasHooks ? "state.isActive" : "isActive"} ? '⏹️ Stop' : '▶️ Start'} ${componentName}
              </button>
            </div>
            
            <div className="bg-gray-900 rounded-lg p-6">
              <h3 className="text-xl font-semibold mb-3">📊 Status</h3>
              <div className="space-y-2">
                <div className="flex justify-between">
                  <span>Status:</span>
                  <span className={${hasHooks ? "state.isActive" : "isActive"} ? 'text-green-400' : 'text-gray-400'}>
                    {${strategy.addPerformanceOptimizations ? "computedProps.status" : hasHooks ? 'state.isActive ? "active" : "inactive"' : 'isActive ? "active" : "inactive"'}}
                  </span>
                </div>
                <div className="flex justify-between">
                  <span>Loaded:</span>
                  <span className="text-green-400">✅ Ready</span>
                </div>
                ${
                  strategy.addPerformanceOptimizations
                    ? `
                <div className="flex justify-between">
                  <span>Optimized:</span>
                  <span className="text-blue-400">⚡ Enhanced</span>
                </div>`
                    : ""
                }
              </div>
            </div>
          </div>

          {children && (
            <div className="mt-6">
              {children}
            </div>
          )}

          <div className="mt-8 text-center text-sm text-gray-400">
            🔧 Enhanced by Cipher Smart Rebuild | ${new Date().toLocaleDateString()}
            ${strategy.addPerformanceOptimizations ? " | ⚡ Performance Optimized" : ""}
          </div>
        </div>
      </div>
    </div>
  );
};

export default ${strategy.addPerformanceOptimizations ? `memo(${componentName})` : componentName};

${
  preserveComments
    ? `
// Original implementation preserved as reference:
/*
${originalContent}
*/`
    : ""
}`;
}

// ✅ Continue with all existing methods (rebuildJavaScriptFile, rebuildJsonFile, etc.)
// ... [Rest of existing methods with same enhancements]

/**
 * 🔄 Full Rebuild Implementation (Enhanced)
 */
async function fullRebuildFile(
  editor: vscode.TextEditor,
  strategy: RebuildStrategy,
  structuralIssues: StructuralIssue[]
): Promise<any> {
  const fileName = path.basename(editor.document.fileName);
  const originalContent = editor.document.getText();

  // ✅ v20 ENHANCEMENT: Handle structural issues in full rebuild
  let newContent: string;
  if (structuralIssues.length > 0) {
    newContent = await generateStructurallyFixedReactComponent(
      fileName.replace(/\.(tsx?|jsx?)$/, ""),
      originalContent,
      strategy,
      []
    );
  } else {
    newContent = await generateEnhancedFileContent(
      fileName,
      originalContent,
      strategy
    );
  }

  await applyFileChanges(editor, newContent);
  await createBackupFile(editor, originalContent);

  return {
    originalLines: originalContent.split("\n").length,
    finalLines: newContent.split("\n").length,
    structuralIssuesFixed: structuralIssues.length,
    backupCreated: true,
    fixType: "full-rebuild",
  };
}

/**
 * 🛡️ Preservative Rebuild Implementation (Enhanced)
 */
async function preservativeRebuildFile(
  editor: vscode.TextEditor,
  strategy: RebuildStrategy,
  structuralIssues: StructuralIssue[]
): Promise<any> {
  const content = editor.document.getText();
  const enhancedContent = await enhanceExistingFile(content, strategy);
  await applyFileChanges(editor, enhancedContent);

  return {
    originalLines: content.split("\n").length,
    finalLines: enhancedContent.split("\n").length,
    preservativeEnhancement: true,
    fixType: "preservative-rebuild",
  };
}

// ✅ All existing utility functions remain the same...
// Support utilities, file type checks, etc.
const SUPPORTED_FILE_TYPES: SupportedFileType[] = [
  {
    extension: ".ts",
    canAnalyze: true,
    canRebuild: true,
    parser: "typescript",
    priority: 1,
  },
  {
    extension: ".tsx",
    canAnalyze: true,
    canRebuild: true,
    parser: "typescript",
    priority: 1,
  },
  {
    extension: ".js",
    canAnalyze: true,
    canRebuild: true,
    parser: "javascript",
    priority: 1,
  },
  {
    extension: ".jsx",
    canAnalyze: true,
    canRebuild: true,
    parser: "javascript",
    priority: 1,
  },
  {
    extension: ".json",
    canAnalyze: true,
    canRebuild: true,
    parser: "json",
    priority: 1,
  },
  {
    extension: ".md",
    canAnalyze: true,
    canRebuild: true,
    parser: "markdown",
    priority: 1,
  },
  {
    extension: ".html",
    canAnalyze: true,
    canRebuild: true,
    parser: "generic",
    priority: 1,
  },
  {
    extension: ".css",
    canAnalyze: true,
    canRebuild: true,
    parser: "generic",
    priority: 1,
  },
  {
    extension: ".scss",
    canAnalyze: true,
    canRebuild: true,
    parser: "generic",
    priority: 1,
  },
];

function getFileTypeSupport(fileName: string): SupportedFileType | null {
  const extension = path.extname(fileName).toLowerCase();
  return (
    SUPPORTED_FILE_TYPES.find((type) => type.extension === extension) || null
  );
}

function isFileTypeSupported(
  fileName: string,
  operation: "analyze" | "rebuild"
): boolean {
  const fileType = getFileTypeSupport(fileName);
  if (!fileType) return false;
  return operation === "analyze" ? fileType.canAnalyze : fileType.canRebuild;
}

async function applyFileChanges(
  editor: vscode.TextEditor,
  newContent: string
): Promise<void> {
  const edit = new vscode.WorkspaceEdit();
  const fullRange = new vscode.Range(
    0,
    0,
    editor.document.lineCount,
    editor.document.lineAt(editor.document.lineCount - 1).text.length
  );
  edit.replace(editor.document.uri, fullRange, newContent);
  await vscode.workspace.applyEdit(edit);
}

async function analyzeCurrentFileForRebuild(
  editor: vscode.TextEditor
): Promise<void> {
  // Import and call the analyze current file handler
  const { analyzeCurrentFileHandler } = await import(
    "../core/analyzeCurrentFileHandler"
  );
  await analyzeCurrentFileHandler();
}

async function generateEnhancedFileContent(
  fileName: string,
  originalContent: string,
  strategy: RebuildStrategy
): Promise<string> {
  const componentName = fileName.replace(/\.(tsx?|jsx?)$/, "");
  return generateEnhancedReactComponent(
    componentName,
    originalContent,
    strategy
  );
}

async function createBackupFile(
  editor: vscode.TextEditor,
  content: string
): Promise<void> {
  const workspaceFolder = vscode.workspace.workspaceFolders?.[0];
  if (!workspaceFolder) return;

  const backupDir = vscode.Uri.joinPath(workspaceFolder.uri, "cipher-backups");
  await ensureDirectoryExists(backupDir);

  const fileName = path.basename(editor.document.fileName);
  const backupFile = vscode.Uri.joinPath(
    backupDir,
    `${fileName}.backup-${Date.now()}`
  );
  await vscode.workspace.fs.writeFile(backupFile, Buffer.from(content));
}

async function enhanceExistingFile(
  content: string,
  strategy: RebuildStrategy
): Promise<string> {
  let enhanced = content;

  if (
    strategy.enhanceTypes &&
    !content.includes("interface") &&
    content.includes("React")
  ) {
    enhanced = enhanced.replace(
      /function (\w+)\(/,
      "interface $1Props {\n  // Enhanced props\n}\n\nfunction $1("
    );
  }

  if (
    strategy.addPerformanceOptimizations &&
    content.includes("React") &&
    !content.includes("memo")
  ) {
    enhanced = enhanced.replace(
      /export default (\w+)/,
      "export default React.memo($1)"
    );
  }

  return enhanced;
}

async function generateCompanionTestFile(
  fileName: string,
  content: string
): Promise<void> {
  const workspaceFolder = vscode.workspace.workspaceFolders?.[0];
  if (!workspaceFolder) return;

  const baseName = path.basename(fileName, path.extname(fileName));
  const testDir = vscode.Uri.joinPath(workspaceFolder.uri, "tests");
  await ensureDirectoryExists(testDir);

  const testContent = `// 🧪 ${baseName} Tests - Generated by Cipher Smart Rebuild v20
import { render, screen, fireEvent } from '@testing-library/react';
import '@testing-library/jest-dom';
import ${baseName} from '../${fileName}';

describe('${baseName}', () => {
  test('renders without crashing', () => {
    render(<${baseName} />);
    expect(screen.getByText('${baseName}')).toBeInTheDocument();
  });

  test('handles user interactions', () => {
    render(<${baseName} />);
    const button = screen.getByRole('button');
    fireEvent.click(button);
    // Add specific assertions
  });

  test('structural fixes applied correctly', () => {
    render(<${baseName} />);
    // Test that hooks are properly structured
    expect(screen.getByText(/Structurally Enhanced/)).toBeInTheDocument();
  });
});

// Generated by Cipher Smart Rebuild v20 with Brain Integration`;

  const testFile = vscode.Uri.joinPath(testDir, `${baseName}.test.tsx`);
  await vscode.workspace.fs.writeFile(testFile, Buffer.from(testContent));
}

// ✅ Enhanced RebuildStrategy interface for structural fixes
declare module "../../shared/types" {
  interface RebuildStrategy {
    type:
      | "refactor"
      | "rewrite"
      | "optimize"
      | "enhance"
      | "smart"
      | "full"
      | "preserve"
      | "songsterr"
      | "audio";
    preserveComments: boolean;
    enhanceTypes: boolean;
    addPerformanceOptimizations: boolean;
    includeTests: boolean;
    fixStructuralIssues?: boolean; // ✅ v20 NEW
  }
}

// ✅ Additional file type implementations (JavaScript, JSON, Markdown, Generic)
async function rebuildJavaScriptFile(
  fileName: string,
  content: string,
  strategy: RebuildStrategy
): Promise<string> {
  const baseName = path.basename(fileName).replace(/\.(js|jsx)$/, "");
  const isReact =
    fileName.includes(".jsx") ||
    content.includes("React") ||
    content.includes("jsx");

  if (isReact) {
    return generateEnhancedJavaScriptReactComponent(
      baseName,
      content,
      strategy
    );
  } else {
    return generateEnhancedJavaScriptModule(baseName, content, strategy);
  }
}

function generateEnhancedJavaScriptReactComponent(
  componentName: string,
  originalContent: string,
  strategy: RebuildStrategy
): string {
  return `// 🎵 ${componentName} - Enhanced by Cipher Smart Rebuild v20
import React, { useState, useEffect${strategy.addPerformanceOptimizations ? ", useCallback, memo" : ""} } from 'react';

const ${componentName} = (${strategy.enhanceTypes ? '{ className = "", ...props }' : "props"}) => {
  const [isLoaded, setIsLoaded] = useState(false);
  const [isActive, setIsActive] = useState(false);

  useEffect(() => {
    setIsLoaded(true);
  }, []);

  ${
    strategy.addPerformanceOptimizations
      ? `
  const handleAction = useCallback(() => {
    setIsActive(prev => !prev);
  }, []);`
      : `
  const handleAction = () => {
    setIsActive(prev => !prev);
  };`
  }

  if (!isLoaded) {
    return (
      <div className="flex items-center justify-center min-h-screen">
        <div className="text-white text-xl">Loading ${componentName}...</div>
      </div>
    );
  }

  return (
    <div className="min-h-screen bg-gradient-to-br from-purple-900 via-blue-900 to-indigo-900 text-white p-6">
      <div className="container mx-auto">
        <div className="text-center mb-8">
          <h1 className="text-4xl font-bold mb-4">🎵 ${componentName}</h1>
          <p className="text-gray-300 text-lg">Enhanced by Cipher Smart Rebuild v20</p>
        </div>
        <div className="bg-gray-800/50 backdrop-blur rounded-xl p-8">
          <button 
            onClick={handleAction}
            className="w-full px-4 py-3 bg-blue-600 hover:bg-blue-700 rounded-lg font-semibold transition-colors"
          >
            {isActive ? '⏹️ Stop' : '▶️ Start'}
          </button>
        </div>
      </div>
    </div>
  );
};

export default ${strategy.addPerformanceOptimizations ? `memo(${componentName})` : componentName};

${
  strategy.preserveComments
    ? `
// Original content preserved:
/*
${originalContent}
*/`
    : ""
}`;
}

function generateEnhancedJavaScriptModule(
  fileName: string,
  originalContent: string,
  strategy: RebuildStrategy
): string {
  return `// 🎵 ${fileName} - Enhanced by Cipher Smart Rebuild v20
// Generated: ${new Date().toISOString()}

${
  strategy.addPerformanceOptimizations
    ? `
// Performance optimizations
const performanceCache = new Map();

function optimizedFunction(fn) {
  return function(...args) {
    const key = JSON.stringify(args);
    if (performanceCache.has(key)) {
      return performanceCache.get(key);
    }
    const result = fn.apply(this, args);
    performanceCache.set(key, result);
    return result;
  };
}`
    : ""
}

${originalContent}

// Enhanced exports
module.exports = {
  ...module.exports,
  enhanced: true,
  rebuiltBy: 'Cipher Smart Rebuild v20',
  rebuiltAt: '${new Date().toISOString()}'
};`;
}

async function rebuildJsonFile(
  fileName: string,
  content: string,
  strategy: RebuildStrategy
): Promise<string> {
  try {
    const parsed = JSON.parse(content);

    const enhanced = {
      ...parsed,
      _cipher: {
        enhanced: true,
        rebuiltBy: "Cipher Smart Rebuild v20",
        rebuiltAt: new Date().toISOString(),
        strategy: strategy.type,
        preservedOriginal: strategy.preserveComments,
        brainIntegrated: true,
      },
    };

    return JSON.stringify(enhanced, null, 2);
  } catch (error) {
    return `{
  "name": "rebuilt-${path.basename(fileName, ".json")}",
  "version": "1.0.0", 
  "description": "Rebuilt by Cipher Smart Rebuild v20",
  "_cipher": {
    "originalContentHadErrors": true,
    "rebuiltBy": "Cipher Smart Rebuild v20",
    "rebuiltAt": "${new Date().toISOString()}",
    "brainIntegrated": true
  }
}`;
  }
}

async function rebuildMarkdownFile(
  fileName: string,
  content: string,
  strategy: RebuildStrategy
): Promise<string> {
  const title = path.basename(fileName, ".md");

  return `# ${title.charAt(0).toUpperCase() + title.slice(1)}

> **Enhanced by Cipher Smart Rebuild v20 with Brain Integration** | ${new Date().toLocaleDateString()}

## Overview

${content.includes("##") ? "Original content enhanced and restructured:" : "Generated from original content:"}

${strategy.preserveComments ? content : content.replace(/<!--[\s\S]*?-->/g, "")}

## v20 Enhanced Features

- ✅ Improved structure and formatting
- 🎵 Cipher Smart Rebuild v20 optimization
- 🧠 Brain integration for continuous learning
- 📖 Better readability
${strategy.enhanceTypes ? "- 🏷️ Enhanced type definitions" : ""}
${strategy.addPerformanceOptimizations ? "- ⚡ Performance considerations" : ""}

## Rebuild Information

- **Strategy:** ${strategy.type}
- **Enhanced Types:** ${strategy.enhanceTypes ? "Yes" : "No"}
- **Performance Optimized:** ${strategy.addPerformanceOptimizations ? "Yes" : "No"}
- **Comments Preserved:** ${strategy.preserveComments ? "Yes" : "No"}
- **Brain Integrated:** Yes (v20)

---
*Rebuilt by Cipher Smart Rebuild v20 with Brain Integration*  
*Generated: ${new Date().toISOString()}*`;
}

async function rebuildGenericFile(
  fileName: string,
  content: string,
  strategy: RebuildStrategy
): Promise<string> {
  const baseName = path.basename(fileName);
  const extension = path.extname(fileName);

  return `/* 🎵 ${baseName} - Enhanced by Cipher Smart Rebuild v20
 * Generated: ${new Date().toISOString()}
 * File type: ${extension}
 * Strategy: ${strategy.type}
 * Brain Integrated: Yes
 */

${content}

/* Enhanced with Cipher Smart Rebuild v20
 * Strategy: ${strategy.type}
 * Enhanced Types: ${strategy.enhanceTypes}
 * Performance Optimized: ${strategy.addPerformanceOptimizations}
 * Comments Preserved: ${strategy.preserveComments}
 * Brain Learning: Active
 */`;
}

function generateEnhancedTypeScriptModule(
  moduleName: string,
  originalContent: string,
  strategy: RebuildStrategy
): string {
  const hasExports = originalContent.includes("export");
  const hasInterfaces = originalContent.includes("interface");

  return `// 🎵 ${moduleName} - Enhanced by Cipher Smart Rebuild v20
// Generated: ${new Date().toISOString()}

${
  strategy.enhanceTypes && !hasInterfaces
    ? `
interface ${moduleName}Config {
  enabled: boolean;
  options: Record<string, any>;
}

interface ${moduleName}Result {
  success: boolean;
  data?: any;
  error?: string;
}`
    : ""
}

${
  strategy.addPerformanceOptimizations
    ? `
// Performance-optimized implementation
const cache = new Map<string, any>();

function memoize<T extends (...args: any[]) => any>(fn: T): T {
  return ((...args: any[]) => {
    const key = JSON.stringify(args);
    if (cache.has(key)) {
      return cache.get(key);
    }
    const result = fn(...args);
    cache.set(key, result);
    return result;
  }) as T;
}`
    : ""
}

${originalContent}

${
  strategy.enhanceTypes && hasExports
    ? `
// Enhanced exports with better typing
export type { ${moduleName}Config, ${moduleName}Result };`
    : ""
}

${
  strategy.addPerformanceOptimizations
    ? `
// Performance utilities
export { memoize };`
    : ""
}

// Enhanced with Cipher Smart Rebuild v20
export default {
  enhanced: true,
  rebuiltBy: 'Cipher Smart Rebuild v20',
  rebuiltAt: '${new Date().toISOString()}',
  brainIntegrated: true,
  ${strategy.addPerformanceOptimizations ? "optimized: true," : ""}
  ${strategy.enhanceTypes ? "typeSafe: true," : ""}
};`;
}