#!/bin/bash

#==========================================================================
# PyGuardian Universal Installer
# Quick installation wrapper for all PyGuardian deployment modes
#==========================================================================

set -e

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

# Project information
PYGUARDIAN_VERSION="2.0.0"
PYGUARDIAN_REPO="https://github.com/SmartSolTech/PyGuardian"

print_header() {
    echo -e "${BLUE}"
    echo "================================================="
    echo "  PyGuardian Security System v${PYGUARDIAN_VERSION}"
    echo "  Universal Installation Wrapper"
    echo "================================================="
    echo -e "${NC}"
}

print_usage() {
    echo "Usage: $0 [OPTIONS]"
    echo ""
    echo "Options:"
    echo "  --mode MODE          Installation mode (standalone|controller|agent)"
    echo "  --controller HOST    Controller IP (required for agent mode)"
    echo "  --docker             Use Docker installation"
    echo "  --help              Show this help message"
    echo ""
    echo "Examples:"
    echo "  $0                                    # Interactive installation"
    echo "  $0 --mode standalone                 # Standalone installation"
    echo "  $0 --mode controller                 # Cluster controller"
    echo "  $0 --mode agent --controller 1.2.3.4 # Cluster agent"
    echo "  $0 --docker                          # Docker installation"
}

check_system() {
    echo -e "${BLUE}[INFO]${NC} Checking system requirements..."
    
    # Check if running as root
    if [[ $EUID -ne 0 ]]; then
        echo -e "${RED}[ERROR]${NC} This script must be run as root or with sudo"
        exit 1
    fi
    
    # Check operating system
    if ! command -v systemctl &> /dev/null; then
        echo -e "${RED}[ERROR]${NC} This installer requires a systemd-based Linux distribution"
        exit 1
    fi
    
    # Check Python version
    if command -v python3 &> /dev/null; then
        PYTHON_VERSION=$(python3 -c 'import sys; print(".".join(map(str, sys.version_info[:2])))')
        echo -e "${GREEN}[OK]${NC} Python ${PYTHON_VERSION} found"
        
        if ! python3 -c 'import sys; exit(0 if sys.version_info >= (3, 10) else 1)'; then
            echo -e "${RED}[ERROR]${NC} Python 3.10+ is required (found ${PYTHON_VERSION})"
            exit 1
        fi
    else
        echo -e "${RED}[ERROR]${NC} Python3 not found. Please install Python 3.10+"
        exit 1
    fi
    
    echo -e "${GREEN}[OK]${NC} System requirements satisfied"
}

download_installer() {
    echo -e "${BLUE}[INFO]${NC} Downloading PyGuardian installer..."
    
    # Create temporary directory
    TEMP_DIR=$(mktemp -d)
    cd "$TEMP_DIR"
    
    # Download the detailed installer
    if command -v curl &> /dev/null; then
        curl -fsSL "${PYGUARDIAN_REPO}/raw/main/deployment/scripts/install.sh" -o install.sh
    elif command -v wget &> /dev/null; then
        wget -q "${PYGUARDIAN_REPO}/raw/main/deployment/scripts/install.sh" -O install.sh
    else
        echo -e "${RED}[ERROR]${NC} Neither curl nor wget found. Please install one of them."
        exit 1
    fi
    
    chmod +x install.sh
    echo -e "${GREEN}[OK]${NC} Installer downloaded to ${TEMP_DIR}/install.sh"
    
    # Export for use in main function
    export INSTALLER_PATH="${TEMP_DIR}/install.sh"
}

run_docker_installation() {
    echo -e "${BLUE}[INFO]${NC} Starting Docker-based installation..."
    
    # Check if Docker is installed
    if ! command -v docker &> /dev/null; then
        echo -e "${YELLOW}[WARNING]${NC} Docker not found. Installing Docker..."
        
        # Install Docker
        curl -fsSL https://get.docker.com -o get-docker.sh
        sh get-docker.sh
        
        # Start Docker service
        systemctl enable docker
        systemctl start docker
        
        echo -e "${GREEN}[OK]${NC} Docker installed successfully"
    fi
    
    # Check if docker-compose is available
    if ! command -v docker-compose &> /dev/null; then
        if ! docker compose version &> /dev/null; then
            echo -e "${YELLOW}[WARNING]${NC} Docker Compose not found. Installing..."
            
            # Install docker-compose
            curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
            chmod +x /usr/local/bin/docker-compose
            
            echo -e "${GREEN}[OK]${NC} Docker Compose installed"
        fi
    fi
    
    # Download docker installation script
    TEMP_DIR=$(mktemp -d)
    cd "$TEMP_DIR"
    
    if command -v curl &> /dev/null; then
        curl -fsSL "${PYGUARDIAN_REPO}/raw/main/deployment/scripts/docker-install.sh" -o docker-install.sh
    else
        wget -q "${PYGUARDIAN_REPO}/raw/main/deployment/scripts/docker-install.sh" -O docker-install.sh
    fi
    
    chmod +x docker-install.sh
    
    # Run Docker installation
    ./docker-install.sh "$@"
}

run_interactive_installation() {
    echo -e "${BLUE}[INFO]${NC} Starting interactive installation..."
    echo ""
    
    echo "Select PyGuardian installation mode:"
    echo "1) Standalone server (all components on one server)"
    echo "2) Cluster controller (central management node)"
    echo "3) Cluster agent (managed node)"
    echo "4) Docker installation"
    echo ""
    
    while true; do
        read -p "Enter your choice (1-4): " choice
        case $choice in
            1)
                echo -e "${GREEN}[SELECTED]${NC} Standalone installation"
                "$INSTALLER_PATH" --mode standalone
                break
                ;;
            2)
                echo -e "${GREEN}[SELECTED]${NC} Cluster controller installation"
                "$INSTALLER_PATH" --mode controller
                break
                ;;
            3)
                echo -e "${GREEN}[SELECTED]${NC} Cluster agent installation"
                echo ""
                read -p "Enter controller IP address: " controller_ip
                if [[ -z "$controller_ip" ]]; then
                    echo -e "${RED}[ERROR]${NC} Controller IP is required for agent mode"
                    continue
                fi
                "$INSTALLER_PATH" --mode agent --controller "$controller_ip"
                break
                ;;
            4)
                echo -e "${GREEN}[SELECTED]${NC} Docker installation"
                run_docker_installation
                break
                ;;
            *)
                echo -e "${RED}[ERROR]${NC} Invalid choice. Please select 1-4."
                ;;
        esac
    done
}

main() {
    print_header
    
    # Parse command line arguments
    MODE=""
    CONTROLLER_HOST=""
    USE_DOCKER=false
    
    while [[ $# -gt 0 ]]; do
        case $1 in
            --mode)
                MODE="$2"
                shift 2
                ;;
            --controller)
                CONTROLLER_HOST="$2"
                shift 2
                ;;
            --docker)
                USE_DOCKER=true
                shift
                ;;
            --help)
                print_usage
                exit 0
                ;;
            *)
                echo -e "${RED}[ERROR]${NC} Unknown option: $1"
                print_usage
                exit 1
                ;;
        esac
    done
    
    # System checks
    check_system
    
    # Handle Docker installation
    if [[ "$USE_DOCKER" == true ]]; then
        run_docker_installation "$@"
        exit 0
    fi
    
    # Download detailed installer
    download_installer
    
    # Run installation based on mode
    if [[ -n "$MODE" ]]; then
        echo -e "${BLUE}[INFO]${NC} Running ${MODE} installation..."
        
        # Validate mode
        if [[ "$MODE" != "standalone" && "$MODE" != "controller" && "$MODE" != "agent" ]]; then
            echo -e "${RED}[ERROR]${NC} Invalid mode: $MODE"
            print_usage
            exit 1
        fi
        
        # Check controller host for agent mode
        if [[ "$MODE" == "agent" && -z "$CONTROLLER_HOST" ]]; then
            echo -e "${RED}[ERROR]${NC} Controller host is required for agent mode"
            print_usage
            exit 1
        fi
        
        # Run installer with specified mode
        if [[ "$MODE" == "agent" ]]; then
            "$INSTALLER_PATH" --mode agent --controller "$CONTROLLER_HOST"
        else
            "$INSTALLER_PATH" --mode "$MODE"
        fi
    else
        # Interactive mode
        run_interactive_installation
    fi
    
    # Cleanup
    if [[ -n "$INSTALLER_PATH" ]]; then
        rm -rf "$(dirname "$INSTALLER_PATH")"
    fi
    
    echo ""
    echo -e "${GREEN}[SUCCESS]${NC} PyGuardian installation completed!"
    echo ""
    echo "Next steps:"
    echo "1. Configure your Telegram bot token in /opt/pyguardian/config/config.yaml"
    echo "2. Review authentication settings in /opt/pyguardian/config/auth.yaml"
    echo "3. Start the service: systemctl start pyguardian"
    echo "4. Enable auto-start: systemctl enable pyguardian"
    echo ""
    echo -e "${YELLOW}[INFO]${NC} PyGuardian v2.1.0 includes:"
    echo "  ✓ JWT-based agent authentication"
    echo "  ✓ Encrypted agent credentials storage"
    echo "  ✓ RESTful API server with authentication"
    echo "  ✓ Comprehensive testing suite"
    echo "  ✓ CI/CD pipeline with security scanning"
    echo ""
    echo "Documentation: ${PYGUARDIAN_REPO}/tree/main/documentation"
    echo "Support: https://github.com/SmartSolTech/PyGuardian/issues"
}

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

# Run main function
main "$@"