from agentic_devops.aws.ec2 import EC2Service
from agentic_devops.aws.s3 import S3Service
from agentic_devops.github import GitHubService
from agentic_devops.core.context import DevOpsContext

# Initialize context
context = DevOpsContext(
    user_id="user123",
    aws_region="us-west-2",
    github_org="your-organization"
)

# Initialize services
ec2 = EC2Service(context=context)
s3 = S3Service(context=context)
github = GitHubService(context=context)

# List EC2 instances
instances = ec2.list_instances(filters=[{"Name": "instance-state-name", "Values": ["running"]}])
print(f"Found {len(instances)} running EC2 instances")

# Create S3 bucket with encryption
bucket = s3.create_bucket(
    name="my-secure-bucket",
    region="us-west-2",
    encryption={"algorithm": "AES256"},
    versioning=True
)

# Deploy from GitHub to EC2
ec2.deploy_from_github(
    instance_id="i-1234567890abcdef0",
    repository="your-org/your-repo",
    branch="main",
    deploy_path="/var/www/html",
    setup_script="scripts/setup.sh",
    environment_variables={"ENV": "production"}
)

from agentic_devops.autonomous import AutonomousDeployer
from agentic_devops.core.context import DevOpsContext

# Initialize context
context = DevOpsContext(
    user_id="user123",
    aws_region="us-west-2",
    github_org="your-organization"
)

# Initialize the autonomous deployer
deployer = AutonomousDeployer(context=context)

# Define high-level deployment requirements
deployment_spec = {
    "application": "web-service",
    "source": {
        "type": "github",
        "repository": "your-org/web-service",
        "branch": "main"
    },
    "target": {
        "environment": "production",
        "regions": ["us-west-2", "us-east-1"],
        "scaling": {
            "min_instances": 2,
            "max_instances": 10,
            "auto_scale": True
        }
    },
    "strategy": {
        "type": "blue-green",
        "health_check_path": "/health",
        "rollback_on_failure": True
    },
    "notifications": {
        "slack_channel": "#deployments",
        "email": "team@example.com"
    }
}

# Let the autonomous system handle the entire deployment
deployment = deployer.deploy(deployment_spec)

# Monitor the autonomous deployment
status = deployer.get_status(deployment.id)
print(f"Deployment status: {status.phase}")
print(f"Actions taken: {len(status.actions)}")
for action in status.actions:
    print(f"- {action.timestamp}: {action.description} ({action.status})")

from agents import Agent, Runner
from agentic_devops.agents.tools import (
    list_ec2_instances,
    start_ec2_instances,
    stop_ec2_instances,
    create_ec2_instance
)
from agentic_devops.core.context import DevOpsContext

# Create a context with user information
context = DevOpsContext(
    user_id="user123",
    aws_region="us-west-2",
    github_org="your-organization"
)

# Create an EC2-focused agent
ec2_agent = Agent(
    name="EC2 Assistant",
    instructions="""
    You are an EC2 management assistant that helps users manage their AWS EC2 instances.
    You can list, start, stop, and create EC2 instances based on user requests.
    Always confirm important actions before executing them and provide clear explanations.
    """,
    tools=[
        list_ec2_instances,
        start_ec2_instances,
        stop_ec2_instances,
        create_ec2_instance
    ],
    model="gpt-4o"
)

# Run the agent with a user query
result = Runner.run_sync(
    ec2_agent,
    "I need to launch 3 t2.micro instances for a web application in us-west-2. They should have the tag 'Project=WebApp'.",
    context=context
)

print(result.final_output)

from agents import Agent, Runner, Handoff
from agentic_devops.agents.tools import (
    # EC2 tools
    list_ec2_instances,
    start_ec2_instances,
    stop_ec2_instances,
    create_ec2_instance,
    # S3 tools
    list_s3_buckets,
    create_s3_bucket,
    # GitHub tools
    get_github_repository,
    list_github_issues,
    create_github_issue,
    # Deployment tools
    deploy_to_ec2
)

# Create specialized agents
ec2_agent = Agent(
    name="EC2 Agent",
    instructions="You are an EC2 management specialist...",
    tools=[list_ec2_instances, start_ec2_instances, stop_ec2_instances, create_ec2_instance],
    model="gpt-4o"
)

s3_agent = Agent(
    name="S3 Agent",
    instructions="You are an S3 management specialist...",
    tools=[list_s3_buckets, create_s3_bucket],
    model="gpt-4o"
)

github_agent = Agent(
    name="GitHub Agent",
    instructions="You are a GitHub management specialist...",
    tools=[get_github_repository, list_github_issues, create_github_issue],
    model="gpt-4o"
)

deployment_agent = Agent(
    name="Deployment Agent",
    instructions="You are a deployment specialist...",
    tools=[deploy_to_ec2],
    model="gpt-4o"
)

# Create an orchestrator agent that can delegate to specialized agents
orchestrator = Agent(
    name="DevOps Orchestrator",
    instructions="""
    You are a DevOps orchestrator that helps users manage their cloud infrastructure and code repositories.
    You can delegate tasks to specialized agents for EC2, S3, GitHub, and deployments.
    Determine which specialized agent is best suited for each user request and hand off accordingly.
    """,
    handoffs=[
        Handoff(agent=ec2_agent, description="Handles EC2 instance management tasks"),
        Handoff(agent=s3_agent, description="Handles S3 bucket operations"),
        Handoff(agent=github_agent, description="Handles GitHub repository management"),
        Handoff(agent=deployment_agent, description="Handles deployment workflows")
    ],
    model="gpt-4o"
)

# Run the orchestrator with a complex query
result = Runner.run_sync(
    orchestrator,
    """
    I need to set up a new web application deployment:
    1. Create 2 t2.micro EC2 instances with the tag 'Project=WebApp'
    2. Create an S3 bucket for static assets with versioning enabled
    3. Clone our 'company/webapp' GitHub repository to the EC2 instances
    4. Create a GitHub issue to track this deployment
    """,
    context=context
)

print(result.final_output)

import asyncio
from agents import Runner

async def run_agent_async():
    result = await Runner.run(
        ec2_agent,
        "List all my EC2 instances in us-west-2 and show their status",
        context=context
    )
    return result.final_output

# Run the agent asynchronously
response = asyncio.run(run_agent_async())
print(response)

from agentic_devops.core.guardrails import (
    security_guardrail,
    sensitive_info_guardrail
)

# Apply security guardrail to check for potentially harmful operations
@security_guardrail
def perform_operation(operation_details):
    # Implementation
    pass

# Apply sensitive information guardrail to prevent leaking credentials
@sensitive_info_guardrail
def generate_response(user_query, system_data):
    # Implementation
    pass

from agents.tracing import set_tracing_enabled, get_trace

# Enable tracing
set_tracing_enabled(True)

# Run the agent
result = Runner.run_sync(ec2_agent, "List my EC2 instances", context=context)

# Get the trace for analysis
trace = get_trace()
print(f"Agent took {len(trace.steps)} steps to complete the task")
for step in trace.steps:
    print(f"Step: {step.type}, Duration: {step.duration}ms")

from agentic_devops.core.credentials import CredentialManager

# Store credentials securely
cred_manager = CredentialManager()
cred_manager.store_aws_credentials(
    access_key="YOUR_ACCESS_KEY",
    secret_key="YOUR_SECRET_KEY",
    region="us-west-2",
    profile_name="production"
)

cred_manager.store_github_credentials(
    token="YOUR_GITHUB_TOKEN",
    username="your-username"
)

# Retrieve credentials securely
aws_creds = cred_manager.get_aws_credentials(profile_name="production")
github_creds = cred_manager.get_github_credentials()

from agentic_devops.core.logging import setup_logging
from agentic_devops.aws.base import AWSServiceError, ResourceNotFoundError

# Setup logging
logger = setup_logging(level="INFO", log_file="agentic-devops.log")

try:
    # Attempt to perform an operation
    ec2.start_instance(instance_id="i-nonexistentid")
except ResourceNotFoundError as e:
    # Handle specific error with context
    logger.error(f"Could not find instance: {e}")
    logger.info(f"Suggestion: {e.suggestion}")
    # Take remedial action
except AWSServiceError as e:
    # Handle general AWS errors
    logger.error(f"AWS operation failed: {e}")
    logger.info(f"Suggestion: {e.suggestion}")

from agentic_devops.aws.base import AWSBaseService

class CustomService(AWSBaseService):
    """Custom service implementation."""
    
    SERVICE_NAME = "custom-service"
    
    def __init__(self, credentials=None, region=None):
        super().__init__(credentials, region)
        # Initialize service-specific resources
        
    def custom_operation(self, param1, param2):
        """Implement custom operation."""
        try:
            # Implement operation logic
            result = self._client.some_operation(
                Param1=param1,
                Param2=param2
            )
            return self._format_response(result)
        except Exception as e:
            # Handle and transform errors
            self.handle_error(e, "custom_operation")

from agents import function_tool
from pydantic import BaseModel, Field
from agentic_devops.core.context import DevOpsContext, RunContextWrapper

# Define the input schema for your tool
class CustomOperationInput(BaseModel):
    resource_id: str = Field(..., description="The ID of the resource to operate on")
    operation_type: str = Field(..., description="The type of operation to perform")
    parameters: dict = Field(default={}, description="Additional parameters for the operation")

# Create a function tool
@function_tool()
async def custom_operation(
    wrapper: RunContextWrapper[DevOpsContext],
    input_data: CustomOperationInput
) -> dict:
    """
    Perform a custom operation on a specified resource.
    
    Args:
        resource_id: The ID of the resource to operate on
        operation_type: The type of operation to perform (e.g., "analyze", "optimize", "backup")
        parameters: Additional parameters specific to the operation type
        
    Returns:
        A dictionary containing the operation results
    """
    # Access the context
    context = wrapper.context
    
    # Implement your custom logic
    result = {
        "resource_id": input_data.resource_id,
        "operation_type": input_data.operation_type,
        "status": "completed",
        "details": {
            "timestamp": "2023-01-01T00:00:00Z",
            "user": context.user_id,
            "region": context.aws_region,
            "parameters": input_data.parameters
        }
    }
    
    return result