#!/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()