# .github/workflows/hyperlink-guardian.yml
name: 🔗 Hyperlink Guardian - Daily Link Health Check

on:
  schedule:
    # Run every day at 3:00 AM UTC (adjust timezone as needed)
    - cron: '0 3 * * *'
  workflow_dispatch:  # Allow manual triggering
    inputs:
      force_scan:
        description: 'Force full site scan even if no changes detected'
        required: false
        default: 'false'
        type: boolean

env:
  SITE_URL: $
  OUTPUT_DIR: './link-check-results'

jobs:
  link-health-scan:
    name: 🔍 Scan Link Health
    runs-on: ubuntu-latest
    permissions:
      contents: read
      issues: write
    
    steps:
    - name: 🏰 Checkout Repository
      uses: actions/checkout@v4
      with:
        fetch-depth: 0  # Full history for change detection
    
    - name: 🔧 Setup Node.js Environment
      uses: actions/setup-node@v4
      with:
        node-version: '18'
        cache: 'npm'
    
    - name: 📦 Install Dependencies
      run: |
        npm install -g markdown-link-check
        sudo apt-get update
        sudo apt-get install -y curl jq bc
    
    - name: 🛠️ Prepare Hyperlink Guardian Script
      run: |
        # Create the link checking script
        cat > hyperlink-guardian.sh << 'SCRIPT_EOF'
        #!/bin/bash
        set -euo pipefail
        
        # Configuration
        SITE_URL="${SITE_URL:-https://bamr87.github.io/it-journey}"
        OUTPUT_DIR="${OUTPUT_DIR:-./link-check-results}"
        MAX_PARALLEL="${MAX_PARALLEL:-10}"
        TIMEOUT="${TIMEOUT:-30}"
        
        mkdir -p "$OUTPUT_DIR"
        
        echo "🔍 Hyperlink Guardian: Beginning domain scan..."
        echo "Target domain: $SITE_URL"
        echo "Timestamp: $(date -u +"%Y-%m-%d %H:%M:%S UTC")"
        
        # Function definitions from Chapter 1 script...
        # [Include all the functions from the previous script here]
        
        # Main execution
        scan_site_links() {
            # Implement the scanning logic here
            # This is a simplified version - use the full implementation from Chapter 1
            
            local results_file="$OUTPUT_DIR/test_results.csv"
            echo "timestamp|url|status_code|response_time|status|error_message" > "$results_file"
            
            # Find all markdown files and extract links
            find . -name "*.md" -o -name "*.markdown" | grep -v node_modules | grep -v .git | while read file; do
                echo "Scanning: $file"
                # Extract and test links (simplified for brevity)
                grep -oE '\[([^\]]*)\]\(([^)]+)\)' "$file" | sed 's/.*(\([^)]*\)).*/\1/' | while read url; do
                    if [[ "$url" =~ ^http ]]; then
                        status_code=$(curl -s -o /dev/null -w "%{http_code}" --max-time "$TIMEOUT" "$url" || echo "ERROR")
                        status="PASS"
                        if [[ "$status_code" == "ERROR" ]] || [[ "$status_code" -ge 400 ]]; then
                            status="FAIL"
                        fi
                        echo "$(date -u +"%Y-%m-%d %H:%M:%S")|$url|$status_code|0|$status|" >> "$results_file"
                    fi
                done
            done
        }
        
        generate_summary() {
            local results_file="$OUTPUT_DIR/test_results.csv"
            local summary_file="$OUTPUT_DIR/summary.json"
            
            local total_links=$(tail -n +2 "$results_file" | wc -l)
            local broken_links=$(tail -n +2 "$results_file" | grep -c "|FAIL|" || echo "0")
            local working_links=$((total_links - broken_links))
            
            cat > "$summary_file" << EOF
        {
          "scan_timestamp": "$(date -u +"%Y-%m-%d %H:%M:%S UTC")",
          "site_url": "$SITE_URL",
          "total_links": $total_links,
          "working_links": $working_links,
          "broken_links": $broken_links,
          "success_rate": $(echo "scale=2; $working_links * 100 / $total_links" | bc -l 2>/dev/null || echo "0"),
          "repository": "$GITHUB_REPOSITORY",
          "commit_sha": "$GITHUB_SHA",
          "broken_link_details": []
        }
        EOF
        }
        
        main() {
            scan_site_links
            generate_summary
            echo "🎉 Hyperlink Guardian scan complete!"
        }
        
        main "$@"
        SCRIPT_EOF
        
        chmod +x hyperlink-guardian.sh
    
    - name: 🔍 Execute Hyperlink Guardian Scan
      run: |
        echo "🚀 Starting comprehensive link health check..."
        ./hyperlink-guardian.sh
        
        echo "📊 Scan Results:"
        if [[ -f "$OUTPUT_DIR/summary.json" ]]; then
          cat "$OUTPUT_DIR/summary.json" | jq '.'
        fi
    
    - name: 📁 Upload Scan Results as Artifacts
      uses: actions/upload-artifact@v4
      with:
        name: link-health-results-$
        path: |
          $/
        retention-days: 30
    
    - name: 🤖 Prepare AI Analysis Data
      id: prepare-analysis
      run: |
        # Create a comprehensive data package for AI analysis
        ANALYSIS_DIR="./ai-analysis-input"
        mkdir -p "$ANALYSIS_DIR"
        
        # Copy scan results
        cp -r "$OUTPUT_DIR"/* "$ANALYSIS_DIR/"
        
        # Add repository context
        cat > "$ANALYSIS_DIR/repository_context.json" << EOF
        {
          "repository": "$GITHUB_REPOSITORY",
          "branch": "$GITHUB_REF_NAME",
          "commit_sha": "$GITHUB_SHA",
          "workflow_run_id": "$GITHUB_RUN_ID",
          "trigger": "$GITHUB_EVENT_NAME",
          "site_url": "$SITE_URL"
        }
        EOF
        
        # Add recent commit history for context
        git log --oneline -10 > "$ANALYSIS_DIR/recent_commits.txt"
        
        # Check if there are broken links
        BROKEN_COUNT=$(jq -r '.broken_links' "$OUTPUT_DIR/summary.json" 2>/dev/null || echo "0")
        echo "broken_count=$BROKEN_COUNT" >> $GITHUB_OUTPUT
        
        # Create analysis prompt
        cat > "$ANALYSIS_DIR/analysis_prompt.txt" << EOF
        Please analyze the hyperlink health scan results for the IT-Journey repository.
        
        Context:
        - This is a Jekyll-based GitHub Pages educational site
        - The site contains technical documentation, tutorials, and learning quests
        - Links may be to external documentation, GitHub repositories, tools, or internal content
        
        Analysis Requirements:
        1. Summarize the overall link health status
        2. Categorize broken links by type (external sites, GitHub repos, documentation, etc.)
        3. Identify patterns in link failures (specific domains, types of content, etc.)
        4. Provide root cause analysis for common failure types
        5. Suggest specific remediation actions for each broken link
        6. Recommend preventive measures to avoid future link rot
        7. Assess the impact on user experience and learning outcomes
        
        Please provide actionable insights that help maintain the educational value of this learning platform.
        EOF
        
        echo "🤖 AI analysis data prepared in $ANALYSIS_DIR"
        ls -la "$ANALYSIS_DIR"
    
    outputs:
      broken_count: $

  ai-analysis:
    name: 🧠 AI-Powered Link Analysis
    needs: link-health-scan
    runs-on: ubuntu-latest
    if: needs.link-health-scan.outputs.broken_count > 0
    permissions:
      contents: read
      issues: write
    
    steps:
    - name: 🏰 Checkout Repository
      uses: actions/checkout@v4
    
    - name: 📥 Download Scan Results
      uses: actions/download-artifact@v4
      with:
        name: link-health-results-$
        path: ./analysis-input
    
    - name: 🧠 Execute AI Analysis
      id: ai-analysis
      env:
        OPENAI_API_KEY: $
      run: |
        # Create AI analysis script
        cat > ai_analyzer.py << 'PYTHON_EOF'
        import json
        import os
        import sys
        from datetime import datetime
        
        try:
            import openai
        except ImportError:
            print("Installing OpenAI library...")
            os.system("pip install openai")
            import openai
        
        def analyze_link_health():
            # Load scan results
            with open('./analysis-input/summary.json', 'r') as f:
                summary = json.load(f)
            
            # Load repository context
            with open('./analysis-input/repository_context.json', 'r') as f:
                repo_context = json.load(f)
            
            # Load analysis prompt
            with open('./analysis-input/analysis_prompt.txt', 'r') as f:
                base_prompt = f.read()
            
            # Prepare data for AI analysis
            analysis_data = {
                "scan_summary": summary,
                "repository_context": repo_context,
                "analysis_prompt": base_prompt
            }
            
            # Configure OpenAI client
            client = openai.OpenAI(api_key=os.environ['OPENAI_API_KEY'])
            
            # Create analysis prompt
            prompt = f"""
            {base_prompt}
            
            Scan Results Summary:
            {json.dumps(summary, indent=2)}
            
            Repository Context:
            {json.dumps(repo_context, indent=2)}
            
            Please provide a comprehensive analysis in JSON format with the following structure:
            executive_summary
              ],
              "patterns_identified": ["pattern1", "pattern2"],
              "preventive_measures": ["measure1", "measure2"],
              "overall_recommendations": ["recommendation1", "recommendation2"],
              "impact_assessment": "description of impact on users"
            }}
            """
            
            # Make API call
            response = client.chat.completions.create(
                model="gpt-4",
                messages=[
                    {"role": "system", "content": "You are an expert DevOps engineer and technical writer specializing in maintaining high-quality educational content platforms."},
                    {"role": "user", "content": prompt}
                ],
                max_tokens=2000
            )
            
            # Extract and save analysis
            analysis_result = response.choices[0].message.content
            
            # Try to parse as JSON, fallback to text if needed
            try:
                analysis_json = json.loads(analysis_result)
                with open('./ai_analysis_result.json', 'w') as f:
                    json.dump(analysis_json, f, indent=2)
            except json.JSONDecodeError:
                # Save as text if JSON parsing fails
                with open('./ai_analysis_result.txt', 'w') as f:
                    f.write(analysis_result)
                analysis_json = {"raw_analysis": analysis_result}
            
            return analysis_json
        
        if __name__ == "__main__":
            try:
                result = analyze_link_health()
                print("✅ AI analysis completed successfully")
                print(json.dumps(result, indent=2))
            except Exception as e:
                print(f"❌ AI analysis failed: {str(e)}")
                sys.exit(1)
        PYTHON_EOF
        
        python ai_analyzer.py
        
        # Set output for next step
        if [[ -f "./ai_analysis_result.json" ]]; then
          echo "analysis_file=ai_analysis_result.json" >> $GITHUB_OUTPUT
        else
          echo "analysis_file=ai_analysis_result.txt" >> $GITHUB_OUTPUT
        fi
    
    - name: 📋 Create GitHub Issue with Analysis
      uses: actions/github-script@v7
      env:
        ANALYSIS_FILE: $
      with:
        script: |
          const fs = require('fs');
          const path = require('path');
          
          // Load scan summary
          const summary = JSON.parse(fs.readFileSync('./analysis-input/summary.json', 'utf8'));
          
          // Load AI analysis
          let aiAnalysis;
          const analysisPath = `./${process.env.ANALYSIS_FILE}`;
          if (process.env.ANALYSIS_FILE.endsWith('.json')) {
            aiAnalysis = JSON.parse(fs.readFileSync(analysisPath, 'utf8'));
          } else {
            aiAnalysis = { raw_analysis: fs.readFileSync(analysisPath, 'utf8') };
          }
          
          // Create issue body
          let issueBody = `# 🔗 Hyperlink Guardian Report
          
          **Scan Date**: ${summary.scan_timestamp}
          **Repository**: ${summary.repository || context.repo.owner + '/' + context.repo.repo}
          **Site URL**: ${summary.site_url}
          
          ## 📊 Summary Statistics
          
          - **Total Links Tested**: ${summary.total_links}
          - **Working Links**: ${summary.working_links}
          - **Broken Links**: ${summary.broken_links}
          - **Success Rate**: ${summary.success_rate}%
          
          `;
          
          if (summary.broken_links > 0) {
            issueBody += `## ❌ Broken Links Detected
          
          `;
            
            if (aiAnalysis.broken_links_analysis) {
              issueBody += `### 🧠 AI Analysis & Recommendations
          
          **Executive Summary**: ${aiAnalysis.executive_summary || 'Analysis completed'}
          
          #### Broken Link Details:
          `;
              
              aiAnalysis.broken_links_analysis.forEach((link, index) => {
                issueBody += `
          **${index + 1}. ${link.url}**
          - **Issue Type**: ${link.issue_type || 'Unknown'}
          - **Root Cause**: ${link.root_cause || 'Analysis pending'}
          - **Recommended Action**: ${link.recommended_action || 'Manual review required'}
          - **Priority**: ${link.priority || 'Medium'}
          
          `;
              });
              
              if (aiAnalysis.patterns_identified && aiAnalysis.patterns_identified.length > 0) {
                issueBody += `#### 🔍 Patterns Identified:
          ${aiAnalysis.patterns_identified.map(pattern => `- ${pattern}`).join('\n')}
          
          `;
              }
              
              if (aiAnalysis.preventive_measures && aiAnalysis.preventive_measures.length > 0) {
                issueBody += `#### 🛡️ Preventive Measures:
          ${aiAnalysis.preventive_measures.map(measure => `- ${measure}`).join('\n')}
          
          `;
              }
              
              if (aiAnalysis.overall_recommendations && aiAnalysis.overall_recommendations.length > 0) {
                issueBody += `#### 💡 Overall Recommendations:
          ${aiAnalysis.overall_recommendations.map(rec => `- ${rec}`).join('\n')}
          
          `;
              }
              
              if (aiAnalysis.impact_assessment) {
                issueBody += `#### 📈 Impact Assessment:
          ${aiAnalysis.impact_assessment}
          
          `;
              }
            } else if (aiAnalysis.raw_analysis) {
              issueBody += `### 🧠 AI Analysis:
          
          ${aiAnalysis.raw_analysis}
          `;
            }
            
            if (summary.broken_link_details && summary.broken_link_details.length > 0) {
              issueBody += `### 📋 Raw Link Test Results:
          
          | URL | Status Code | Error Message |
          |-----|-------------|---------------|
          `;
              
              summary.broken_link_details.forEach(link => {
                issueBody += `| ${link.url} | ${link.status_code} | ${link.error_message || 'N/A'} |\n`;
              });
            }
          } else {
            issueBody += `## ✅ All Links Healthy
          
          Great news! All ${summary.total_links} links are working correctly.
          `;
          }
          
          issueBody += `
          
          ---
          
          **Workflow Run**: [#${context.runNumber}](${context.payload.repository.html_url}/actions/runs/${context.runId})
          **Commit**: ${context.sha.substring(0, 7)}
          
          This issue was automatically created by the Hyperlink Guardian workflow. 🤖
          `;
          
          // Create the issue
          const issue = await github.rest.issues.create({
            owner: context.repo.owner,
            repo: context.repo.repo,
            title: `🔗 Hyperlink Health Report - ${summary.broken_links > 0 ? summary.broken_links + ' broken links detected' : 'All links healthy'} (${new Date(summary.scan_timestamp).toLocaleDateString()})`,
            body: issueBody,
            labels: summary.broken_links > 0 ? ['bug', 'links', 'automated-report'] : ['maintenance', 'links', 'automated-report']
          });
          
          console.log(`Created issue: ${issue.data.html_url}`);

  cleanup:
    name: 🧹 Cleanup Old Reports
    needs: [link-health-scan, ai-analysis]
    runs-on: ubuntu-latest
    if: always()
    permissions:
      contents: read
      issues: write
    
    steps:
    - name: 🏰 Checkout Repository
      uses: actions/checkout@v4
    
    - name: 🗑️ Close Old Link Health Issues
      uses: actions/github-script@v7
      with:
        script: |
          // Find and close old automated link health reports
          const { data: issues } = await github.rest.issues.listForRepo({
            owner: context.repo.owner,
            repo: context.repo.repo,
            labels: 'automated-report,links',
            state: 'open'
          });
          
          // Close issues older than 7 days
          const oneWeekAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000);
          
          for (const issue of issues) {
            const issueDate = new Date(issue.created_at);
            if (issueDate < oneWeekAgo) {
              await github.rest.issues.update({
                owner: context.repo.owner,
                repo: context.repo.repo,
                issue_number: issue.number,
                state: 'closed'
              });
              
              await github.rest.issues.createComment({
                owner: context.repo.owner,
                repo: context.repo.repo,
                issue_number: issue.number,
                body: 'Automatically closed by Hyperlink Guardian - report is more than 7 days old. 🤖'
              });
              
              console.log(`Closed old issue: #${issue.number}`);
            }
          }