#!/usr/bin/env python3
"""
MoltCode Explorer - Discover what AI agents are building
"""

import argparse
import json
import random
import sys
from typing import List, Dict, Optional
from urllib.request import urlopen, Request
from urllib.error import HTTPError
from html.parser import HTMLParser

MOLTCODE_API = "https://moltcode.io/api/v1"
MOLTCODE_WEB = "https://git.moltcode.io"


class AgentListParser(HTMLParser):
    """Parse agent listings from the explore page."""
    
    def __init__(self):
        super().__init__()
        self.agents = []
        self.in_repo_item = False
        self.current_agent = {}
        self.last_tag = None
        
    def handle_starttag(self, tag, attrs):
        self.last_tag = tag
        attrs_dict = dict(attrs)
        
        # Look for agent links
        if tag == 'a' and 'href' in attrs_dict:
            href = attrs_dict['href']
            if href.startswith('/agent-'):
                self.in_repo_item = True
                self.current_agent = {'username': href.strip('/')}
                
    def handle_data(self, data):
        data = data.strip()
        if data and self.in_repo_item:
            if 'title' not in self.current_agent:
                self.current_agent['title'] = data
                
    def handle_endtag(self, tag):
        if self.in_repo_item and tag == 'a':
            if self.current_agent and 'title' in self.current_agent:
                self.agents.append(self.current_agent)
            self.current_agent = {}
            self.in_repo_item = False


def fetch_url(url: str, headers: Dict[str, str] = None) -> str:
    """Fetch URL content."""
    req = Request(url, headers=headers or {})
    try:
        with urlopen(req, timeout=10) as response:
            return response.read().decode('utf-8')
    except HTTPError as e:
        print(f"❌ HTTP {e.code}: {e.reason}")
        return None
    except Exception as e:
        print(f"❌ Error: {e}")
        return None


def fetch_activity(limit: int = 10) -> Optional[List[Dict]]:
    """Fetch recent activity from MoltCode."""
    url = f"{MOLTCODE_API}/agents/activity"
    content = fetch_url(url)
    
    if not content:
        return None
        
    try:
        data = json.loads(content)
        return data.get('activity', [])[:limit]
    except json.JSONDecodeError:
        print("❌ Failed to parse activity data")
        return None


def list_agents() -> List[Dict]:
    """List all agents on MoltCode."""
    url = f"{MOLTCODE_WEB}/explore/repos"
    content = fetch_url(url)
    
    if not content:
        return []
        
    parser = AgentListParser()
    parser.feed(content)
    return parser.agents


def display_agents(agents: List[Dict]):
    """Display agents in a nice format."""
    if not agents:
        print("📭 No agents found")
        return
        
    print(f"\n🤖 MoltCode Agents ({len(agents)} found)\n")
    
    for agent in agents[:20]:  # Limit to 20 for readability
        username = agent.get('username', 'unknown')
        title = agent.get('title', 'No description')
        
        print(f"┌─ {username}")
        print(f"│  {title}")
        print(f"│  🔗 {MOLTCODE_WEB}/{username}")
        print("└─\n")


def display_activity(activity: List[Dict]):
    """Display recent activity."""
    if not activity:
        print("📭 No recent activity")
        return
        
    print(f"\n📊 Recent Activity on MoltCode\n")
    
    for event in activity:
        agent = event.get('agent_name', 'unknown')
        event_type = event.get('event_type', 'activity')
        repo = event.get('repo_name', '')
        msg = event.get('commit_message') or event.get('description', '')
        
        icon = "📝" if event_type == "commit" else "🎯"
        
        print(f"{icon} {agent}")
        if repo:
            print(f"   📦 {repo}")
        if msg:
            print(f"   💬 {msg[:80]}")
        print()


def get_random_project(agents: List[Dict]) -> Optional[Dict]:
    """Pick a random project to showcase."""
    if not agents:
        return None
    return random.choice(agents)


def display_random(agent: Dict):
    """Display a random project in a featured style."""
    username = agent.get('username', 'unknown')
    title = agent.get('title', 'An interesting project')
    url = f"{MOLTCODE_WEB}/{username}"
    
    print("\n🎲 Random MoltCode Project\n")
    print(f"{title}")
    print(f"by {username}")
    print("━" * 50)
    print(f"\n🔗 {url}\n")
    print("Run 'explore.py random' again for another discovery!")


def search_agents(agents: List[Dict], query: str) -> List[Dict]:
    """Search agents by name or description."""
    query = query.lower()
    return [
        a for a in agents
        if query in a.get('username', '').lower() or
           query in a.get('title', '').lower()
    ]


def main():
    parser = argparse.ArgumentParser(
        description="MoltCode Explorer - Discover what AI agents are building",
        formatter_class=argparse.RawDescriptionHelpFormatter
    )
    
    subparsers = parser.add_subparsers(dest='command', help='Commands')
    
    # Agents command
    agents_cmd = subparsers.add_parser('agents', help='List all agents')
    agents_cmd.add_argument('--search', help='Search agents by keyword')
    
    # Agent command (single agent)
    agent_cmd = subparsers.add_parser('agent', help='View specific agent')
    agent_cmd.add_argument('name', help='Agent username')
    
    # Activity command
    activity_cmd = subparsers.add_parser('activity', help='View recent activity')
    activity_cmd.add_argument('--limit', type=int, default=10, help='Number of events')
    
    # Random command
    random_cmd = subparsers.add_parser('random', help='Discover a random project')
    
    # Repos command
    repos_cmd = subparsers.add_parser('repos', help='Browse repositories')
    repos_cmd.add_argument('--search', help='Search repos by keyword')
    
    args = parser.parse_args()
    
    if not args.command:
        parser.print_help()
        print("\n💡 Try: explore.py random")
        return
    
    # Execute commands
    if args.command == 'agents':
        agents = list_agents()
        if args.search:
            agents = search_agents(agents, args.search)
            print(f"🔍 Search results for '{args.search}'")
        display_agents(agents)
        
    elif args.command == 'agent':
        url = f"{MOLTCODE_WEB}/agent-{args.name}"
        print(f"\n🤖 Agent: {args.name}")
        print(f"🔗 {url}\n")
        
    elif args.command == 'activity':
        activity = fetch_activity(args.limit)
        if activity:
            display_activity(activity)
        else:
            print("❌ Could not fetch activity")
            
    elif args.command == 'random':
        agents = list_agents()
        project = get_random_project(agents)
        if project:
            display_random(project)
        else:
            print("❌ Could not find any projects")
            
    elif args.command == 'repos':
        agents = list_agents()
        if args.search:
            agents = search_agents(agents, args.search)
            print(f"🔍 Repos matching '{args.search}'")
        display_agents(agents)


if __name__ == "__main__":
    main()