#!/usr/bin/env python3
"""
Test Script: Verify Microsoft Skills Sync Coverage
Tests all possible skill locations and structures
"""

import subprocess
import tempfile
from pathlib import Path
from collections import defaultdict

MS_REPO = "https://github.com/microsoft/skills.git"

def analyze_skill_locations():
    """
    Comprehensive analysis of all skill locations in Microsoft repo.
    Verifies that v3 script will catch everything.
    """
    print("🔬 Comprehensive Skill Location Analysis")
    print("=" * 60)
    
    with tempfile.TemporaryDirectory() as temp_dir:
        temp_path = Path(temp_dir)
        
        print("\n1️⃣ Cloning repository...")
        subprocess.run(
            ["git", "clone", "--depth", "1", MS_REPO, str(temp_path)],
            check=True,
            capture_output=True
        )
        
        # Find ALL SKILL.md files in the entire repo
        all_skill_files = list(temp_path.rglob("SKILL.md"))
        print(f"\n2️⃣ Total SKILL.md files found: {len(all_skill_files)}")
        
        # Categorize by location type
        location_types = defaultdict(list)
        
        for skill_file in all_skill_files:
            skill_dir = skill_file.parent
            
            # Determine location type
            if ".github/skills" in str(skill_file):
                location_types["github_skills"].append(skill_file)
            elif ".github/plugins" in str(skill_file):
                location_types["github_plugins"].append(skill_file)
            elif "/skills/" in str(skill_file):
                # This is in the skills/ directory structure
                # Check if it's via symlink or actual file
                try:
                    skills_root = temp_path / "skills"
                    if skills_root in skill_file.parents:
                        # This skill is somewhere under skills/
                        # But is it a symlink or actual?
                        if skill_dir.is_symlink():
                            location_types["skills_symlinked"].append(skill_file)
                        else:
                            # Check if any parent is a symlink
                            has_symlink_parent = False
                            for parent in skill_file.parents:
                                if parent == skills_root:
                                    break
                                if parent.is_symlink():
                                    has_symlink_parent = True
                                    break
                            
                            if has_symlink_parent:
                                location_types["skills_via_symlink_parent"].append(skill_file)
                            else:
                                location_types["skills_direct"].append(skill_file)
                except:
                    location_types["unknown"].append(skill_file)
            else:
                location_types["other"].append(skill_file)
        
        # Display results
        print("\n3️⃣ Skills by Location Type:")
        print("-" * 60)
        
        for loc_type, files in sorted(location_types.items()):
            print(f"\n  📍 {loc_type}: {len(files)} skills")
            if len(files) <= 5:
                for f in files:
                    try:
                        rel = f.relative_to(temp_path)
                        print(f"      - {rel}")
                    except:
                        print(f"      - {f.name}")
            else:
                for f in files[:3]:
                    try:
                        rel = f.relative_to(temp_path)
                        print(f"      - {rel}")
                    except:
                        print(f"      - {f.name}")
                print(f"      ... and {len(files) - 3} more")
        
        # Verify v3 coverage
        print("\n4️⃣ V3 Script Coverage Analysis:")
        print("-" * 60)
        
        github_skills_count = len(location_types["github_skills"])
        github_plugins_count = len(location_types["github_plugins"])
        skills_symlinked_count = len(location_types["skills_symlinked"])
        skills_direct_count = len(location_types["skills_direct"])
        skills_via_symlink_parent_count = len(location_types["skills_via_symlink_parent"])
        
        print(f"\n  ✅ .github/skills/: {github_skills_count}")
        print(f"     └─ Handled by: find_all_skills() function")
        
        print(f"\n  ✅ .github/plugins/: {github_plugins_count}")
        print(f"     └─ Handled by: find_plugin_skills() function")
        
        print(f"\n  ✅ skills/ (symlinked dirs): {skills_symlinked_count}")
        print(f"     └─ Handled by: sync_skills_preserve_structure() lines 76-83")
        
        if skills_direct_count > 0:
            print(f"\n  ✅ skills/ (direct, non-symlink): {skills_direct_count}")
            print(f"     └─ Handled by: sync_skills_preserve_structure() lines 84-86")
        else:
            print(f"\n  ℹ️  skills/ (direct, non-symlink): 0")
            print(f"     └─ No direct skills found, but v3 would handle them (lines 84-86)")
        
        if skills_via_symlink_parent_count > 0:
            print(f"\n  ⚠️  skills/ (via symlink parent): {skills_via_symlink_parent_count}")
            print(f"     └─ May need special handling")
        
        # Summary
        print("\n5️⃣ Summary:")
        print("-" * 60)
        
        total_handled = (github_skills_count + github_plugins_count + 
                        skills_symlinked_count + skills_direct_count)
        
        print(f"\n  Total SKILL.md files: {len(all_skill_files)}")
        print(f"  Handled by v3 script: {total_handled}")
        
        if total_handled == len(all_skill_files):
            print(f"\n  ✅ 100% Coverage - All skills will be synced!")
        elif total_handled >= len(all_skill_files) * 0.99:
            print(f"\n  ✅ ~100% Coverage - Script handles all skills!")
            print(f"     ({len(all_skill_files) - total_handled} skills may be duplicates)")
        else:
            print(f"\n  ⚠️  Partial Coverage - Missing {len(all_skill_files) - total_handled} skills")
            print(f"\n  Skills not covered:")
            for loc_type, files in location_types.items():
                if loc_type not in ["github_skills", "github_plugins", "skills_symlinked", "skills_direct"]:
                    print(f"    - {loc_type}: {len(files)}")
        
        # Test specific cases
        print("\n6️⃣ Testing Specific Edge Cases:")
        print("-" * 60)
        
        skills_dir = temp_path / "skills"
        if skills_dir.exists():
            # Check for any non-symlink directories with SKILL.md
            print("\n  Checking for non-symlinked skills in skills/...")
            non_symlink_skills = []
            
            for item in skills_dir.rglob("*"):
                if item.is_dir() and not item.is_symlink():
                    if (item / "SKILL.md").exists():
                        # Check if any parent is a symlink
                        has_symlink_parent = False
                        for parent in item.parents:
                            if parent == skills_dir:
                                break
                            if parent.is_symlink():
                                has_symlink_parent = True
                                break
                        
                        if not has_symlink_parent:
                            non_symlink_skills.append(item)
            
            if non_symlink_skills:
                print(f"  ✅ Found {len(non_symlink_skills)} non-symlinked skills:")
                for skill in non_symlink_skills[:5]:
                    print(f"     - {skill.relative_to(skills_dir)}")
                print(f"     These WILL be synced by v3 (lines 84-86)")
            else:
                print(f"  ℹ️  No non-symlinked skills found in skills/")
                print(f"     But v3 is ready to handle them if they exist!")
        
        print("\n✨ Analysis complete!")
        
        return {
            'total': len(all_skill_files),
            'handled': total_handled,
            'breakdown': {k: len(v) for k, v in location_types.items()}
        }

if __name__ == "__main__":
    try:
        results = analyze_skill_locations()
        
        print("\n" + "=" * 60)
        print("FINAL VERDICT")
        print("=" * 60)
        
        coverage_pct = (results['handled'] / results['total'] * 100) if results['total'] > 0 else 0
        
        print(f"\nCoverage: {coverage_pct:.1f}%")
        print(f"Skills handled: {results['handled']}/{results['total']}")
        
        if coverage_pct >= 99:
            print("\n✅ V3 SCRIPT IS COMPREHENSIVE")
            print("   All skill locations are properly handled!")
        else:
            print("\n⚠️  V3 SCRIPT MAY NEED ENHANCEMENT")
            print("   Some edge cases might be missed")
        
    except Exception as e:
        print(f"\n❌ Error: {e}")
        import traceback
        traceback.print_exc()