# scripts/ai_link_analyzer.py - Enhanced AI Analysis Engine

import json
import os
import sys
import logging
from datetime import datetime, timedelta
from typing import Dict, List, Optional, Tuple
import re
from urllib.parse import urlparse

try:
    import openai
    import requests
except ImportError:
    print("Installing required packages...")
    os.system("pip install openai requests")
    import openai
    import requests

# Configure logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

class HyperlinkIntelligenceEngine:
    """
    Advanced AI-powered analysis engine for hyperlink health intelligence
    """
    
    def __init__(self, api_key: str):
        self.client = openai.OpenAI(api_key=api_key)
        self.analysis_timestamp = datetime.utcnow().isoformat()
    
    def load_scan_data(self, input_dir: str) -> Dict:
        """Load all scan data and context for analysis"""
        try:
            # Load primary scan results
            with open(f"{input_dir}/summary.json", 'r') as f:
                summary = json.load(f)
            
            # Load repository context
            with open(f"{input_dir}/repository_context.json", 'r') as f:
                repo_context = json.load(f)
            
            # Load detailed test results if available
            detailed_results = []
            results_file = f"{input_dir}/test_results.csv"
            if os.path.exists(results_file):
                with open(results_file, 'r') as f:
                    lines = f.readlines()[1:]  # Skip header
                    for line in lines:
                        parts = line.strip().split('|')
                        if len(parts) >= 6:
                            detailed_results.append({
                                'timestamp': parts[0],
                                'url': parts[1],
                                'status_code': parts[2],
                                'response_time': parts[3],
                                'status': parts[4],
                                'error_message': parts[5] if len(parts) > 5 else ''
                            })
            
            return {
                'summary': summary,
                'repository_context': repo_context,
                'detailed_results': detailed_results,
                'analysis_timestamp': self.analysis_timestamp
            }
            
        except Exception as e:
            logger.error(f"Failed to load scan data: {str(e)}")
            raise
    
    def categorize_broken_links(self, broken_links: List[Dict]) -> Dict[str, List[Dict]]:
        """Categorize broken links by type and domain for pattern analysis"""
        categories = {
            'external_documentation': [],
            'github_repositories': [],
            'academic_resources': [],
            'commercial_tools': [],
            'internal_links': [],
            'deprecated_services': [],
            'temporary_failures': [],
            'unknown': []
        }
        
        for link in broken_links:
            url = link.get('url', '')
            status_code = link.get('status_code', '')
            error_message = link.get('error_message', '')
            
            # Parse URL for analysis
            parsed = urlparse(url)
            domain = parsed.netloc.lower()
            
            # Categorization logic
            if 'github.com' in domain or 'gitlab.com' in domain:
                categories['github_repositories'].append(link)
            elif any(doc_site in domain for doc_site in ['docs.', 'documentation.', 'wiki.', 'manual.']):
                categories['external_documentation'].append(link)
            elif any(academic in domain for academic in ['.edu', 'arxiv.org', 'scholar.google']):
                categories['academic_resources'].append(link)
            elif status_code in ['500', '502', '503', '504']:
                categories['temporary_failures'].append(link)
            elif 'timeout' in error_message.lower() or 'connection' in error_message.lower():
                categories['temporary_failures'].append(link)
            elif parsed.netloc == '' or url.startswith('/'):
                categories['internal_links'].append(link)
            elif status_code == '404':
                # Could be moved/deprecated content
                categories['deprecated_services'].append(link)
            else:
                categories['unknown'].append(link)
        
        # Remove empty categories
        return {k: v for k, v in categories.items() if v}
    
    def identify_patterns(self, scan_data: Dict) -> List[str]:
        """Identify patterns in link failures"""
        patterns = []
        broken_links = scan_data['summary'].get('broken_link_details', [])
        
        if not broken_links:
            return patterns
        
        # Domain pattern analysis
        domains = {}
        for link in broken_links:
            domain = urlparse(link.get('url', '')).netloc
            domains[domain] = domains.get(domain, 0) + 1
        
        # Check for domain-specific issues
        for domain, count in domains.items():
            if count > 1:
                patterns.append(f"Multiple failures from domain: {domain} ({count} links)")
        
        # Status code pattern analysis
        status_codes = {}
        for link in broken_links:
            code = link.get('status_code', '')
            status_codes[code] = status_codes.get(code, 0) + 1
        
        for code, count in status_codes.items():
            if count > 2:
                patterns.append(f"Frequent {code} errors ({count} occurrences)")
        
        # Time-based patterns (if we had historical data)
        # This could be enhanced with trend analysis
        
        return patterns
    
    def generate_ai_analysis(self, scan_data: Dict) -> Dict:
        """Generate comprehensive AI analysis of link health"""
        
        # Prepare data for AI analysis
        broken_links = scan_data['summary'].get('broken_link_details', [])
        categorized_links = self.categorize_broken_links(broken_links)
        identified_patterns = self.identify_patterns(scan_data)
        
        # Create detailed analysis prompt
        analysis_prompt = f"""
        As an expert DevOps engineer and technical content strategist, analyze this hyperlink health report for an educational IT platform.

        CONTEXT:
        - Repository: {scan_data['repository_context'].get('repository', 'Unknown')}
        - Site URL: {scan_data['summary'].get('site_url', 'Unknown')}
        - Total Links: {scan_data['summary'].get('total_links', 0)}
        - Broken Links: {scan_data['summary'].get('broken_links', 0)}
        - Success Rate: {scan_data['summary'].get('success_rate', 0)}%

        BROKEN LINKS BY CATEGORY:
        {json.dumps(categorized_links, indent=2)}

        IDENTIFIED PATTERNS:
        {json.dumps(identified_patterns, indent=2)}

        DETAILED LINK DATA:
        {json.dumps(broken_links[:20], indent=2)}  # Limit to first 20 for token efficiency

        ANALYSIS REQUIREMENTS:
        1. Provide an executive summary of the link health situation
        2. Analyze each broken link category and suggest specific remediation strategies
        3. Identify root causes for the most common failure patterns
        4. Recommend immediate actions prioritized by impact and effort
        5. Suggest long-term preventive measures for maintaining link health
        6. Assess the educational impact on learners and site users
        7. Provide specific technical implementation recommendations

        Please respond in valid JSON format with this structure:
        ```json
        {
          "executive_summary": "Brief overview highlighting key issues and overall health",
          "category_analysis": {
            "category_name": {
              "impact": "high|medium|low",
              "root_cause": "Primary reason for failures in this category",
              "recommended_actions": ["action1", "action2"],
              "timeline": "immediate|short-term|long-term"
            }
          },
          "priority_actions": [
            {
              "action": "Specific action to take",
              "priority": "high|medium|low",
              "effort": "low|medium|high",
              "impact": "high|medium|low",
              "timeline": "immediate|short-term|long-term"
            }
          ],
          "preventive_measures": [
            {
              "measure": "Description of preventive action",
              "implementation": "How to implement this measure",
              "automation_potential": "Can this be automated? How?"
            }
          ],
          "educational_impact": "Assessment of how broken links affect learning outcomes",
          "technical_recommendations": [
            {
              "recommendation": "Technical improvement suggestion",
              "justification": "Why this recommendation is important",
              "implementation_complexity": "low|medium|high"
            }
          ],
          "monitoring_suggestions": [
            "Enhanced monitoring recommendations"
          ]
        }
        ```
        """
        
        try:
            # Make API call to AI service
            response = self.client.chat.completions.create(
                model="gpt-4",
                messages=[
                    {
                        "role": "system", 
                        "content": "You are an expert DevOps engineer, technical writer, and educational content strategist with deep expertise in maintaining high-quality learning platforms. Provide actionable, specific, and technically sound recommendations."
                    },
                    {
                        "role": "user", 
                        "content": analysis_prompt
                    }
                ],
                max_tokens=3000,
                temperature=0.3  # Lower temperature for more focused, technical responses
            )
            
            # Parse AI response
            ai_response = response.choices[0].message.content
            
            try:
                # Try to parse as JSON
                analysis_result = json.loads(ai_response)
            except json.JSONDecodeError:
                # Fallback: extract JSON from response if it's wrapped in markdown
                json_match = re.search(r'```json\s*(.*?)\s*```', ai_response, re.DOTALL)
                if json_match:
                    analysis_result = json.loads(json_match.group(1))
                else:
                    # If JSON parsing fails completely, return structured fallback
                    analysis_result = {
                        "executive_summary": "AI analysis completed with parsing issues",
                        "raw_analysis": ai_response,
                        "analysis_status": "partial"
                    }
            
            # Add metadata
            analysis_result['ai_analysis_metadata'] = {
                'model_used': 'gpt-4',
                'analysis_timestamp': self.analysis_timestamp,
                'tokens_used': response.usage.total_tokens if hasattr(response, 'usage') else 'unknown',
                'broken_links_analyzed': len(broken_links)
            }
            
            return analysis_result
            
        except Exception as e:
            logger.error(f"AI analysis failed: {str(e)}")
            # Return fallback analysis
            return {
                "executive_summary": f"Automated analysis detected {len(broken_links)} broken links requiring attention",
                "error": str(e),
                "fallback_analysis": True,
                "broken_links_count": len(broken_links),
                "categories_identified": list(categorized_links.keys()),
                "patterns_identified": identified_patterns
            }
    
    def generate_actionable_report(self, analysis_result: Dict, scan_data: Dict) -> str:
        """Generate a comprehensive, actionable report for GitHub issues"""
        
        summary = scan_data['summary']
        repo_context = scan_data['repository_context']
        
        report = f"""# 🔗 Hyperlink Guardian Intelligence Report

## 📊 Executive Dashboard

**Scan Timestamp**: {summary.get('scan_timestamp', 'Unknown')}
**Repository**: {repo_context.get('repository', 'Unknown')}
**Site URL**: {summary.get('site_url', 'Unknown')}
**Workflow Run**: #{repo_context.get('workflow_run_id', 'Unknown')}

### Health Metrics
- 🔗 **Total Links**: {summary.get('total_links', 0)}
- ✅ **Working Links**: {summary.get('working_links', 0)}
- ❌ **Broken Links**: {summary.get('broken_links', 0)}
- 📈 **Success Rate**: {summary.get('success_rate', 0):.1f}%

"""
        
        if analysis_result.get('executive_summary'):
            report += f"""## 🧠 AI Analysis Summary

{analysis_result['executive_summary']}

"""
        
        # Priority Actions Section
        if analysis_result.get('priority_actions'):
            report += f"""## 🎯 Priority Actions

"""
            for i, action in enumerate(analysis_result['priority_actions'], 1):
                priority_emoji = {"high": "🔴", "medium": "🟡", "low": "🟢"}.get(action.get('priority', 'medium'), "🟡")
                effort_emoji = {"low": "⚡", "medium": "⚙️", "high": "🏗️"}.get(action.get('effort', 'medium'), "⚙️")
                
                report += f"""### {i}. {action.get('action', 'Action needed')}
- **Priority**: {priority_emoji} {action.get('priority', 'Medium').title()}
- **Effort**: {effort_emoji} {action.get('effort', 'Medium').title()}
- **Impact**: {action.get('impact', 'Medium').title()}
- **Timeline**: {action.get('timeline', 'Unknown')}

"""
        
        # Category Analysis
        if analysis_result.get('category_analysis'):
            report += f"""## 📂 Broken Link Category Analysis

"""
            for category, details in analysis_result['category_analysis'].items():
                impact_emoji = {"high": "🔴", "medium": "🟡", "low": "🟢"}.get(details.get('impact', 'medium'), "🟡")
                
                report += f"""### {category.replace('_', ' ').title()}
- **Impact**: {impact_emoji} {details.get('impact', 'Medium').title()}
- **Root Cause**: {details.get('root_cause', 'Analysis needed')}
- **Timeline**: {details.get('timeline', 'Unknown')}

**Recommended Actions**:
"""
                for action in details.get('recommended_actions', []):
                    report += f"- {action}\n"
                
                report += "\n"
        
        # Technical Recommendations
        if analysis_result.get('technical_recommendations'):
            report += f"""## 🔧 Technical Recommendations

"""
            for i, rec in enumerate(analysis_result['technical_recommendations'], 1):
                complexity_emoji = {"low": "🟢", "medium": "🟡", "high": "🔴"}.get(rec.get('implementation_complexity', 'medium'), "🟡")
                
                report += f"""### {i}. {rec.get('recommendation', 'Recommendation')}
- **Complexity**: {complexity_emoji} {rec.get('implementation_complexity', 'Medium').title()}
- **Justification**: {rec.get('justification', 'Details needed')}

"""
        
        # Preventive Measures
        if analysis_result.get('preventive_measures'):
            report += f"""## 🛡️ Preventive Measures

"""
            for i, measure in enumerate(analysis_result['preventive_measures'], 1):
                report += f"""### {i}. {measure.get('measure', 'Preventive measure')}
**Implementation**: {measure.get('implementation', 'Details needed')}
**Automation Potential**: {measure.get('automation_potential', 'Assessment needed')}

"""
        
        # Educational Impact
        if analysis_result.get('educational_impact'):
            report += f"""## 📚 Educational Impact Assessment

{analysis_result['educational_impact']}

"""
        
        # Monitoring Suggestions
        if analysis_result.get('monitoring_suggestions'):
            report += f"""## 📊 Enhanced Monitoring Recommendations

"""
            for suggestion in analysis_result['monitoring_suggestions']:
                report += f"- {suggestion}\n"
        
        # Raw Data Section
        if summary.get('broken_link_details'):
            report += f"""## 📋 Detailed Link Test Results

| URL | Status | Error Details |
|-----|--------|---------------|
"""
            for link in summary['broken_link_details'][:20]:  # Limit to prevent overly long issues
                url = link.get('url', 'Unknown')[:80] + ('...' if len(link.get('url', '')) > 80 else '')
                status = link.get('status_code', 'Unknown')
                error = link.get('error_message', 'N/A')[:50] + ('...' if len(link.get('error_message', '')) > 50 else '')
                report += f"| {url} | {status} | {error} |\n"
            
            if len(summary['broken_link_details']) > 20:
                report += f"\n*Showing first 20 of {len(summary['broken_link_details'])} broken links*\n"
        
        # Metadata footer
        report += f"""
---

## 🤖 Analysis Metadata

**AI Model**: {analysis_result.get('ai_analysis_metadata', {}).get('model_used', 'Unknown')}
**Analysis Timestamp**: {analysis_result.get('ai_analysis_metadata', {}).get('analysis_timestamp', 'Unknown')}
**Links Analyzed**: {analysis_result.get('ai_analysis_metadata', {}).get('broken_links_analyzed', 'Unknown')}

*This report was automatically generated by the Hyperlink Guardian with AI-powered analysis.*
"""
        
        return report

def main():
    """Main execution function for AI analysis"""
    
    # Configuration
    input_dir = "./analysis-input"
    output_file = "./ai_analysis_result.json"
    report_file = "./analysis_report.md"
    
    # Check for required environment variables
    api_key = os.environ.get('OPENAI_API_KEY')
    if not api_key:
        logger.error("OPENAI_API_KEY environment variable is required")
        sys.exit(1)
    
    try:
        # Initialize AI engine
        logger.info("🧠 Initializing Hyperlink Intelligence Engine...")
        ai_engine = HyperlinkIntelligenceEngine(api_key)
        
        # Load scan data
        logger.info("📂 Loading scan data...")
        scan_data = ai_engine.load_scan_data(input_dir)
        
        # Generate AI analysis
        logger.info("🔍 Generating AI analysis...")
        analysis_result = ai_engine.generate_ai_analysis(scan_data)
        
        # Save analysis result
        with open(output_file, 'w') as f:
            json.dump(analysis_result, f, indent=2)
        logger.info(f"💾 Analysis saved to {output_file}")
        
        # Generate actionable report
        logger.info("📝 Generating actionable report...")
        report = ai_engine.generate_actionable_report(analysis_result, scan_data)
        
        with open(report_file, 'w') as f:
            f.write(report)
        logger.info(f"📋 Report saved to {report_file}")
        
        # Output summary for GitHub Actions
        broken_count = scan_data['summary'].get('broken_links', 0)
        logger.info(f"✅ Analysis complete! Found {broken_count} broken links.")
        
        return analysis_result
        
    except Exception as e:
        logger.error(f"❌ Analysis failed: {str(e)}")
        sys.exit(1)

if __name__ == "__main__":
    main()