cli.py

#!/usr/bin/env python3
"""
Command-line interface for Email Routing Manager.
Provides both legacy compatibility and new OOP interface.
"""
import sys
import asyncio
import argparse
from pathlib import Path


def setup_parser():
    """Set up the command line argument parser."""
    parser = argparse.ArgumentParser(
        description="Cloudflare Email Routing Manager",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Examples:
  %(prog)s create dest@example.com 10     # Create 10 email rules
  %(prog)s update new@example.com         # Update all destinations
  %(prog)s delete --filter temp           # Delete rules with 'temp' in name
  %(prog)s list --filter routing          # List rules with 'routing' in name
  %(prog)s print results.json             # Print mappings from file
        """
    )
    
    subparsers = parser.add_subparsers(dest='command', help='Available commands')
    
    # Create command
    create_parser = subparsers.add_parser('create', help='Create email rules')
    create_parser.add_argument('destination', help='Destination email address')
    create_parser.add_argument('count', type=int, help='Number of rules to create (1-200)')
    create_parser.add_argument('--length', type=int, default=10, help='Email prefix length (default: 10)')
    create_parser.add_argument('--delay', type=float, default=0.5, help='Delay between requests (default: 0.5)')
    
    # Update command
    update_parser = subparsers.add_parser('update', help='Update destination emails')
    update_parser.add_argument('destination', help='New destination email address')
    update_parser.add_argument('--filter', help='Filter rules by name')
    update_parser.add_argument('--delay', type=float, default=0.5, help='Delay between requests (default: 0.5)')
    
    # Delete command
    delete_parser = subparsers.add_parser('delete', help='Delete email rules')
    delete_parser.add_argument('--filter', help='Filter rules by name')
    delete_parser.add_argument('--delay', type=float, default=0.5, help='Delay between requests (default: 0.5)')
    
    # List command
    list_parser = subparsers.add_parser('list', help='List email rules')
    list_parser.add_argument('--filter', help='Filter rules by name')
    
    # Print command
    print_parser = subparsers.add_parser('print', help='Print email mappings from file')
    print_parser.add_argument('filename', help='JSON file to read')
    
    # Interactive command
    subparsers.add_parser('interactive', help='Run in interactive mode')
    
    # Legacy command
    legacy_parser = subparsers.add_parser('legacy', help='Run legacy scripts')
    legacy_parser.add_argument('script', choices=['app', 'change', 'delete', 'print'], 
                              help='Legacy script to run')
    legacy_parser.add_argument('args', nargs='*', help='Arguments for the legacy script')
    
    return parser


async def run_create_command(args):
    """Run the create command."""
    from main import EmailRoutingApp
    from config import API_TOKEN, ZONE_ID, DOMAIN
    
    if not API_TOKEN or not ZONE_ID or not DOMAIN:
        print("Error: Please configure API_TOKEN, ZONE_ID, and DOMAIN in config.py")
        return 1
    
    app = EmailRoutingApp(API_TOKEN, ZONE_ID, DOMAIN)
    
    try:
        await app.manager.create_email_rules(
            destination_email=args.destination,
            count=args.count,
            email_length=args.length,
            delay=args.delay
        )
        return 0
    except Exception as e:
        print(f"Error: {e}")
        return 1


async def run_update_command(args):
    """Run the update command."""
    from main import EmailRoutingApp
    from config import API_TOKEN, ZONE_ID, DOMAIN
    
    if not API_TOKEN or not ZONE_ID or not DOMAIN:
        print("Error: Please configure API_TOKEN, ZONE_ID, and DOMAIN in config.py")
        return 1
    
    app = EmailRoutingApp(API_TOKEN, ZONE_ID, DOMAIN)
    
    try:
        await app.manager.update_destinations(
            new_destination=args.destination,
            filter_text=args.filter,
            delay=args.delay
        )
        return 0
    except Exception as e:
        print(f"Error: {e}")
        return 1


async def run_delete_command(args):
    """Run the delete command."""
    from main import EmailRoutingApp
    from config import API_TOKEN, ZONE_ID, DOMAIN
    
    if not API_TOKEN or not ZONE_ID or not DOMAIN:
        print("Error: Please configure API_TOKEN, ZONE_ID, and DOMAIN in config.py")
        return 1
    
    app = EmailRoutingApp(API_TOKEN, ZONE_ID, DOMAIN)
    
    try:
        await app.manager.delete_rules(
            filter_text=args.filter,
            delay=args.delay
        )
        return 0
    except Exception as e:
        print(f"Error: {e}")
        return 1


async def run_list_command(args):
    """Run the list command."""
    from main import EmailRoutingApp
    from config import API_TOKEN, ZONE_ID, DOMAIN
    
    if not API_TOKEN or not ZONE_ID or not DOMAIN:
        print("Error: Please configure API_TOKEN, ZONE_ID, and DOMAIN in config.py")
        return 1
    
    app = EmailRoutingApp(API_TOKEN, ZONE_ID, DOMAIN)
    
    try:
        await app.list_rules_interactive()
        return 0
    except Exception as e:
        print(f"Error: {e}")
        return 1


async def run_print_command(args):
    """Run the print command."""
    from main import EmailRoutingApp
    from config import API_TOKEN, ZONE_ID, DOMAIN
    
    app = EmailRoutingApp(API_TOKEN, ZONE_ID, DOMAIN)
    
    try:
        await app.print_file_mappings(args.filename)
        return 0
    except Exception as e:
        print(f"Error: {e}")
        return 1


async def run_interactive_command():
    """Run the interactive command."""
    from main import main
    await main()
    return 0


def run_legacy_command(args):
    """Run legacy scripts for backward compatibility."""
    script_map = {
        'app': 'app.py',
        'change': 'change_destination.py',
        'delete': 'delete_emails.py',
        'print': 'print_emails.py'
    }
    
    script_file = script_map.get(args.script)
    if not script_file or not Path(script_file).exists():
        print(f"Error: Legacy script {script_file} not found")
        return 1
    
    print(f"Running legacy script: {script_file}")
    print("Note: Consider using the new OOP interface instead")
    
    # Import and run the legacy script
    import subprocess
    import sys
    
    cmd = [sys.executable, script_file] + args.args
    result = subprocess.run(cmd)
    return result.returncode


async def main():
    """Main CLI entry point."""
    parser = setup_parser()
    
    if len(sys.argv) == 1:
        # No arguments provided, show help
        parser.print_help()
        return 0
    
    args = parser.parse_args()
    
    if not args.command:
        parser.print_help()
        return 0
    
    try:
        if args.command == 'create':
            return await run_create_command(args)
        elif args.command == 'update':
            return await run_update_command(args)
        elif args.command == 'delete':
            return await run_delete_command(args)
        elif args.command == 'list':
            return await run_list_command(args)
        elif args.command == 'print':
            return await run_print_command(args)
        elif args.command == 'interactive':
            return await run_interactive_command()
        elif args.command == 'legacy':
            return run_legacy_command(args)
        else:
            print(f"Unknown command: {args.command}")
            return 1
            
    except KeyboardInterrupt:
        print("\nOperation cancelled by user")
        return 1
    except Exception as e:
        print(f"Unexpected error: {e}")
        return 1


if __name__ == "__main__":
    exit_code = asyncio.run(main())
    sys.exit(exit_code)