#!/usr/bin/env python3
"""
MCP Browser command-line interface.
"""

import os
import sys
import asyncio
import argparse
import json
from pathlib import Path
from typing import Optional, Dict, Any

from .proxy import MCPBrowser
from .config import ConfigLoader
from .daemon import MCPBrowserDaemon, MCPBrowserClient, get_socket_path, is_daemon_running, kill_daemon_with_children
from .logging_config import setup_logging, get_logger
from .http_gateway import run_streamable_http_gateway


def build_mcp_request(args) -> Dict[str, Any]:
    """Build JSON-RPC request from command line arguments."""
    if args.command == "tools-list":
        return {
            "jsonrpc": "2.0",
            "id": 1,
            "method": "tools/list",
            "params": {}
        }
    
    elif args.command == "tools-call":
        return {
            "jsonrpc": "2.0",
            "id": 1,
            "method": "tools/call",
            "params": {
                "name": args.name,
                "arguments": json.loads(args.arguments)
            }
        }
    
    elif args.command == "resources-list":
        return {
            "jsonrpc": "2.0",
            "id": 1,
            "method": "resources/list",
            "params": {}
        }
    
    elif args.command == "resources-read":
        return {
            "jsonrpc": "2.0",
            "id": 1,
            "method": "resources/read",
            "params": {
                "uri": args.uri
            }
        }
    
    elif args.command == "prompts-list":
        return {
            "jsonrpc": "2.0",
            "id": 1,
            "method": "prompts/list",
            "params": {}
        }
    
    elif args.command == "prompts-get":
        return {
            "jsonrpc": "2.0",
            "id": 1,
            "method": "prompts/get",
            "params": {
                "name": args.name,
                "arguments": json.loads(args.arguments)
            }
        }
    
    elif args.command == "completion":
        params = {}
        if args.ref:
            params["ref"] = {"type": "ref/resource", "uri": args.ref}
        if args.argument:
            params["argument"] = args.argument
            
        return {
            "jsonrpc": "2.0",
            "id": 1,
            "method": "completion/complete",
            "params": params
        }
    
    elif args.command == "jsonrpc":
        request = json.loads(args.request)
        if "jsonrpc" not in request:
            request["jsonrpc"] = "2.0"
        if "id" not in request:
            request["id"] = 1
        return request
    
    else:
        raise ValueError(f"Unknown command: {args.command}")


def format_mcp_response(args, request: Dict[str, Any], response: Dict[str, Any]):
    """Format and print MCP response based on command."""
    logger = get_logger(__name__)
    if args.debug:
        logger.debug(f"Request: {json.dumps(request)}")
        logger.debug(f"Response: {json.dumps(response)}")
    
    # Format output based on command
    if args.command == "tools-list" and "result" in response:
        tools = response["result"].get("tools", [])
        print(f"Found {len(tools)} tools:")
        for tool in tools:
            print(f"  - {tool['name']}: {tool.get('description', 'No description')}")
    
    elif args.command == "tools-call" and "result" in response:
        # Format tool response
        result = response["result"]
        if "content" in result:
            for content in result["content"]:
                if content.get("type") == "text":
                    print(content.get("text", ""))
                else:
                    print(json.dumps(content, indent=2))
        else:
            print(json.dumps(result, indent=2))
    
    elif args.command == "resources-list" and "result" in response:
        resources = response["result"].get("resources", [])
        print(f"Found {len(resources)} resources:")
        for res in resources:
            print(f"  - {res['uri']}: {res.get('name', 'Unnamed')}")
    
    elif args.command == "prompts-list" and "result" in response:
        prompts = response["result"].get("prompts", [])
        print(f"Found {len(prompts)} prompts:")
        for prompt in prompts:
            print(f"  - {prompt['name']}: {prompt.get('description', 'No description')}")
    
    elif args.command == "jsonrpc":
        # For raw JSON-RPC, output the full response as JSON
        print(json.dumps(response))
    
    else:
        # Default: pretty print result
        if "result" in response:
            print(json.dumps(response["result"], indent=2))
        elif "error" in response:
            print(f"Error: {response['error'].get('message', 'Unknown error')}")
            if args.debug:
                logger.debug(f"Error details: {json.dumps(response['error'])}")
        else:
            print(json.dumps(response, indent=2))


async def interactive_mode(browser: MCPBrowser):
    """Run MCP Browser in interactive mode."""
    print("MCP Browser Interactive Mode")
    print("=" * 50)
    print(f"Server: {browser._server_name or browser.config.default_server}")
    print(f"Sparse mode: {'enabled' if browser.config.sparse_mode else 'disabled'}")
    print("Type 'help' for commands, 'exit' to quit\n")
    
    while True:
        try:
            command = input("> ").strip()
            
            if command == "exit":
                break
            elif command == "help":
                print("\nCommands:")
                print("  list              - List available tools (sparse mode)")
                print("  discover <path>   - Discover tools using JSONPath") 
                print("  call <json>       - Execute JSON-RPC call")
                print("  onboard [<id>]    - Show/set onboarding for identity")
                print("  reload            - Reload configuration")
                print("  status            - Show connection status")
                print("  exit              - Exit interactive mode")
                print("\nExamples:")
                print('  discover $.tools[*].name               # Get all tool names')
                print('  discover $.tools[0].inputSchema        # Get first tool schema')
                print('  call {"method": "tools/list"}          # Raw JSON-RPC call')
                print('  onboard MyProject                      # Get project onboarding')
                print('\nJSONPath syntax:')
                print('  $                 - Root object')
                print('  .tools[*]         - All tools')
                print('  .tools[0]         - First tool')
                print('  .tools[*].name    - All tool names')
                continue
                
            elif command.startswith("discover "):
                jsonpath = command[9:]
                result = browser.discover(jsonpath)
                print(json.dumps(result, indent=2))
                
            elif command.startswith("call "):
                json_str = command[5:]
                request = json.loads(json_str)
                if "jsonrpc" not in request:
                    request["jsonrpc"] = "2.0"
                response = await browser.call(request)
                print(json.dumps(response, indent=2))
                
            elif command.startswith("onboard "):
                identity = command[8:]
                response = await browser.call({
                    "jsonrpc": "2.0",
                    "method": "tools/call",
                    "params": {
                        "name": "onboarding",
                        "arguments": {"identity": identity}
                    }
                })
                if "result" in response:
                    print(response["result"]["content"][0]["text"])
                    
            elif command == "list":
                response = await browser.call({
                    "jsonrpc": "2.0",
                    "method": "tools/list"
                })
                if "result" in response:
                    tools = response["result"]["tools"]
                    for tool in tools:
                        print(f"- {tool['name']}: {tool['description']}")
                        
            else:
                print("Unknown command. Type 'help' for available commands.")
                
        except KeyboardInterrupt:
            print("\nUse 'exit' to quit")
        except Exception as e:
            print(f"Error: {e}")


def show_available_servers(config_path: Optional[str] = None):
    """Show list of available MCP servers from configuration."""
    loader = ConfigLoader(Path(config_path) if config_path else None)
    config = loader.load()
    
    print("Available MCP Servers:")
    print("=" * 50)
    
    for name, server in config.servers.items():
        print(f"\n{name}:")
        print(f"  Description: {server.description or 'No description'}")
        print(f"  Command: {' '.join(server.command) if server.command else 'Built-in only'}")
        if server.env:
            print(f"  Environment: {', '.join(server.env.keys())}")
    
    print(f"\nDefault server: {config.default_server}")
    print(f"Config location: {loader.config_path}")


def show_configuration(config_path: Optional[str] = None):
    """Show current configuration file path and content."""
    loader = ConfigLoader(Path(config_path) if config_path else None)
    
    print(f"Configuration file: {loader.config_path}")
    print("=" * 50)
    
    if loader.config_path.exists():
        with open(loader.config_path) as f:
            print(f.read())
    else:
        print("Configuration file not found. Will be created on first run.")


async def test_server_connection(browser: MCPBrowser, server_name: Optional[str] = None):
    """Test connection to specified MCP server."""
    print(f"Testing connection to server: {server_name or 'default'}")
    print("=" * 50)
    
    try:
        await browser.initialize()
        print("✓ Successfully connected to server")
        
        # Try to list tools
        response = await browser.call({
            "jsonrpc": "2.0",
            "method": "tools/list"
        })
        
        if "result" in response:
            tools = response["result"]["tools"]
            print(f"✓ Server provides {len(tools)} tools")
            if browser.config.sparse_mode:
                print("  (Showing sparse tools only)")
        else:
            print("✗ Failed to list tools")
            
    except Exception as e:
        print(f"✗ Connection failed: {e}")
        return
    finally:
        await browser.close()
    
    print("\nConnection test completed successfully!")


async def handle_mcp_command(args):
    """Handle MCP method commands by simulating JSON-RPC calls."""
    # Check if we should use daemon mode
    socket_path = get_socket_path(args.server)
    
    if hasattr(args, 'use_daemon') and args.use_daemon and is_daemon_running(socket_path):
        # Use daemon client
        async with MCPBrowserClient(socket_path) as client:
            request = build_mcp_request(args)
            response = await client.call(request)
            format_mcp_response(args, request, response)
        return
    
    # Create browser directly
    config_path = Path(args.config) if args.config else None
    
    # Set debug in config if requested
    if args.debug and config_path is None:
        from .config import ConfigLoader
        loader = ConfigLoader()
        config = loader.load()
        config.debug = True
    
    browser = MCPBrowser(
        server_name=args.server,
        config_path=config_path,
        enable_builtin_servers=not args.no_builtin,
        transport_override=getattr(args, "transport_override", None)
    )
    
    try:
        await browser.initialize()
        
        # Build and send request
        request = build_mcp_request(args)
        response = await browser.call(request)
        
        # Format response
        format_mcp_response(args, request, response)
        
    except Exception as e:
        print(f"Error: {e}")
        if args.debug:
            import traceback
            traceback.print_exc(file=sys.stderr)
    finally:
        await browser.close()


async def run_daemon_mode(browser: MCPBrowser, socket_path: Path):
    """Run MCP Browser in daemon mode."""
    daemon = MCPBrowserDaemon(browser, socket_path)
    await daemon.start()


async def start_daemon_background(args):
    """Start daemon in background."""
    socket_path = get_socket_path(args.server)
    
    if is_daemon_running(socket_path):
        print(f"Killing existing daemon for server: {args.server or 'default'}")
        if kill_daemon_with_children(socket_path):
            print("Existing daemon and children killed successfully")
            # Wait a moment for cleanup
            import time
            time.sleep(0.5)
        else:
            print("Warning: Failed to kill existing daemon cleanly")
    
    # Fork to background
    pid = os.fork()
    if pid > 0:
        # Parent process
        print(f"Starting daemon in background (PID: {pid})")
        return
    
    # Child process
    # Detach from terminal
    os.setsid()
    
    # Second fork to prevent zombie processes
    try:
        pid = os.fork()
        if pid > 0:
            # First child exits, orphaning the daemon
            sys.exit(0)
    except OSError as e:
        print(f"Fork #2 failed: {e}", file=sys.stderr)
        sys.exit(1)
    
    # Close file descriptors
    sys.stdin.close()
    sys.stdout.close()
    sys.stderr.close()
    
    # Redirect stdout/stderr to log file
    log_dir = socket_path.parent / "logs"
    log_dir.mkdir(parents=True, exist_ok=True)
    log_file = log_dir / f"mcp-browser-{args.server or 'default'}.log"
    
    # Open new file descriptors
    sys.stdin = open(os.devnull, 'r')
    sys.stdout = open(log_file, 'a', buffering=1)
    sys.stderr = sys.stdout
    
    # Create browser
    config_path = Path(args.config) if args.config else None
    browser = MCPBrowser(
        server_name=args.server,
        config_path=config_path,
        enable_builtin_servers=not args.no_builtin,
        transport_override=getattr(args, "transport_override", None)
    )
    
    # Run daemon
    try:
        asyncio.run(run_daemon_mode(browser, socket_path))
    except Exception as e:
        print(f"Daemon error: {e}", file=sys.stderr)
        sys.exit(1)


def stop_daemon(args):
    """Stop running daemon and all child processes."""
    socket_path = get_socket_path(args.server)
    
    if not is_daemon_running(socket_path):
        print(f"No daemon running for server: {args.server or 'default'}")
        return
    
    pid_file = socket_path.with_suffix('.pid')
    try:
        pid = int(pid_file.read_text().strip())
        print(f"Stopping daemon (PID: {pid}) and all child processes...")
        
        if kill_daemon_with_children(socket_path):
            print("Daemon and all children stopped successfully")
        else:
            print("Warning: Daemon may not have been stopped cleanly")
    except Exception as e:
        print(f"Error stopping daemon: {e}")


def show_daemon_status(args):
    """Show daemon status."""
    socket_path = get_socket_path(args.server)
    
    if is_daemon_running(socket_path):
        pid_file = socket_path.with_suffix('.pid')
        pid = pid_file.read_text().strip()
        print(f"Daemon running (PID: {pid})")
        print(f"Socket: {socket_path}")
    else:
        print(f"No daemon running for server: {args.server or 'default'}")


async def run_server_mode(browser: MCPBrowser):
    """Run MCP Browser as an MCP server (stdin/stdout)."""
    import sys
    
    # Don't initialize here - let it happen lazily when Claude sends initialize request
    # This prevents timeout issues when the browser tries to connect to upstream servers
    
    # Read JSON-RPC from stdin line by line
    while True:
        try:
            line = sys.stdin.readline()
            if not line:  # EOF
                break
                
            line = line.strip()
            if not line:  # Empty line
                continue
                
            try:
                request = json.loads(line)
                response = await browser.call(request)
                print(json.dumps(response))
                sys.stdout.flush()
            except json.JSONDecodeError as e:
                # Send error response for malformed JSON
                error_response = {
                    "jsonrpc": "2.0",
                    "id": None,
                    "error": {
                        "code": -32700,
                        "message": "Parse error",
                        "data": str(e)
                    }
                }
                print(json.dumps(error_response))
                sys.stdout.flush()
                
        except KeyboardInterrupt:
            break
        except EOFError:
            break


async def run_server_mode_with_daemon(socket_path: Path):
    """Run as MCP server but forward to daemon."""
    import sys
    
    async with MCPBrowserClient(socket_path) as client:
        # Read JSON-RPC from stdin line by line, forward to daemon
        while True:
            try:
                line = sys.stdin.readline()
                if not line:  # EOF
                    break
                    
                line = line.strip()
                if not line:  # Empty line
                    continue
                    
                try:
                    request = json.loads(line)
                    response = await client.call(request)
                    print(json.dumps(response))
                    sys.stdout.flush()
                except json.JSONDecodeError as e:
                    # Send error response for malformed JSON
                    error_response = {
                        "jsonrpc": "2.0",
                        "id": None,
                        "error": {
                            "code": -32700,
                            "message": "Parse error",
                            "data": str(e)
                        }
                    }
                    print(json.dumps(error_response))
                    sys.stdout.flush()
                            
            except KeyboardInterrupt:
                break
            except EOFError:
                break


async def interactive_mode_with_daemon(socket_path: Path):
    """Run interactive mode connected to daemon."""
    async with MCPBrowserClient(socket_path) as client:
        print("MCP Browser Interactive Mode (Daemon)")
        print("=" * 50)
        print(f"Connected to daemon at: {socket_path}")
        print("Type 'help' for commands, 'exit' to quit\n")
        
        while True:
            try:
                command = input("> ").strip()
                
                if command == "exit":
                    break
                elif command == "help":
                    print("\nCommands:")
                    print("  list              - List available tools (sparse mode)")
                    print("  discover <path>   - Discover tools using JSONPath") 
                    print("  call <json>       - Execute JSON-RPC call")
                    print("  exit              - Exit interactive mode")
                    continue
                    
                elif command.startswith("call "):
                    json_str = command[5:]
                    request = json.loads(json_str)
                    if "jsonrpc" not in request:
                        request["jsonrpc"] = "2.0"
                    if "id" not in request:
                        request["id"] = 1
                    response = await client.call(request)
                    print(json.dumps(response, indent=2))
                    
                elif command == "list":
                    response = await client.call({
                        "jsonrpc": "2.0",
                        "id": 1,
                        "method": "tools/list"
                    })
                    if "result" in response:
                        tools = response["result"]["tools"]
                        for tool in tools:
                            print(f"- {tool['name']}: {tool['description']}")
                            
                else:
                    print("Unknown command. Type 'help' for available commands.")
                    
            except KeyboardInterrupt:
                print("\nUse 'exit' to quit")
            except Exception as e:
                print(f"Error: {e}")


def main():
    """Main entry point."""
    # Parse args first to check for log configuration
    args_parser = argparse.ArgumentParser(add_help=False)
    args_parser.add_argument("--debug", action="store_true")
    args_parser.add_argument("--log-level")
    args_parser.add_argument("--log-file")
    early_args, _ = args_parser.parse_known_args()
    
    # Setup logging before anything else
    # IMPORTANT: In server mode, we must not log to stderr as it may interfere
    # Determine if we're in server mode early
    is_server_mode = "--mode" in sys.argv and "server" in sys.argv
    
    log_file = Path(early_args.log_file) if early_args.log_file else None
    
    # In server mode, use syslog unless a log file is specified
    use_syslog = is_server_mode and not log_file
    
    setup_logging(
        debug=early_args.debug,
        log_file=log_file,
        log_level=early_args.log_level,
        use_syslog=use_syslog
    )
    
    # Import version
    from . import __version__
    
    # Now create the full parser
    parser = argparse.ArgumentParser(
        description=f"MCP Browser v{__version__} - Universal Model Context Protocol Interface",
        epilog="""
Examples:
  # Interactive mode
  mcp-browser                          # Start interactive mode with default server
  mcp-browser --server brave-search    # Use Brave Search server
  
  # Configuration
  mcp-browser --list-servers           # List configured servers
  mcp-browser --show-config            # Show current configuration
  mcp-browser --test                   # Test server connection
  
  # MCP method commands
  mcp-browser tools-list               # List available tools
  mcp-browser tools-call brave_web_search '{"query": "MCP protocol"}'
  mcp-browser resources-list           # List available resources
  mcp-browser resources-read "file:///path/to/file"
  mcp-browser prompts-list             # List available prompts
  mcp-browser prompts-get "greeting" --arguments '{"name": "Alice"}'
  
  # Raw JSON-RPC
  mcp-browser jsonrpc '{"method": "tools/list", "params": {}}'
  
  # Server mode
  mcp-browser --mode server            # Run as MCP server (stdin/stdout)
  
Configuration:
  Default config: ~/.claude/mcp-browser/config.yaml
  First run creates default configuration with examples
  
Environment:
  Set API keys as needed: BRAVE_API_KEY, GITHUB_TOKEN, etc.
  Or source from: source ~/.secrets/api-keys.sh
        """,
        formatter_class=argparse.RawDescriptionHelpFormatter
    )
    parser.add_argument("--server", "-s", help="Target MCP server name (see --list-servers)")
    parser.add_argument("--config", "-c", help="Custom configuration file path")
    parser.add_argument("--mode", choices=["interactive", "server", "daemon", "streamable-http"], 
                       default="interactive", help="Operating mode (default: interactive)")
    parser.add_argument("--no-sparse", action="store_true", 
                       help="Disable sparse mode (show all tools)")
    parser.add_argument("--no-builtin", action="store_true",
                       help="Disable built-in servers (screen, memory, patterns)")
    parser.add_argument("--list-servers", action="store_true",
                       help="List available MCP servers from config")
    parser.add_argument("--show-config", action="store_true",
                       help="Show current configuration path and content")
    parser.add_argument("--test", action="store_true",
                       help="Test connection to specified server")
    parser.add_argument("--debug", action="store_true",
                       help="Enable debug output")
    parser.add_argument("--log-level", choices=["TRACE", "DEBUG", "INFO", "WARNING", "ERROR"],
                       help="Set logging level")
    parser.add_argument("--log-file", help="Log to file instead of stderr")
    parser.add_argument("--use-daemon", action="store_true",
                       help="Automatically use daemon if available")
    parser.add_argument("--daemon-start", action="store_true",
                       help="Start daemon in background")
    parser.add_argument("--daemon-stop", action="store_true",
                       help="Stop running daemon")
    parser.add_argument("--daemon-status", action="store_true",
                       help="Check daemon status")
    parser.add_argument("--version", "-v", action="version",
                       version=f"%(prog)s {__version__}",
                       help="Show program version and exit")
    parser.add_argument("--transport", choices=["stdio", "streamable-http"],
                       help="Override transport type for the target server")
    parser.add_argument("--transport-url",
                       help="Endpoint URL for streamable-http transport override")
    parser.add_argument("--transport-header", action="append", metavar="KEY=VALUE",
                       help="Additional HTTP headers for streamable-http transport (repeatable)")
    parser.add_argument("--transport-timeout", type=float,
                       help="Override HTTP request timeout in seconds")
    parser.add_argument("--transport-sse-timeout", type=float,
                       help="Override SSE read timeout in seconds")
    parser.add_argument("--oauth-token-url",
                       help="OAuth token endpoint for client credentials flow")
    parser.add_argument("--oauth-client-id", help="OAuth client identifier")
    parser.add_argument("--oauth-client-secret", help="OAuth client secret")
    parser.add_argument("--oauth-scope",
                       help="OAuth scopes (space-separated)")
    parser.add_argument("--oauth-audience",
                       help="OAuth audience/resource parameter")
    parser.add_argument("--oauth-extra-param", action="append", metavar="KEY=VALUE",
                       help="Additional form parameters for OAuth token requests (repeatable)")
    parser.add_argument("--oauth-token",
                       help="Static OAuth bearer token (applies Authorization header)")
    parser.add_argument("--http-host", default="127.0.0.1",
                       help="Host/interface for streamable-http gateway (when --mode streamable-http)")
    parser.add_argument("--http-port", type=int, default=0,
                       help="TCP port for streamable-http gateway (default 0 = random)")
    parser.add_argument("--http-path", default="/mcp",
                       help="HTTP path prefix for streamable-http gateway (default /mcp)")
    parser.add_argument("--http-allow-origin",
                       help="Optional Access-Control-Allow-Origin value for streamable-http gateway")
    
    # MCP method commands
    subparsers = parser.add_subparsers(dest="command", help="MCP methods")
    
    # tools/list command
    subparsers.add_parser("tools-list", help="List available tools")
    
    # tools/call command
    call_tool = subparsers.add_parser("tools-call", help="Call a tool")
    call_tool.add_argument("name", help="Tool name")
    call_tool.add_argument("arguments", help="Tool arguments as JSON")
    
    # resources/list command
    subparsers.add_parser("resources-list", help="List available resources")
    
    # resources/read command
    read_resource = subparsers.add_parser("resources-read", help="Read a resource")
    read_resource.add_argument("uri", help="Resource URI")
    
    # prompts/list command
    subparsers.add_parser("prompts-list", help="List available prompts")
    
    # prompts/get command
    get_prompt = subparsers.add_parser("prompts-get", help="Get a prompt")
    get_prompt.add_argument("name", help="Prompt name")
    get_prompt.add_argument("--arguments", "-a", help="Prompt arguments as JSON", default="{}")
    
    # completion command
    completion = subparsers.add_parser("completion", help="Get completion")
    completion.add_argument("--ref", help="Reference for completion")
    completion.add_argument("--argument", help="Argument name")
    
    # Generic JSON-RPC command
    jsonrpc = subparsers.add_parser("jsonrpc", help="Send raw JSON-RPC request")
    jsonrpc.add_argument("request", help="JSON-RPC request")
    
    args = parser.parse_args()
    
    def parse_key_value_pairs(pairs):
        result = {}
        if not pairs:
            return result
        for item in pairs:
            if "=" not in item:
                print(f"Invalid KEY=VALUE format: {item}", file=sys.stderr)
                sys.exit(2)
            key, value = item.split("=", 1)
            key = key.strip()
            value = value.strip()
            if not key:
                print(f"Header key is empty for entry: {item}", file=sys.stderr)
                sys.exit(2)
            result[key] = value
        return result
    
    transport_headers = parse_key_value_pairs(args.transport_header)
    oauth_extra = parse_key_value_pairs(args.oauth_extra_param)
    
    if args.oauth_token:
        transport_headers.setdefault("Authorization", f"Bearer {args.oauth_token}")
    
    oauth_override = {}
    if args.oauth_token_url:
        oauth_override["token_url"] = args.oauth_token_url
    if args.oauth_client_id:
        oauth_override["client_id"] = args.oauth_client_id
    if args.oauth_client_secret is not None:
        oauth_override["client_secret"] = args.oauth_client_secret
    if args.oauth_scope is not None:
        oauth_override["scope"] = args.oauth_scope
    if args.oauth_audience is not None:
        oauth_override["audience"] = args.oauth_audience
    if oauth_extra:
        oauth_override["extra_params"] = oauth_extra
    if args.oauth_token:
        oauth_override["access_token"] = args.oauth_token
    
    transport_override = None
    if any([
        args.transport,
        args.transport_url,
        transport_headers,
        args.transport_timeout is not None,
        args.transport_sse_timeout is not None,
        oauth_override,
    ]):
        transport_override = {}
        if args.transport:
            transport_override["type"] = args.transport
        if args.transport_url:
            transport_override["url"] = args.transport_url
        if transport_headers:
            transport_override["headers"] = transport_headers
        if args.transport_timeout is not None:
            transport_override["timeout"] = args.transport_timeout
        if args.transport_sse_timeout is not None:
            transport_override["sse_timeout"] = args.transport_sse_timeout
        if oauth_override:
            transport_override["oauth"] = oauth_override
    
    setattr(args, "transport_override", transport_override)
    
    # Handle special commands first
    if args.list_servers:
        show_available_servers(args.config)
        return
    
    if args.show_config:
        show_configuration(args.config)
        return
    
    # Handle daemon management commands
    if args.daemon_start:
        asyncio.run(start_daemon_background(args))
        return
    
    if args.daemon_stop:
        stop_daemon(args)
        return
    
    if args.daemon_status:
        show_daemon_status(args)
        return
    
    # Handle MCP method commands
    if args.command:
        asyncio.run(handle_mcp_command(args))
        return
    
    # Create browser
    config_path = Path(args.config) if args.config else None
    
    # Apply log level to config if set
    if args.log_level == "TRACE" and config_path is None:
        from .config import ConfigLoader
        loader = ConfigLoader()
        loader.load()
        # TRACE level shows raw I/O
    
    browser = MCPBrowser(
        server_name=args.server,
        config_path=config_path,
        enable_builtin_servers=not args.no_builtin,
        transport_override=transport_override
    )
    
    # Handle test mode
    if args.test:
        asyncio.run(test_server_connection(browser, args.server))
        return
    
    # Run in appropriate mode
    if args.mode == "server":
        # Run as MCP server (stdin/stdout) - can connect to daemon
        socket_path = get_socket_path(args.server)
        if args.use_daemon and is_daemon_running(socket_path):
            # Use daemon as backend
            asyncio.run(run_server_mode_with_daemon(socket_path))
        else:
            asyncio.run(run_server_mode(browser))
    elif args.mode == "daemon":
        # Run as daemon
        socket_path = get_socket_path(args.server)
        asyncio.run(run_daemon_mode(browser, socket_path))
    elif args.mode == "streamable-http":
        asyncio.run(
            run_streamable_http_gateway(
                browser,
                host=args.http_host,
                port=args.http_port,
                path=args.http_path,
                allow_origin=args.http_allow_origin,
            )
        )
    else:
        # Interactive mode - can use daemon if available
        socket_path = get_socket_path(args.server)
        if args.use_daemon and is_daemon_running(socket_path):
            asyncio.run(interactive_mode_with_daemon(socket_path))
        else:
            asyncio.run(async_main(browser))


async def async_main(browser: MCPBrowser):
    """Async main for interactive mode."""
    try:
        await browser.initialize()
        await interactive_mode(browser)
    finally:
        await browser.close()


if __name__ == "__main__":
    main()