from .aws_agents.ec2_agent import EC2Agent
from .aws_agents.s3_agent import S3Agent
from .aws_agents.iam_agent import IAMAgent
from .aws_agents.vpc_agent import VPCAgent
from .aws_agents.rds_agent import RDSAgent
from .aws_agents.cloudwatch_agent import CloudWatchAgent
from .aws_agents.cloudtrail_agent import CloudTrailAgent
from .aws_agents.cost_management_agent import CostManagementAgent
from .aws_agents.secrets_manager_agent import SecretsManagerAgent
from .aws_agents.acm_agent import ACMAgent
from .aws_agents.route53_agent import Route53Agent
from .aws_agents.elb_agent import ELBAgent
from .aws_agents.lambda_agent import LambdaAgent
from .aws_agents.autoscaling_agent import AutoscalingAgent
from .aws_agents.opensearch_agent import OpenSearchAgent
from .aws_agents.eks_agent import EKSAgent
from .aws_agents.ebs_agent import EBSAgent
from .aws_agents.elasticbeanstalk_agent import ElasticBeanstalkAgent
from .aws_agents.efs_agent import EFSAgent
from .aws_agents.fargate_agent import FargateAgent
from .aws_agents.dms_agent import DMSAgent
from .aws_agents.apigateway_agent import APIGatewayAgent
from .aws_agents.cloudfront_agent import CloudFrontAgent
from .aws_agents.sagemaker_agent import SageMakerAgent
from .aws_agents.rekognition_agent import RekognitionAgent
from .aws_agents.comprehend_agent import ComprehendAgent
from .aws_agents.polly_agent import PollyAgent
from .aws_agents.kinesis_agent import KinesisAgent
from .aws_agents.redshift_agent import RedshiftAgent
from .aws_agents.athena_agent import AthenaAgent
from .aws_agents.waf_agent import WAFAgent
from .aws_agents.guardduty_agent import GuardDutyAgent
from .aws_agents.config_agent import ConfigAgent
from .aws_agents.sns_agent import SNSAgent
from .aws_agents.sqs_agent import SQSAgent
import shlex

class AgentManager:
    """
    The central orchestrator for all AWS agents.
    """

    def __init__(self):
        """
        Initializes the AgentManager and registers the available agents.
        """
        self.agents = {
            'ec2': EC2Agent(),
            's3': S3Agent(),
            'iam': IAMAgent(),
            'vpc': VPCAgent(),
            'rds': RDSAgent(),
            'cloudwatch': CloudWatchAgent(),
            'cloudtrail': CloudTrailAgent(),
            'cost': CostManagementAgent(),
            'secretsmanager': SecretsManagerAgent(),
            'acm': ACMAgent(),
            'route53': Route53Agent(),
            'elb': ELBAgent(),
            'lambda': LambdaAgent(),
            'autoscaling': AutoscalingAgent(),
            'opensearch': OpenSearchAgent(),
            'eks': EKSAgent(),
            'ebs': EBSAgent(),
            'elasticbeanstalk': ElasticBeanstalkAgent(),
            'efs': EFSAgent(),
            'fargate': FargateAgent(),
            'dms': DMSAgent(),
            'apigateway': APIGatewayAgent(),
            'cloudfront': CloudFrontAgent(),
            'sagemaker': SageMakerAgent(),
            'rekognition': RekognitionAgent(),
            'comprehend': ComprehendAgent(),
            'polly': PollyAgent(),
            'kinesis': KinesisAgent(),
            'redshift': RedshiftAgent(),
            'athena': AthenaAgent(),
            'waf': WAFAgent(),
            'guardduty': GuardDutyAgent(),
            'config': ConfigAgent(),
            'sns': SNSAgent(),
            'sqs': SQSAgent(),
        }
        print("AgentManager initialized with the following agents: ec2, s3, iam, vpc, rds, cloudwatch, cloudtrail, cost, secretsmanager, acm, route53, elb, lambda, autoscaling, opensearch, eks, ebs, elasticbeanstalk, efs, fargate, dms, apigateway, cloudfront, sagemaker, rekognition, comprehend, polly, kinesis, redshift, athena, waf, guardduty, config, sns, sqs")

    def get_available_services(self):
        """
        Returns a list of all services managed by this AgentManager.
        """
        return list(self.agents.keys())

    def get_service_commands(self, service_name: str):
        """
        Returns a list of commands supported by a specific service agent.
        """
        parser_method = getattr(self, f'_parse_{service_name}_command', None)
        if parser_method:
            # Call the parser with dummy parts to get the command list
            # The parser now returns (command, args, commands_list)
            _, _, commands_list = parser_method([])
            if commands_list:
                return [cmd['usage'] for cmd in commands_list]
        return []

    def _get_service(self, parts):
        if 'ec2' in parts or 'instance' in parts:
            return 'ec2'
        if 's3' in parts or 'bucket' in parts:
            return 's3'
        if 'iam' in parts or 'user' in parts or 'role' in parts:
            return 'iam'
        if 'vpc' in parts or 'subnet' in parts:
            return 'vpc'
        if 'rds' in parts or 'database' in parts or 'db' in parts:
            return 'rds'
        if 'cloudwatch' in parts or 'alarm' in parts or 'dashboard' in parts:
            return 'cloudwatch'
        if 'cloudtrail' in parts or 'trail' in parts:
            return 'cloudtrail'
        if 'cost' in parts or 'budget' in parts or 'budgets' in parts:
            return 'cost'
        if 'secretsmanager' in parts or 'secret' in parts:
            return 'secretsmanager'
        if 'acm' in parts or 'certificate' in parts:
            return 'acm'
        if 'route53' in parts or 'zone' in parts or 'record' in parts:
            return 'route53'
        if 'elb' in parts or 'loadbalancer' in parts or 'loadbalancers' in parts:
            return 'elb'
        if 'lambda' in parts or 'function' in parts or 'functions' in parts:
            return 'lambda'
        if 'autoscaling' in parts or 'asg' in parts:
            return 'autoscaling'
        if 'opensearch' in parts or 'domain' in parts:
            return 'opensearch'
        if 'eks' in parts or 'cluster' in parts:
            return 'eks'
        if 'ebs' in parts or 'volume' in parts:
            return 'ebs'
        if 'elasticbeanstalk' in parts or 'beanstalk' in parts or 'app' in parts:
            return 'elasticbeanstalk'
        if 'efs' in parts or 'file-system' in parts:
            return 'efs'
        if 'fargate' in parts or 'ecs' in parts or 'container' in parts:
            return 'fargate'
        if 'dms' in parts or 'migration' in parts:
            return 'dms'
        if 'apigateway' in parts or 'api' in parts:
            return 'apigateway'
        if 'cloudfront' in parts or 'distribution' in parts:
            return 'cloudfront'
        if 'sagemaker' in parts or 'notebook' in parts or 'ml' in parts:
            return 'sagemaker'
        if 'rekognition' in parts or 'image' in parts or 'video' in parts:
            return 'rekognition'
        if 'comprehend' in parts or 'nlp' in parts or 'sentiment' in parts:
            return 'comprehend'
        if 'polly' in parts or 'speech' in parts or 'text-to-speech' in parts:
            return 'polly'
        if 'kinesis' in parts or 'stream' in parts:
            return 'kinesis'
        if 'redshift' in parts or 'datawarehouse' in parts or 'cluster' in parts:
            return 'redshift'
        if 'athena' in parts or 'query' in parts:
            return 'athena'
        if 'waf' in parts or 'web-acl' in parts:
            return 'waf'
        if 'guardduty' in parts or 'detector' in parts:
            return 'guardduty'
        if 'config' in parts or 'configuration' in parts:
            return 'config'
        if 'sns' in parts or 'topic' in parts or 'notification' in parts:
            return 'sns'
        if 'sqs' in parts or 'queue' in parts:
            return 'sqs'
        return None

    def _parse_ec2_command(self, parts):
        commands = [
            {"command": "list_instances", "usage": "ec2 list instances in <region>"},
            {"command": "start_instances", "usage": "ec2 start <instance-id-1> [instance-id-2 ...] in <region>"},
            {"command": "stop_instances", "usage": "ec2 stop <instance-id-1> [instance-id-2 ...] in <region>"},
            {"command": "terminate_instances", "usage": "ec2 terminate <instance-id-1> [instance-id-2 ...] in <region>"},
            {"command": "create_instance", "usage": "ec2 create instance named <name> with <os> [type <instance-type>] in <region>"},
            {"command": "list_idle_instances", "usage": "ec2 list idle-instances in <region> [threshold <percent>] [period-days <days>]"},
        ]

        command, args = None, {}
        try:
            # Extract region first, as it's common to many EC2 commands
            if 'in' in parts:
                args['region'] = parts[parts.index('in') + 1]
            else:
                return None, {"error": "Region not specified. Use 'in <region>'."}

            if 'list' in parts and 'instances' in parts:
                command = 'list_instances'
            elif 'start' in parts:
                command = 'start_instances'
                args['instance_ids'] = [p for p in parts if p.startswith('i-')]
                if not args['instance_ids']:
                    return None, {"error": "No instance IDs found for 'start'."}
            elif 'stop' in parts:
                command = 'stop_instances'
                args['instance_ids'] = [p for p in parts if p.startswith('i-')]
                if not args['instance_ids']:
                    return None, {"error": "No instance IDs found for 'stop'."}
            elif 'terminate' in parts:
                command = 'terminate_instances'
                args['instance_ids'] = [p for p in parts if p.startswith('i-')]
                if not args['instance_ids']:
                    return None, {"error": "No instance IDs found for 'terminate'."}
            elif 'create' in parts and 'instance' in parts:
                command = 'create_instance'
                args['name'] = parts[parts.index('named') + 1]
                args['os'] = parts[parts.index('with') + 1]
                if 'type' in parts:
                    args['instance_type'] = parts[parts.index('type') + 1]
            elif 'list' in parts and 'idle-instances' in parts:
                command = 'list_idle_instances'
                if 'threshold' in parts:
                    args['threshold'] = float(parts[parts.index('threshold') + 1])
                if 'period-days' in parts:
                    args['period_days'] = int(parts[parts.index('period-days') + 1])

        except (ValueError, IndexError) as e:
            return None, {"error": f"Invalid EC2 command usage: {e}. Refer to help for correct syntax."}
        
        return command, args, commands

    def _parse_s3_command(self, parts):
        commands = [
            {"command": "list_buckets", "usage": "s3 list buckets"},
            {"command": "create_bucket", "usage": "s3 create bucket <name> in <region>"},
            {"command": "smart_create_bucket", "usage": "s3 smart-create bucket <name> in <region> [logging-bucket <logging-bucket-name>]"},
            {"command": "delete_bucket", "usage": "s3 delete bucket <name>"},
            {"command": "analyze_bucket_cost_optimization", "usage": "s3 analyze bucket-cost-optimization <bucket-name>"},
        ]

        command, args = None, {}
        if 'list' in parts:
            command = 'list_buckets'
        elif 'create' in parts and 'bucket' in parts and 'smart-create' not in parts:
            command = 'create_bucket'
            try:
                args['bucket_name'] = parts[parts.index('bucket') + 1]
                args['region'] = parts[parts.index('in') + 1]
            except (ValueError, IndexError):
                return None, {"error": "Usage: s3 create bucket <name> in <region>"}, commands
        elif 'smart-create' in parts and 'bucket' in parts:
            command = 'smart_create_bucket'
            try:
                args['bucket_name'] = parts[parts.index('bucket') + 1]
                args['region'] = parts[parts.index('in') + 1]
                if 'logging-bucket' in parts:
                    args['enable_logging'] = True
                    args['logging_bucket_name'] = parts[parts.index('logging-bucket') + 1]
            except (ValueError, IndexError):
                return None, {"error": "Usage: s3 smart-create bucket <name> in <region> [logging-bucket <logging-bucket-name>]"}, commands
        elif 'delete' in parts and 'bucket' in parts:
            command = 'delete_bucket'
            try:
                args['bucket_name'] = parts[parts.index('bucket') + 1]
            except (ValueError, IndexError):
                return None, {"error": "Usage: s3 delete bucket <name>"}, commands
        elif 'analyze' in parts and 'bucket-cost-optimization' in parts:
            command = 'analyze_bucket_cost_optimization'
            try:
                args['bucket_name'] = parts[parts.index('bucket') + 1]
            except (ValueError, IndexError):
                return None, {"error": "Usage: s3 analyze bucket-cost-optimization <bucket-name>"}, commands
        return command, args, commands

    def _parse_iam_command(self, parts):
        commands = [
            {"command": "list_users", "usage": "iam list users"},
            {"command": "list_roles", "usage": "iam list roles"},
            {"command": "list_policies", "usage": "iam list policies"},
            {"command": "create_user", "usage": "iam create user <name>"},
            {"command": "delete_user", "usage": "iam delete user <name>"},
            {"command": "create_eks_cluster_role", "usage": "iam create eks-cluster-role role <role-name>"},
            {"command": "create_eks_nodegroup_role", "usage": "iam create eks-nodegroup-role role <role-name>"},
            {"command": "create_lambda_execution_role", "usage": "iam create lambda-execution-role role <role-name>"},
        ]

        command, args = None, {}
        if 'list' in parts and 'users' in parts:
            command = 'list_users'
        elif 'list' in parts and 'roles' in parts:
            command = 'list_roles'
        elif 'list' in parts and 'policies' in parts:
            command = 'list_policies'
        elif 'create' in parts and 'user' in parts:
            command = 'create_user'
            try:
                args['user_name'] = parts[parts.index('user') + 1]
            except (ValueError, IndexError):
                return None, {"error": "Usage: iam create user <name>"}, commands
        elif 'delete' in parts and 'user' in parts:
            command = 'delete_user'
            try:
                args['user_name'] = parts[parts.index('user') + 1]
            except (ValueError, IndexError):
                return None, {"error": "Usage: iam delete user <name>"}, commands
        elif 'create' in parts and 'eks-cluster-role' in parts:
            command = 'create_eks_cluster_role'
            try:
                args['role_name'] = parts[parts.index('role') + 1]
            except (ValueError, IndexError):
                return None, {"error": "Usage: iam create eks-cluster-role <role-name>"}, commands
        elif 'create' in parts and 'eks-nodegroup-role' in parts:
            command = 'create_eks_nodegroup_role'
            try:
                args['role_name'] = parts[parts.index('role') + 1]
            except (ValueError, IndexError):
                return None, {"error": "Usage: iam create eks-nodegroup-role <role-name>"}, commands
        elif 'create' in parts and 'lambda-execution-role' in parts:
            command = 'create_lambda_execution_role'
            try:
                args['role_name'] = parts[parts.index('role') + 1]
            except (ValueError, IndexError):
                return None, {"error": "Usage: iam create-lambda-execution-role role <role-name>"}, commands
        return command, args, commands

    def _parse_vpc_command(self, parts):
        commands = [
            {"command": "create_vpc", "usage": "vpc create vpc with cidr <cidr> in <region>"},
            {"command": "create_subnet", "usage": "vpc create subnet in vpc <vpc-id> with cidr <cidr> in <region>"},
            {"command": "smart_create_vpc", "usage": "vpc smart-create named <name> in <region> [cidr <cidr-block>] [public-subnets <count>] [private-subnets <count>]"},
        ]

        command, args = None, {}
        try:
            if 'create' in parts and 'vpc' in parts and 'smart-create' not in parts:
                command = 'create_vpc'
                args['cidr_block'] = parts[parts.index('cidr') + 1]
                args['region'] = parts[parts.index('in') + 1]
            elif 'create' in parts and 'subnet' in parts:
                command = 'create_subnet'
                args['vpc_id'] = parts[parts.index('vpc') + 1]
                args['cidr_block'] = parts[parts.index('cidr') + 1]
                args['region'] = parts[parts.index('in') + 1]
            elif 'smart-create' in parts:
                command = 'smart_create_vpc'
                args['name'] = parts[parts.index('named') + 1]
                args['region'] = parts[parts.index('in') + 1]
                if 'cidr' in parts:
                    args['cidr_block'] = parts[parts.index('cidr') + 1]
                if 'public-subnets' in parts:
                    args['num_public_subnets'] = int(parts[parts.index('public-subnets') + 1])
                if 'private-subnets' in parts:
                    args['num_private_subnets'] = int(parts[parts.index('private-subnets') + 1])
        except (ValueError, IndexError) as e:
            return None, {"error": f"Invalid VPC command usage: {e}. Refer to help for correct syntax."}
        return command, args, commands

    def _parse_rds_command(self, parts):
        commands = [
            {"command": "create_db_instance", "usage": "rds create db instance <id> engine <engine> class <class> storage <gb> username <user> password <pass> in <region> [security-groups <sg-id1> ...] [subnet-group <name>]"},
            {"command": "smart_create_db_instance", "usage": "rds smart-create db instance <id> engine <engine> username <user> password <pass> in <region> [class <class>] [storage <gb>] [vpc <vpc-id>]"},
            {"command": "troubleshoot_db_instance", "usage": "rds troubleshoot db instance <id> in <region>"},
        ]

        command, args = None, {}
        try:
            if 'create' in parts and ('db' in parts or 'database' in parts or 'instance' in parts) and 'smart-create' not in parts:
                command = 'create_db_instance'
                args['db_instance_identifier'] = parts[parts.index('instance') + 1]
                args['engine'] = parts[parts.index('engine') + 1]
                args['db_instance_class'] = parts[parts.index('class') + 1]
                args['allocated_storage'] = int(parts[parts.index('storage') + 1])
                args['master_username'] = parts[parts.index('username') + 1]
                args['master_password'] = parts[parts.index('password') + 1]
                args['region'] = parts[parts.index('in') + 1]
                if 'security-groups' in parts:
                    sg_index = parts.index('security-groups') + 1
                    sg_ids = []
                    while sg_index < len(parts) and not parts[sg_index].startswith('--') and not parts[sg_index] == 'in':
                        sg_ids.append(parts[sg_index])
                        sg_index += 1
                    args['vpc_security_group_ids'] = sg_ids
                if 'subnet-group' in parts:
                    args['db_subnet_group_name'] = parts[parts.index('subnet-group') + 1]
            elif 'smart-create' in parts and ('db' in parts or 'database' in parts or 'instance' in parts):
                command = 'smart_create_db_instance'
                args['db_instance_identifier'] = parts[parts.index('instance') + 1]
                args['engine'] = parts[parts.index('engine') + 1]
                args['master_username'] = parts[parts.index('username') + 1]
                args['master_password'] = parts[parts.index('password') + 1]
                args['region'] = parts[parts.index('in') + 1]
                if 'class' in parts:
                    args['db_instance_class'] = parts[parts.index('class') + 1]
                if 'storage' in parts:
                    args['allocated_storage'] = int(parts[parts.index('storage') + 1])
                if 'vpc' in parts:
                    args['vpc_id'] = parts[parts.index('vpc') + 1]
            elif 'troubleshoot' in parts and ('db' in parts or 'database' in parts or 'instance' in parts):
                command = 'troubleshoot_db_instance'
                args['db_instance_identifier'] = parts[parts.index('instance') + 1]
                args['region'] = parts[parts.index('in') + 1]
        except (ValueError, IndexError) as e:
            return None, {"error": f"Invalid RDS command usage: {e}. Refer to help for correct syntax."}
        return command, args, commands

    def _parse_cloudwatch_command(self, parts):
        commands = [
            {"command": "list_alarms", "usage": "cloudwatch list alarms in <region>"},
            {"command": "list_dashboards", "usage": "cloudwatch list dashboards in <region>"},
            {"command": "smart_create_cpu_alarm", "usage": "cloudwatch smart-create cpu-alarm for <instance-id> in <region> [threshold <value>] [sns-topic <sns-topic-arn>]"},
        ]

        command, args = None, {}
        try:
            if 'list' in parts and 'alarms' in parts:
                command = 'list_alarms'
                args['region'] = parts[parts.index('in') + 1]
            elif 'list' in parts and 'dashboards' in parts:
                command = 'list_dashboards'
                args['region'] = parts[parts.index('in') + 1]
            elif 'smart-create' in parts and 'cpu-alarm' in parts:
                command = 'smart_create_cpu_alarm'
                args['instance_id'] = parts[parts.index('for') + 1]
                args['region'] = parts[parts.index('in') + 1]
                if 'threshold' in parts:
                    args['threshold'] = float(parts[parts.index('threshold') + 1])
                if 'sns-topic' in parts:
                    args['sns_topic_arn'] = parts[parts.index('sns-topic') + 1]
        except (ValueError, IndexError) as e:
            return None, {"error": f"Invalid CloudWatch command usage: {e}. Refer to help for correct syntax."}
        return command, args, commands

    def _parse_cloudtrail_command(self, parts):
        commands = [
            {"command": "smart_create_trail", "usage": "cloudtrail smart-create trail <name> in <region> [s3-bucket <bucket-name>]"},
            {"command": "troubleshoot_trail", "usage": "cloudtrail troubleshoot trail <name> in <region>"},
        ]

        command, args = None, {}
        try:
            if 'smart-create' in parts and 'trail' in parts:
                command = 'smart_create_trail'
                args['name'] = parts[parts.index('trail') + 1]
                args['region'] = parts[parts.index('in') + 1]
                if 's3-bucket' in parts:
                    args['s3_bucket_name'] = parts[parts.index('s3-bucket') + 1]
            elif 'troubleshoot' in parts and 'trail' in parts:
                command = 'troubleshoot_trail'
                args['name'] = parts[parts.index('trail') + 1]
                args['region'] = parts[parts.index('in') + 1]
        except (ValueError, IndexError) as e:
            return None, {"error": f"Invalid CloudTrail command usage: {e}. Refer to help for correct syntax."}
        return command, args, commands

    def _parse_cost_management_command(self, parts):
        commands = [
            {"command": "get_cost_and_usage", "usage": "cost get cost-and-usage for <days> days in <region>"},
            {"command": "get_recommendations", "usage": "cost get recommendations in <region>"},
        ]

        command, args = None, {}
        try:
            if 'get' in parts and 'cost-and-usage' in parts:
                command = 'get_cost_and_usage'
                args['days'] = int(parts[parts.index('for') + 1])
                args['region'] = parts[parts.index('in') + 1]
            elif 'get' in parts and 'recommendations' in parts:
                command = 'get_recommendations'
                args['region'] = parts[parts.index('in') + 1]
        except (ValueError, IndexError) as e:
            return None, {"error": f"Invalid Cost Management command usage: {e}. Refer to help for correct syntax."}
        return command, args, commands

    def _parse_secrets_manager_command(self, parts):
        commands = [
            {"command": "smart_create_secret", "usage": "secretsmanager smart-create secret <name> value \"<value>\" in <region>"},
            {"command": "get_secret_value", "usage": "secretsmanager get secret value <name> in <region>"},
        ]

        command, args = None, {}
        try:
            if 'smart-create' in parts and 'secret' in parts:
                command = 'smart_create_secret'
                args['name'] = parts[parts.index('secret') + 1]
                args['secret_string'] = parts[parts.index('value') + 1]
                args['region'] = parts[parts.index('in') + 1]
            elif 'get' in parts and 'secret' in parts and 'value' in parts:
                command = 'get_secret_value'
                args['name'] = parts[parts.index('value') + 1]
                args['region'] = parts[parts.index('in') + 1]
        except (ValueError, IndexError) as e:
            return None, {"error": f"Invalid Secrets Manager command usage: {e}. Refer to help for correct syntax."}
        return command, args, commands

    def _parse_acm_command(self, parts):
        commands = [
            {"command": "smart_request_certificate", "usage": "acm smart-request certificate for domain <domain-name> in <region>"},
        ]

        command, args = None, {}
        try:
            if 'smart-request' in parts and 'certificate' in parts:
                command = 'smart_request_certificate'
                args['domain_name'] = parts[parts.index('domain') + 1]
                args['region'] = parts[parts.index('in') + 1]
        except (ValueError, IndexError) as e:
            return None, {"error": f"Invalid ACM command usage: {e}. Refer to help for correct syntax."}
        return command, args, commands

    def _parse_route53_command(self, parts):
        commands = [
            {"command": "smart_create_hosted_zone", "usage": "route53 smart-create hosted-zone <domain-name>"},
            {"command": "smart_create_a_record", "usage": "route53 smart-create a-record <record-name> value <ip-address> in hosted-zone <zone-name>"},
        ]

        command, args = None, {}
        try:
            if 'smart-create' in parts and 'hosted-zone' in parts:
                command = 'smart_create_hosted_zone'
                args['domain_name'] = parts[parts.index('hosted-zone') + 1]
            elif 'smart-create' in parts and 'a-record' in parts:
                command = 'smart_create_a_record'
                args['record_name'] = parts[parts.index('a-record') + 1]
                args['ip_address'] = parts[parts.index('value') + 1]
                args['hosted_zone_name'] = parts[parts.index('hosted-zone') + 1]
        except (ValueError, IndexError) as e:
            return None, {"error": f"Invalid Route53 command usage: {e}. Refer to help for correct syntax."}
        return command, args, commands

    def _parse_elb_command(self, parts):
        commands = [
            {"command": "list_load_balancers", "usage": "elb list loadbalancers in <region>"},
            {"command": "smart_create_alb", "usage": "elb smart-create alb named <name> in <region> [vpc <vpc-id>] [subnets <subnet-id-1> ...] [security-groups <sg-id-1> ...]"},
        ]

        command, args = None, {}
        try:
            if 'list' in parts and ('loadbalancers' in parts or 'loadbalancer' in parts):
                command = 'list_load_balancers'
                args['region'] = parts[parts.index('in') + 1]
            elif 'smart-create' in parts and ('loadbalancer' in parts or 'alb' in parts):
                command = 'smart_create_alb'
                args['name'] = parts[parts.index('named') + 1]
                args['region'] = parts[parts.index('in') + 1]
                if 'vpc' in parts:
                    args['vpc_id'] = parts[parts.index('vpc') + 1]
                if 'subnets' in parts:
                    subnet_index = parts.index('subnets') + 1
                    subnet_ids = []
                    while subnet_index < len(parts) and parts[subnet_index].startswith('subnet-'):
                        subnet_ids.append(parts[subnet_index])
                        subnet_index += 1
                    args['subnet_ids'] = subnet_ids
                if 'security-groups' in parts:
                    sg_index = parts.index('security-groups') + 1
                    security_group_ids = []
                    while sg_index < len(parts) and parts[sg_index].startswith('sg-'):
                        security_group_ids.append(parts[sg_index])
                        sg_index += 1
                    args['security_group_ids'] = security_group_ids
        except (ValueError, IndexError) as e:
            return None, {"error": f"Invalid ELB command usage: {e}. Refer to help for correct syntax."}
        return command, args, commands

    def _parse_lambda_command(self, parts):
        commands = [
            {"command": "list_functions", "usage": "lambda list functions in <region>"},
            {"command": "smart_create_function", "usage": "lambda smart-create function <name> in <region> [runtime <runtime>] [handler <handler>] [memory <mb>] [timeout <seconds>]"},
        ]

        command, args = None, {}
        try:
            if 'list' in parts and 'functions' in parts:
                command = 'list_functions'
                args['region'] = parts[parts.index('in') + 1]
            elif 'smart-create' in parts and 'function' in parts:
                command = 'smart_create_function'
                args['function_name'] = parts[parts.index('function') + 1]
                args['region'] = parts[parts.index('in') + 1]
                if 'runtime' in parts:
                    args['runtime'] = parts[parts.index('runtime') + 1]
                if 'handler' in parts:
                    args['handler'] = parts[parts.index('handler') + 1]
                if 'memory' in parts:
                    args['memory'] = int(parts[parts.index('memory') + 1])
                if 'timeout' in parts:
                    args['timeout'] = int(parts[parts.index('timeout') + 1])
        except (ValueError, IndexError) as e:
            return None, {"error": f"Invalid Lambda command usage: {e}. Refer to help for correct syntax."}
        return command, args, commands

    def _parse_autoscaling_command(self, parts):
        commands = [
            {"command": "smart_create_asg", "usage": "autoscaling smart-create asg named <name> launch-template <template-id> min <min-size> max <max-size> in <region> [subnets <subnet-id-1> ...]"},
        ]

        command, args = None, {}
        try:
            if 'smart-create' in parts and 'asg' in parts:
                command = 'smart_create_asg'
                args['name'] = parts[parts.index('named') + 1]
                args['launch_template_id'] = parts[parts.index('launch-template') + 1]
                args['min_size'] = int(parts[parts.index('min') + 1])
                args['max_size'] = int(parts[parts.index('max') + 1])
                args['region'] = parts[parts.index('in') + 1]
                if 'subnets' in parts:
                    subnet_index = parts.index('subnets') + 1
                    subnet_ids = []
                    while subnet_index < len(parts) and parts[subnet_index].startswith('subnet-'):
                        subnet_ids.append(parts[subnet_index])
                        subnet_index += 1
                    args['subnet_ids'] = subnet_ids
        except (ValueError, IndexError) as e:
            return None, {"error": f"Invalid Autoscaling command usage: {e}. Refer to help for correct syntax."}
        return command, args, commands

    def _parse_opensearch_command(self, parts):
        commands = [
            {"command": "create_domain", "usage": "opensearch create domain <name> version <version> type <instance-type> count <count> size <gb> in <region>"},
            {"command": "troubleshoot_domain", "usage": "opensearch troubleshoot domain <name> in <region>"},
        ]

        command, args = None, {}
        try:
            if 'create' in parts and 'domain' in parts:
                command = 'create_domain'
                args['domain_name'] = parts[parts.index('domain') + 1]
                args['engine_version'] = parts[parts.index('version') + 1]
                args['instance_type'] = parts[parts.index('type') + 1]
                args['instance_count'] = int(parts[parts.index('count') + 1])
                args['volume_size'] = int(parts[parts.index('size') + 1])
                args['region'] = parts[parts.index('in') + 1]
            elif 'troubleshoot' in parts and 'domain' in parts:
                command = 'troubleshoot_domain'
                args['domain_name'] = parts[parts.index('domain') + 1]
                args['region'] = parts[parts.index('in') + 1]
        except (ValueError, IndexError) as e:
            return None, {"error": f"Invalid OpenSearch command usage: {e}. Refer to help for correct syntax."}
        return command, args, commands

    def _parse_eks_command(self, parts):
        commands = [
            {"command": "create_cluster", "usage": "eks create cluster <name> role <role-arn> vpc <vpc-id> subnets <subnet-id-1> <subnet-id-2> ... in <region>"},
            {"command": "create_nodegroup", "usage": "eks create nodegroup for cluster <cluster-name> nodegroup <nodegroup-name> role <node-role-arn> instance-types <type1> <type2> ... subnets <subnet-id-1> ... in <region>"},
            {"command": "troubleshoot_cluster", "usage": "eks troubleshoot cluster <name> in <region>"},
        ]

        command, args = None, {}
        try:
            if 'create' in parts and 'cluster' in parts:
                command = 'create_cluster'
                args['name'] = parts[parts.index('cluster') + 1]
                args['role_arn'] = parts[parts.index('role') + 1]
                args['vpc_id'] = parts[parts.index('vpc') + 1]
                args['region'] = parts[parts.index('in') + 1]
                subnet_index = parts.index('subnets') + 1
                subnet_ids = []
                while subnet_index < len(parts) and parts[subnet_index].startswith('subnet-'):
                    subnet_ids.append(parts[subnet_index])
                    subnet_index += 1
                args['subnet_ids'] = subnet_ids
            elif 'create' in parts and 'nodegroup' in parts:
                command = 'create_nodegroup'
                args['cluster_name'] = parts[parts.index('cluster') + 1]
                args['nodegroup_name'] = parts[parts.index('nodegroup') + 1]
                args['node_role_arn'] = parts[parts.index('role') + 1]
                args['region'] = parts[parts.index('in') + 1]
                instance_type_index = parts.index('instance-types') + 1
                instance_types = []
                while instance_type_index < len(parts) and not parts[instance_type_index].startswith('subnet-') and not parts[instance_type_index] == 'in':
                    instance_types.append(parts[instance_type_index])
                    instance_type_index += 1
                args['instance_types'] = instance_types
                subnet_index = parts.index('subnets') + 1
                subnet_ids = []
                while subnet_index < len(parts) and parts[subnet_index].startswith('subnet-'):
                    subnet_ids.append(parts[subnet_index])
                    subnet_index += 1
                args['subnet_ids'] = subnet_ids
            elif 'troubleshoot' in parts and 'cluster' in parts:
                command = 'troubleshoot_cluster'
                args['name'] = parts[parts.index('cluster') + 1]
                args['region'] = parts[parts.index('in') + 1]
        except (ValueError, IndexError) as e:
            return None, {"error": f"Invalid EKS command usage: {e}. Refer to help for correct syntax."}
        return command, args, commands

    def _parse_ebs_command(self, parts):
        commands = [
            {"command": "smart_create_and_attach_volume", "usage": "ebs smart-create volume <name> to <instance-id> in <region> [size <gb>] [type <volume-type>]"},
        ]

        command, args = None, {}
        try:
            if 'smart-create' in parts and 'volume' in parts:
                command = 'smart_create_and_attach_volume'
                args['volume_name'] = parts[parts.index('volume') + 1]
                args['instance_id'] = parts[parts.index('to') + 1]
                args['region'] = parts[parts.index('in') + 1]
                if 'size' in parts:
                    args['size'] = int(parts[parts.index('size') + 1])
                if 'type' in parts:
                    args['volume_type'] = parts[parts.index('type') + 1]
        except (ValueError, IndexError) as e:
            return None, {"error": f"Invalid EBS command usage: {e}. Refer to help for correct syntax."}
        return command, args, commands

    def _parse_elasticbeanstalk_command(self, parts):
        commands = [
            {"command": "smart_create_web_app", "usage": "elasticbeanstalk smart-create web-app named <app-name> in <region> [environment <env-name>] [solution-stack <stack-name>] [instance-type <type>]"},
        ]

        command, args = None, {}
        try:
            if 'smart-create' in parts and ('web-app' in parts or 'app' in parts):
                command = 'smart_create_web_app'
                args['app_name'] = parts[parts.index('named') + 1]
                args['region'] = parts[parts.index('in') + 1]
                if 'environment' in parts:
                    args['environment_name'] = parts[parts.index('environment') + 1]
                if 'solution-stack' in parts:
                    args['solution_stack_name'] = parts[parts.index('solution-stack') + 1]
                if 'instance-type' in parts:
                    args['instance_type'] = parts[parts.index('instance-type') + 1]
        except (ValueError, IndexError) as e:
            return None, {"error": f"Invalid Elastic Beanstalk command usage: {e}. Refer to help for correct syntax."}
        return command, args, commands

    def _parse_efs_command(self, parts):
        commands = [
            {"command": "smart_create_file_system", "usage": "efs smart-create file-system <name> in <region> [subnet <subnet-id>] [vpc <vpc-id>] [performance-mode <mode>] [throughput-mode <mode>] [security-group <sg-id>]"},
        ]

        command, args = None, {}
        try:
            if 'smart-create' in parts and 'file-system' in parts:
                command = 'smart_create_file_system'
                args['name'] = parts[parts.index('file-system') + 1]
                args['region'] = parts[parts.index('in') + 1]
                if 'subnet' in parts:
                    args['subnet_id'] = parts[parts.index('subnet') + 1]
                if 'vpc' in parts:
                    args['vpc_id'] = parts[parts.index('vpc') + 1]
                if 'performance-mode' in parts:
                    args['performance_mode'] = parts[parts.index('performance-mode') + 1]
                if 'throughput-mode' in parts:
                    args['throughput_mode'] = parts[parts.index('throughput-mode') + 1]
                if 'security-group' in parts:
                    args['security_group_id'] = parts[parts.index('security-group') + 1]
        except (ValueError, IndexError) as e:
            return None, {"error": f"Invalid EFS command usage: {e}. Refer to help for correct syntax."}
        return command, args, commands

    def _parse_fargate_command(self, parts):
        commands = [
            {"command": "smart_deploy_container_app", "usage": "fargate smart-deploy container-app named <app-name> in <region> [vpc <vpc-id>] [subnets <subnet-id-1> ...] [image <image-name>] [port <port-number>] [cpu <cpu-units>] [memory <mb>]"},
        ]

        command, args = None, {}
        try:
            if 'smart-deploy' in parts and ('container-app' in parts or 'app' in parts):
                command = 'smart_deploy_container_app'
                args['app_name'] = parts[parts.index('named') + 1]
                args['region'] = parts[parts.index('in') + 1]
                if 'vpc' in parts:
                    args['vpc_id'] = parts[parts.index('vpc') + 1]
                if 'subnets' in parts:
                    subnet_index = parts.index('subnets') + 1
                    subnet_ids = []
                    while subnet_index < len(parts) and parts[subnet_index].startswith('subnet-'):
                        subnet_ids.append(parts[subnet_index])
                        subnet_index += 1
                    args['subnet_ids'] = subnet_ids
                if 'image' in parts:
                    args['container_image'] = parts[parts.index('image') + 1]
                if 'port' in parts:
                    args['container_port'] = int(parts[parts.index('port') + 1])
                if 'cpu' in parts:
                    args['cpu'] = int(parts[parts.index('cpu') + 1])
                if 'memory' in parts:
                    args['memory'] = int(parts[parts.index('memory') + 1])
        except (ValueError, IndexError) as e:
            return None, {"error": f"Invalid Fargate command usage: {e}. Refer to help for correct syntax."}
        return command, args, commands

    def _parse_dms_command(self, parts):
        commands = [
            {"command": "smart_create_replication_task", "usage": "dms smart-create replication-task <task-name> source <source-endpoint-id> target <target-endpoint-id> in <region> [replication-instance <rep-instance-id>] [source-engine <engine>] [target-engine <engine>] [instance-class <class>] [migration-type <type>]"},
        ]

        command, args = None, {}
        try:
            if 'smart-create' in parts and 'replication-task' in parts:
                command = 'smart_create_replication_task'
                args['task_name'] = parts[parts.index('task') + 1]
                args['source_endpoint_id'] = parts[parts.index('source') + 1]
                args['target_endpoint_id'] = parts[parts.index('target') + 1]
                args['region'] = parts[parts.index('in') + 1]
                if 'replication-instance' in parts:
                    args['replication_instance_id'] = parts[parts.index('replication-instance') + 1]
                if 'source-engine' in parts:
                    args['source_engine'] = parts[parts.index('source-engine') + 1]
                if 'target-engine' in parts:
                    args['target_engine'] = parts[parts.index('target-engine') + 1]
                if 'instance-class' in parts:
                    args['instance_class'] = parts[parts.index('instance-class') + 1]
                if 'migration-type' in parts:
                    args['migration_type'] = parts[parts.index('migration-type') + 1]
        except (ValueError, IndexError) as e:
            return None, {"error": f"Invalid DMS command usage: {e}. Refer to help for correct syntax."}
        return command, args, commands

    def _parse_apigateway_command(self, parts):
        commands = [
            {"command": "smart_create_rest_api", "usage": "apigateway smart-create rest-api <api-name> in <region> [stage <stage-name>] [path <resource-path>]"},
        ]

        command, args = None, {}
        try:
            if 'smart-create' in parts and 'rest-api' in parts:
                command = 'smart_create_rest_api'
                args['api_name'] = parts[parts.index('api') + 1]
                args['region'] = parts[parts.index('in') + 1]
                if 'stage' in parts:
                    args['stage_name'] = parts[parts.index('stage') + 1]
                if 'path' in parts:
                    args['path'] = parts[parts.index('path') + 1]
        except (ValueError, IndexError) as e:
            return None, {"error": f"Invalid API Gateway command usage: {e}. Refer to help for correct syntax."}
        return command, args, commands

    def _parse_cloudfront_command(self, parts):
        commands = [
            {"command": "smart_create_s3_distribution", "usage": "cloudfront smart-create s3-distribution for bucket <bucket-name> in <region> [default-root-object <object-name>]"},
        ]

        command, args = None, {}
        try:
            if 'smart-create' in parts and 's3-distribution' in parts:
                command = 'smart_create_s3_distribution'
                args['bucket_name'] = parts[parts.index('bucket') + 1]
                args['region'] = parts[parts.index('in') + 1]
                if 'default-root-object' in parts:
                    args['default_root_object'] = parts[parts.index('default-root-object') + 1]
        except (ValueError, IndexError) as e:
            return None, {"error": f"Invalid CloudFront command usage: {e}. Refer to help for correct syntax."}
        return command, args, commands

    def _parse_sagemaker_command(self, parts):
        commands = [
            {"command": "smart_create_notebook_instance", "usage": "sagemaker smart-create notebook-instance <name> role <role-arn> in <region> [instance-type <type>] [volume-size <gb>]"},
        ]

        command, args = None, {}
        try:
            if 'smart-create' in parts and 'notebook-instance' in parts:
                command = 'smart_create_notebook_instance'
                args['instance_name'] = parts[parts.index('instance') + 1]
                args['role_arn'] = parts[parts.index('role') + 1]
                args['region'] = parts[parts.index('in') + 1]
                if 'instance-type' in parts:
                    args['instance_type'] = parts[parts.index('instance-type') + 1]
                if 'volume-size' in parts:
                    args['volume_size_in_gb'] = int(parts[parts.index('volume-size') + 1])
        except (ValueError, IndexError) as e:
            return None, {"error": f"Invalid SageMaker command usage: {e}. Refer to help for correct syntax."}
        return command, args, commands

    def _parse_rekognition_command(self, parts):
        commands = [
            {"command": "analyze_image_labels", "usage": "rekognition analyze image-labels in bucket <bucket-name> key <object-key> in <region> [max-labels <count>] [min-confidence <percentage>]"},
        ]

        command, args = None, {}
        try:
            if 'analyze' in parts and 'image-labels' in parts:
                command = 'analyze_image_labels'
                args['bucket_name'] = parts[parts.index('bucket') + 1]
                args['object_key'] = parts[parts.index('key') + 1]
                args['region'] = parts[parts.index('in') + 1]
                if 'max-labels' in parts:
                    args['max_labels'] = int(parts[parts.index('max-labels') + 1])
                if 'min-confidence' in parts:
                    args['min_confidence'] = float(parts[parts.index('min-confidence') + 1])
        except (ValueError, IndexError) as e:
            return None, {"error": f"Invalid Rekognition command usage: {e}. Refer to help for correct syntax."}
        return command, args, commands

    def _parse_comprehend_command(self, parts):
        commands = [
            {"command": "detect_sentiment", "usage": "comprehend detect sentiment for text \"<text>\" in <region> [language <code>]"},
        ]

        command, args = None, {}
        try:
            if 'detect' in parts and 'sentiment' in parts:
                command = 'detect_sentiment'
                args['text'] = parts[parts.index('text') + 1]
                args['region'] = parts[parts.index('in') + 1]
                if 'language' in parts:
                    args['language_code'] = parts[parts.index('language') + 1]
        except (ValueError, IndexError) as e:
            return None, {"error": f"Invalid Comprehend command usage: {e}. Refer to help for correct syntax."}
        return command, args, commands

    def _parse_polly_command(self, parts):
        commands = [
            {"command": "synthesize_speech", "usage": "polly synthesize speech for text \"<text>\" to bucket <bucket-name> key <object-key> in <region> [voice <voice-id>] [format <output-format>]"},
        ]

        command, args = None, {}
        try:
            if 'synthesize' in parts and 'speech' in parts:
                command = 'synthesize_speech'
                args['text'] = parts[parts.index('text') + 1]
                args['output_s3_bucket'] = parts[parts.index('bucket') + 1]
                args['output_s3_key'] = parts[parts.index('key') + 1]
                args['region'] = parts[parts.index('in') + 1]
                if 'voice' in parts:
                    args['voice_id'] = parts[parts.index('voice') + 1]
                if 'format' in parts:
                    args['output_format'] = parts[parts.index('format') + 1]
        except (ValueError, IndexError) as e:
            return None, {"error": f"Invalid Polly command usage: {e}. Refer to help for correct syntax."}
        return command, args, commands

    def _parse_kinesis_command(self, parts):
        commands = [
            {"command": "smart_create_data_stream", "usage": "kinesis smart-create data-stream <stream-name> in <region> [shards <count>]"},
        ]

        command, args = None, {}
        try:
            if 'smart-create' in parts and 'data-stream' in parts:
                command = 'smart_create_data_stream'
                args['stream_name'] = parts[parts.index('stream') + 1]
                args['region'] = parts[parts.index('in') + 1]
                if 'shards' in parts:
                    args['shard_count'] = int(parts[parts.index('shards') + 1])
        except (ValueError, IndexError) as e:
            return None, {"error": f"Invalid Kinesis command usage: {e}. Refer to help for correct syntax."}
        return command, args, commands

    def _parse_redshift_command(self, parts):
        commands = [
            {"command": "smart_create_cluster", "usage": "redshift smart-create cluster <cluster-identifier> node-type <node-type> username <username> password <password> in <region> [node-count <count>] [security-groups <sg-id-1> ...] [vpc <vpc-id>]"},
        ]

        command, args = None, {}
        try:
            if 'smart-create' in parts and 'cluster' in parts:
                command = 'smart_create_cluster'
                args['cluster_identifier'] = parts[parts.index('cluster') + 1]
                args['node_type'] = parts[parts.index('node-type') + 1]
                args['master_username'] = parts[parts.index('username') + 1]
                args['master_user_password'] = parts[parts.index('password') + 1]
                args['region'] = parts[parts.index('in') + 1]
                if 'node-count' in parts:
                    args['node_count'] = int(parts[parts.index('node-count') + 1])
                if 'security-groups' in parts:
                    sg_index = parts.index('security-groups') + 1
                    sg_ids = []
                    while sg_index < len(parts) and parts[sg_index].startswith('sg-'):
                        sg_ids.append(parts[sg_index])
                        sg_index += 1
                    args['vpc_security_group_ids'] = sg_ids
                if 'vpc' in parts:
                    args['vpc_id'] = parts[parts.index('vpc') + 1]
        except (ValueError, IndexError) as e:
            return None, {"error": f"Invalid Redshift command usage: {e}. Refer to help for correct syntax."}
        return command, args, commands

    def _parse_athena_command(self, parts):
        commands = [
            {"command": "run_query", "usage": "athena run query \"<query-string>\" on database <database-name> output <s3-output-location> in <region>"},
        ]

        command, args = None, {}
        try:
            if 'run' in parts and 'query' in parts:
                command = 'run_query'
                args['database'] = parts[parts.index('database') + 1]
                args['query_string'] = parts[parts.index('query') + 1]
                args['output_location'] = parts[parts.index('output') + 1]
                args['region'] = parts[parts.index('in') + 1]
        except (ValueError, IndexError) as e:
            return None, {"error": f"Invalid Athena command usage: {e}. Refer to help for correct syntax."}
        return command, args, commands

    def _parse_waf_command(self, parts):
        commands = [
            {"command": "smart_create_web_acl", "usage": "waf smart-create web-acl <name> in <region> [scope <scope>] [default-action <action>]"},
            {"command": "troubleshoot_web_acl", "usage": "waf troubleshoot web-acl <name> in <region> [scope <scope>]"},
        ]

        command, args = None, {}
        try:
            if 'smart-create' in parts and 'web-acl' in parts:
                command = 'smart_create_web_acl'
                args['name'] = parts[parts.index('web-acl') + 1]
                args['region'] = parts[parts.index('in') + 1]
                if 'scope' in parts:
                    args['scope'] = parts[parts.index('scope') + 1]
                if 'default-action' in parts:
                    args['default_action'] = parts[parts.index('default-action') + 1]
            elif 'troubleshoot' in parts and 'web-acl' in parts:
                command = 'troubleshoot_web_acl'
                args['name'] = parts[parts.index('web-acl') + 1]
                args['region'] = parts[parts.index('in') + 1]
                if 'scope' in parts:
                    args['scope'] = parts[parts.index('scope') + 1]
        except (ValueError, IndexError) as e:
            return None, {"error": f"Invalid WAF command usage: {e}. Refer to help for correct syntax."}
        return command, args, commands

    def _parse_guardduty_command(self, parts):
        commands = [
            {"command": "smart_enable_guardduty", "usage": "guardduty smart-enable in <region>"},
        ]

        command, args = None, {}
        try:
            if 'smart-enable' in parts:
                command = 'smart_enable_guardduty'
                args['region'] = parts[parts.index('in') + 1]
        except (ValueError, IndexError) as e:
            return None, {"error": f"Invalid GuardDuty command usage: {e}. Refer to help for correct syntax."}
        return command, args, commands

    def _parse_config_command(self, parts):
        commands = [
            {"command": "smart_enable_config", "usage": "config smart-enable config in <region> s3-bucket <bucket-name>"},
            {"command": "list_compliance_by_resource", "usage": "config list compliance-by-resource in <region> [resource-type <type>] [compliance-type <type>]"},
        ]

        command, args = None, {}
        try:
            if 'smart-enable' in parts and 'config' in parts:
                command = 'smart_enable_config'
                args['region'] = parts[parts.index('in') + 1]
                args['s3_bucket'] = parts[parts.index('s3-bucket') + 1]
            elif 'list' in parts and 'compliance-by-resource' in parts:
                command = 'list_compliance_by_resource'
                args['region'] = parts[parts.index('in') + 1]
                if 'resource-type' in parts:
                    args['resource_type'] = parts[parts.index('resource-type') + 1]
                if 'compliance-type' in parts:
                    args['compliance_type'] = parts[parts.index('compliance-type') + 1]
        except (ValueError, IndexError) as e:
            return None, {"error": f"Invalid Config command usage: {e}. Refer to help for correct syntax."}
        return command, args, commands

    def _parse_sns_command(self, parts):
        commands = [
            {"command": "smart_create_topic_and_subscribe_email", "usage": "sns smart-create topic <topic-name> email <email-address> in <region>"},
        ]

        command, args = None, {}
        try:
            if 'smart-create' in parts and 'topic' in parts:
                command = 'smart_create_topic_and_subscribe_email'
                args['topic_name'] = parts[parts.index('topic') + 1]
                args['email_address'] = parts[parts.index('email') + 1]
                args['region'] = parts[parts.index('in') + 1]
        except (ValueError, IndexError) as e:
            return None, {"error": f"Invalid SNS command usage: {e}. Refer to help for correct syntax."}
        return command, args, commands

    def _parse_sqs_command(self, parts):
        commands = [
            {"command": "smart_create_queue", "usage": "sqs smart-create queue <queue-name> in <region> [message-retention-period <seconds>] [visibility-timeout <seconds>]"},
        ]

        command, args = None, {}
        try:
            if 'smart-create' in parts and 'queue' in parts:
                command = 'smart_create_queue'
                args['queue_name'] = parts[parts.index('queue') + 1]
                args['region'] = parts[parts.index('in') + 1]
                if 'message-retention-period' in parts:
                    args['message_retention_period'] = int(parts[parts.index('message-retention-period') + 1])
                if 'visibility-timeout' in parts:
                    args['visibility_timeout'] = int(parts[parts.index('visibility-timeout') + 1])
        except (ValueError, IndexError) as e:
            return None, {"error": f"Invalid SQS command usage: {e}. Refer to help for correct syntax."}
        return command, args, commands

    def _parse_command(self, user_command: str):
        parts = shlex.split(user_command)
        if not parts:
            return None, None, None

        service = self._get_service(parts)
        if not service:
            return None, None, {}

        parser_map = {
            'ec2': self._parse_ec2_command,
            's3': self._parse_s3_command,
            'iam': self._parse_iam_command,
            'vpc': self._parse_vpc_command,
            'rds': self._parse_rds_command,
            'cloudwatch': self._parse_cloudwatch_command,
            'cloudtrail': self._parse_cloudtrail_command,
            'cost': self._parse_cost_management_command,
            'secretsmanager': self._parse_secrets_manager_command,
            'acm': self._parse_acm_command,
            'route53': self._parse_route53_command,
            'elb': self._parse_elb_command,
            'lambda': self._parse_lambda_command,
            'autoscaling': self._parse_autoscaling_command,
            'opensearch': self._parse_opensearch_command,
            'eks': self._parse_eks_command,
            'ebs': self._parse_ebs_command,
            'elasticbeanstalk': self._parse_elasticbeanstalk_command,
            'efs': self._parse_efs_command,
            'fargate': self._parse_fargate_command,
            'dms': self._parse_dms_command,
            'apigateway': self._parse_apigateway_command,
            'cloudfront': self._parse_cloudfront_command,
            'sagemaker': self._parse_sagemaker_command,
            'rekognition': self._parse_rekognition_command,
            'comprehend': self._parse_comprehend_command,
            'polly': self._parse_polly_command,
            'kinesis': self._parse_kinesis_command,
            'redshift': self._parse_redshift_command,
            'athena': self._parse_athena_command,
            'waf': self._parse_waf_command,
            'guardduty': self._parse_guardduty_command,
            'config': self._parse_config_command,
            'sns': self._parse_sns_command,
            'sqs': self._parse_sqs_command,
        }

        parser = parser_map.get(service)
        if parser:
            command, args, commands_list = parser(parts)
            return service, command, args, commands_list
        
        return None, None, {}, []

    def _workflow_smart_create_eks(self, name: str, region: str, instance_types: list = None):
        """
        Orchestrates the creation of a full EKS cluster and node group.
        """
        print(f"--- Starting Workflow: Smart Create EKS Cluster '{name}' in {region} ---")
        if instance_types is None:
            instance_types = ['t3.medium']
        final_summary = {
            'workflow': 'eks-smart-create',
            'steps': [],
            'outputs': {}
        }

        try:
            iam_agent = self.agents['iam']
            vpc_agent = self.agents['vpc']
            eks_agent = self.agents['eks']

            # Step 1: Create IAM Roles
            print("\nStep 1: Creating IAM roles for EKS...")
            cluster_role_name = f"{name}-cluster-role"
            nodegroup_role_name = f"{name}-nodegroup-role"
            
            cluster_role_result = iam_agent._create_eks_cluster_role(role_name=cluster_role_name)
            if cluster_role_result['status'] != 'success': return cluster_role_result
            cluster_role_arn = cluster_role_result['role_arn']
            final_summary['steps'].append('EKS Cluster Role Created')
            final_summary['outputs']['cluster_role_arn'] = cluster_role_arn

            nodegroup_role_result = iam_agent._create_eks_nodegroup_role(role_name=nodegroup_role_name)
            if nodegroup_role_result['status'] != 'success': return nodegroup_role_result
            nodegroup_role_arn = nodegroup_role_result['role_arn']
            final_summary['steps'].append('EKS Node Group Role Created')
            final_summary['outputs']['nodegroup_role_arn'] = nodegroup_role_arn

            # Step 2: Create VPC Environment
            print("\nStep 2: Creating VPC environment...")
            vpc_result = vpc_agent._smart_create_vpc(region=region, name=f"{name}-vpc")
            if vpc_result['status'] != 'success': return vpc_result
            final_summary['steps'].append('VPC Environment Created')
            final_summary['outputs']['vpc'] = vpc_result['created_resources']
            vpc_id = vpc_result['created_resources']['vpc_id']
            # EKS requires both public and private subnets
            subnet_ids = [vpc_result['created_resources']['public_subnet_id'], vpc_result['created_resources']['private_subnet_id']]

            # Step 3: Create EKS Cluster
            print("\nStep 3: Creating EKS Cluster Control Plane...")
            cluster_result = eks_agent._create_cluster(
                region=region, 
                name=name, 
                role_arn=cluster_role_arn, 
                vpc_id=vpc_id, 
                subnet_ids=subnet_ids
            )
            if cluster_result['status'] != 'success': return cluster_result
            final_summary['steps'].append('EKS Cluster Created')
            final_summary['outputs']['cluster_arn'] = cluster_result['cluster_arn']

            # Step 4: Create EKS Node Group
            print("\nStep 4: Creating EKS Node Group...")
            nodegroup_result = eks_agent._create_nodegroup(
                region=region,
                cluster_name=name,
                nodegroup_name=f"{name}-nodegroup",
                node_role_arn=nodegroup_role_arn,
                instance_types=instance_types,
                subnet_ids=subnet_ids
            )
            if nodegroup_result['status'] != 'success': return nodegroup_result
            final_summary['steps'].append('EKS Node Group Created')
            final_summary['outputs']['nodegroup_arn'] = nodegroup_result['nodegroup_arn']

            # Step 5: Install EKS Addons
            print("\nStep 5: Installing EKS Addons...")
            # CoreDNS and VPC CNI are typically managed by EKS itself as add-ons
            # EBS CSI Driver
            ebs_csi_result = eks_agent._install_ebs_csi_driver(region=region, cluster_name=name)
            if ebs_csi_result['status'] != 'success': return ebs_csi_result
            final_summary['steps'].append('EBS CSI Driver Installed')

            # EFS CSI Driver
            efs_csi_result = eks_agent._install_efs_csi_driver(region=region, cluster_name=name)
            if efs_csi_result['status'] != 'success': return efs_csi_result
            final_summary['steps'].append('EFS CSI Driver Installed')

            # AWS Load Balancer Controller
            alb_controller_result = eks_agent._install_aws_load_balancer_controller(region=region, cluster_name=name, vpc_id=vpc_id)
            if alb_controller_result['status'] != 'success': return alb_controller_result
            final_summary['steps'].append('AWS Load Balancer Controller Installed')

            print("\n--- Workflow: EKS Smart Create Finished Successfully ---")
            return {"status": "success", "summary": final_summary}

        except Exception as e:
            print(f"--- Workflow Failed: {e} ---")
            return {"status": "error", "message": f"EKS Smart Create workflow failed: {e}"}

    def execute_command(self, user_command: str):
        """
        Parses and executes a user command, routing to agents or workflows.
        """
        print(f"\nReceived command: '{user_command}'")
        parts = shlex.split(user_command)

        # Check for high-level workflows first
        if 'create-web-app' in parts:
            try:
                name = parts[parts.index('named') + 1]
                region = parts[parts.index('in') + 1]
                return self._workflow_create_web_app(name=name, region=region)
            except (ValueError, IndexError):
                return {"status": "error", "message": "Usage: create-web-app named <app-name> in <region>"}
        elif 'troubleshoot' in parts and 'web-app' in parts:
            try:
                name = parts[parts.index('named') + 1]
                region = parts[parts.index('in') + 1]
                return self._workflow_troubleshoot_web_app(name=name, region=region)
            except (ValueError, IndexError):
                return {"status": "error", "message": "Usage: troubleshoot web-app named <app-name> in <region>"}
        elif 'eks' in parts and 'smart-create' in parts:
            try:
                name = parts[parts.index('cluster') + 1]
                region = parts[parts.index('in') + 1]
                instance_types = []
                if 'instance-types' in parts:
                    type_index = parts.index('instance-types') + 1
                    while type_index < len(parts) and not parts[type_index] == 'in':
                        instance_types.append(parts[type_index])
                        type_index += 1
                return self._workflow_smart_create_eks(name=name, region=region, instance_types=instance_types or None)
            except (ValueError, IndexError):
                return {"status": "error", "message": "Usage: eks smart-create cluster <name> in <region> [instance-types <type1> ...]"}

        # If not a workflow, proceed with standard agent routing
        service, command, args, commands_list = self._parse_command(user_command)

        if args and 'error' in args:
            return {"status": "error", "message": args['error']}

        if not service or not command:
            return {"status": "error", "message": "Could not understand the command. Please be more specific."}

        if service in self.agents:
            agent = self.agents[service]
            try:
                print(f"Routing to {service.upper()}Agent with command '{command}' and args {args}")
                return agent.execute(command, **args)
            except Exception as e:
                return {"status": "error", "message": str(e)}
        else:
            return {"status": "error", "message": f"No agent found for service '{service}'."}