#!/bin/bash
################################################################################
# PyGuardian Docker Deployment Script
# Quick deployment tool for containerized PyGuardian
################################################################################

set -e

# Colors
RED='\033[0;31m'
GREEN='\033[0;32m'
BLUE='\033[0;34m'
YELLOW='\033[1;33m'
NC='\033[0m'

# Configuration
PYGUARDIAN_VERSION="2.1.0"
DOCKER_REPO="pyguardian"
DEPLOYMENT_MODE=""
ENV_FILE=".env"

# Print functions
log() { echo -e "${BLUE}[INFO]${NC} $1"; }
success() { echo -e "${GREEN}[SUCCESS]${NC} $1"; }
warn() { echo -e "${YELLOW}[WARNING]${NC} $1"; }
error() { echo -e "${RED}[ERROR]${NC} $1" >&2; }

print_banner() {
    echo -e "${BLUE}"
    echo "================================================================="
    echo "  PyGuardian v${PYGUARDIAN_VERSION} Docker Deployment"
    echo "  Enterprise Security System - Container Edition"
    echo "================================================================="
    echo -e "${NC}"
}

print_usage() {
    echo "Usage: $0 [OPTIONS] MODE"
    echo ""
    echo "MODES:"
    echo "  standalone     Single container with all features"
    echo "  cluster        Controller + agents cluster setup"
    echo "  development    Development environment with tools"
    echo "  production     Production deployment"
    echo ""
    echo "OPTIONS:"
    echo "  --build        Force rebuild images"
    echo "  --no-cache     Build without cache"
    echo "  --scale N      Scale agents to N replicas (cluster mode)"
    echo "  --monitoring   Enable monitoring stack"
    echo "  --env FILE     Use custom environment file"
    echo "  --help         Show this help"
    echo ""
    echo "EXAMPLES:"
    echo "  $0 standalone                  # Quick single container"
    echo "  $0 cluster --scale 3           # Cluster with 3 agents"
    echo "  $0 production --monitoring     # Production with monitoring"
    echo "  $0 development                 # Development environment"
}

check_requirements() {
    log "Checking system requirements..."
    
    # Check Docker
    if ! command -v docker &> /dev/null; then
        error "Docker is not installed. Please install Docker first."
        exit 1
    fi
    
    # Check Docker Compose
    if ! command -v docker-compose &> /dev/null && ! docker compose version &> /dev/null; then
        error "Docker Compose is not installed. Please install Docker Compose first."
        exit 1
    fi
    
    # Check if Docker daemon is running
    if ! docker info &> /dev/null; then
        error "Docker daemon is not running. Please start Docker service."
        exit 1
    fi
    
    success "System requirements satisfied"
}

setup_environment() {
    log "Setting up environment configuration..."
    
    # Create directories
    sudo mkdir -p /opt/pyguardian/{controller,agent1,agent2}/{data,logs,config}
    sudo chown -R $USER:$USER /opt/pyguardian
    
    # Setup environment file
    if [[ ! -f "$ENV_FILE" ]]; then
        if [[ -f ".env.docker" ]]; then
            cp .env.docker "$ENV_FILE"
            log "Created $ENV_FILE from template"
        else
            warn "No environment template found, creating minimal configuration"
            cat > "$ENV_FILE" << EOF
# PyGuardian Docker Environment
PYGUARDIAN_VERSION=$PYGUARDIAN_VERSION
LOG_LEVEL=INFO
CLUSTER_SECRET=$(openssl rand -hex 32)
JWT_SECRET=$(openssl rand -hex 32)
TELEGRAM_BOT_TOKEN=your_bot_token_here
EOF
        fi
    fi
    
    success "Environment setup completed"
}

build_images() {
    local build_args=""
    
    if [[ "$FORCE_BUILD" == "true" ]]; then
        build_args="--build"
    fi
    
    if [[ "$NO_CACHE" == "true" ]]; then
        build_args="$build_args --no-cache"
    fi
    
    log "Building PyGuardian Docker images..."
    
    case "$DEPLOYMENT_MODE" in
        "standalone")
            docker build $build_args -f deployment/docker/Dockerfile.optimized \
                --target standalone -t pyguardian:standalone .
            ;;
        "cluster"|"production")
            docker build $build_args -f deployment/docker/Dockerfile.optimized \
                --target controller -t pyguardian:controller .
            docker build $build_args -f deployment/docker/Dockerfile.optimized \
                --target agent -t pyguardian:agent .
            ;;
        "development")
            docker build $build_args -f deployment/docker/Dockerfile.optimized \
                --target development -t pyguardian:development .
            ;;
    esac
    
    success "Images built successfully"
}

deploy_standalone() {
    log "Deploying PyGuardian standalone container..."
    
    docker run -d \
        --name pyguardian-standalone \
        --restart unless-stopped \
        --privileged \
        --network host \
        --env-file "$ENV_FILE" \
        -v /opt/pyguardian/standalone/data:/opt/pyguardian/data \
        -v /opt/pyguardian/standalone/logs:/opt/pyguardian/logs \
        -v /opt/pyguardian/standalone/config:/opt/pyguardian/config \
        -v /var/log:/var/log:ro \
        pyguardian:standalone
    
    success "Standalone deployment completed"
    log "API available at: https://localhost:8443"
}

deploy_cluster() {
    log "Deploying PyGuardian cluster..."
    
    local compose_cmd="docker-compose -f docker-compose.prod.yml"
    local scale_args=""
    
    if [[ -n "$SCALE_AGENTS" ]]; then
        scale_args="--scale pyguardian-agent-1=$SCALE_AGENTS"
    fi
    
    if [[ "$ENABLE_MONITORING" == "true" ]]; then
        compose_cmd="$compose_cmd --profile monitoring"
    fi
    
    $compose_cmd --env-file "$ENV_FILE" up -d $scale_args
    
    success "Cluster deployment completed"
    log "Controller API available at: https://localhost:8443"
    
    if [[ "$ENABLE_MONITORING" == "true" ]]; then
        log "Monitoring available at: http://localhost:9090"
    fi
}

deploy_development() {
    log "Deploying PyGuardian development environment..."
    
    docker-compose -f docker-compose.dev.yml --env-file "$ENV_FILE" up -d
    
    success "Development environment deployed"
    log "API available at: http://localhost:8443"
    log "Jupyter Lab available at: http://localhost:8888"
}

deploy_production() {
    log "Deploying PyGuardian production environment..."
    
    # Production uses cluster deployment with optimizations
    local compose_cmd="docker-compose -f docker-compose.prod.yml"
    
    if [[ "$ENABLE_MONITORING" == "true" ]]; then
        compose_cmd="$compose_cmd --profile monitoring"
    fi
    
    $compose_cmd --env-file "$ENV_FILE" up -d
    
    # Wait for health checks
    log "Waiting for services to be healthy..."
    sleep 30
    
    success "Production deployment completed"
    show_deployment_status
}

show_deployment_status() {
    log "Deployment Status:"
    
    echo ""
    echo "Running Containers:"
    docker ps --format "table {{.Names}}\t{{.Image}}\t{{.Status}}" | grep pyguardian
    
    echo ""
    echo "Health Status:"
    for container in $(docker ps --format "{{.Names}}" | grep pyguardian); do
        echo -n "$container: "
        if docker exec $container sh -c 'exit 0' 2>/dev/null; then
            echo -e "${GREEN}✅ Healthy${NC}"
        else
            echo -e "${RED}❌ Unhealthy${NC}"
        fi
    done
    
    echo ""
    echo "Access Information:"
    case "$DEPLOYMENT_MODE" in
        "standalone"|"cluster"|"production")
            echo "🌐 API Endpoint: https://localhost:8443"
            echo "📊 Health Check: https://localhost:8443/health"
            ;;
        "development")
            echo "🌐 API Endpoint: http://localhost:8443"
            echo "🔬 Jupyter Lab: http://localhost:8888"
            echo "📊 Health Check: http://localhost:8443/health"
            ;;
    esac
    
    if [[ "$ENABLE_MONITORING" == "true" ]]; then
        echo "📈 Monitoring: http://localhost:9090"
    fi
}

cleanup_deployment() {
    warn "Cleaning up existing PyGuardian deployment..."
    
    # Stop and remove containers
    docker-compose -f docker-compose.prod.yml down 2>/dev/null || true
    docker-compose -f docker-compose.dev.yml down 2>/dev/null || true
    docker rm -f pyguardian-standalone 2>/dev/null || true
    
    success "Cleanup completed"
}

main() {
    print_banner
    
    # Parse command line arguments
    FORCE_BUILD="false"
    NO_CACHE="false"
    SCALE_AGENTS=""
    ENABLE_MONITORING="false"
    
    while [[ $# -gt 0 ]]; do
        case $1 in
            --build)
                FORCE_BUILD="true"
                shift
                ;;
            --no-cache)
                NO_CACHE="true"
                shift
                ;;
            --scale)
                SCALE_AGENTS="$2"
                shift 2
                ;;
            --monitoring)
                ENABLE_MONITORING="true"
                shift
                ;;
            --env)
                ENV_FILE="$2"
                shift 2
                ;;
            --help)
                print_usage
                exit 0
                ;;
            standalone|cluster|development|production)
                DEPLOYMENT_MODE="$1"
                shift
                ;;
            *)
                error "Unknown option: $1"
                print_usage
                exit 1
                ;;
        esac
    done
    
    # Validate deployment mode
    if [[ -z "$DEPLOYMENT_MODE" ]]; then
        error "Deployment mode is required"
        print_usage
        exit 1
    fi
    
    # Run deployment
    check_requirements
    setup_environment
    
    # Cleanup existing deployment if requested
    if [[ "$FORCE_BUILD" == "true" ]]; then
        cleanup_deployment
    fi
    
    build_images
    
    case "$DEPLOYMENT_MODE" in
        "standalone")
            deploy_standalone
            ;;
        "cluster")
            deploy_cluster
            ;;
        "development")
            deploy_development
            ;;
        "production")
            deploy_production
            ;;
    esac
    
    echo ""
    success "🚀 PyGuardian v$PYGUARDIAN_VERSION deployment completed!"
    echo ""
    echo "Next steps:"
    echo "1. Configure your Telegram bot token in $ENV_FILE"
    echo "2. Review configuration files in /opt/pyguardian/*/config/"
    echo "3. Monitor logs: docker logs -f <container_name>"
    echo ""
    echo "For management commands, use: make -f Makefile.docker help"
}

# Handle script errors
trap 'echo -e "${RED}[ERROR]${NC} Deployment failed. Check logs above."; exit 1' ERR

# Run main function
main "$@"