#!/bin/bash

# MYP Frontend Installation Script for Debian
# This script installs and configures the MYP frontend reservation platform

# We'll handle errors ourselves rather than exiting immediately
# set -e
SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
LOG_FILE="$SCRIPT_DIR/frontend-install.log"

# Function for logging with timestamps and colors
log() {
    local timestamp=$(date +"%Y-%m-%d %H:%M:%S")
    local message="[$timestamp] $1"
    echo -e "$message" | tee -a "$LOG_FILE"
}

# Function for logging errors with timestamps and colors
log_error() {
    local timestamp=$(date +"%Y-%m-%d %H:%M:%S")
    local message="[$timestamp] ERROR: $1"
    echo -e "\033[0;31m$message\033[0m" | tee -a "$LOG_FILE"
}

# Function for logging warnings with timestamps and colors
log_warning() {
    local timestamp=$(date +"%Y-%m-%d %H:%M:%S")
    local message="[$timestamp] WARNING: $1"
    echo -e "\033[0;33m$message\033[0m" | tee -a "$LOG_FILE"
}

# Function for logging success with timestamps and colors
log_success() {
    local timestamp=$(date +"%Y-%m-%d %H:%M:%S")
    local message="[$timestamp] SUCCESS: $1"
    echo -e "\033[0;32m$message\033[0m" | tee -a "$LOG_FILE"
}

# Function to check if a command exists
command_exists() {
    command -v "$1" >/dev/null 2>&1
}

# Clear log file
> "$LOG_FILE"

# Add script usage info
usage() {
    echo "Usage: $0 [OPTIONS]"
    echo ""
    echo "OPTIONS:"
    echo "  --auto-production    Non-interactive installation in production mode"
    echo "  --auto-development   Non-interactive installation in development mode"
    echo "  --help               Show this help message"
    echo ""
    echo "Example:"
    echo "  $0 --auto-production"
    exit 1
}

# Check for help flag
if [ "$1" == "--help" ]; then
    usage
fi

log "===== Starting MYP Frontend Installation ====="
log "Installation directory: $SCRIPT_DIR"

# Display system information
log "System information:"
uname -a >> "$LOG_FILE" 2>&1
lsb_release -a >> "$LOG_FILE" 2>&1 || cat /etc/os-release >> "$LOG_FILE" 2>&1
log "CPU: $(grep "model name" /proc/cpuinfo | head -n1 | cut -d':' -f2 | sed 's/^ *//')"
log "Memory: $(free -h | grep "Mem:" | awk '{print $2}')"
log "Disk space: $(df -h / | awk 'NR==2 {print $4}') free on /"

# Check for root privileges
if [ "$EUID" -ne 0 ]; then
    log "ERROR: This script must be run as root"
    exit 1
fi

# System update
log "Updating system packages..."
apt update -y >> "$LOG_FILE" 2>&1
apt upgrade -y >> "$LOG_FILE" 2>&1

# Install required packages
log "Installing essential system packages and network tools..."
apt install -y curl git wget htop net-tools iptables iputils-ping traceroute nmap tcpdump nftables \
    netcat-openbsd dnsutils whois vim nano rsync zip unzip xz-utils sqlite3 \
    apt-transport-https ca-certificates gnupg lsb-release >> "$LOG_FILE" 2>&1

# Install Docker using the official Docker repository
log "Installing Docker from official repository..."
if ! command_exists docker; then
    # Remove any old Docker versions
    apt remove -y docker docker-engine docker.io containerd runc >> "$LOG_FILE" 2>&1 || true
    
    # Add Docker's official GPG key
    curl -fsSL https://download.docker.com/linux/debian/gpg | gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg >> "$LOG_FILE" 2>&1
    
    # Set up the stable repository
    echo \
      "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] \
      https://download.docker.com/linux/debian \
      $(lsb_release -cs) stable" | tee /etc/apt/sources.list.d/docker.list > /dev/null
    
    # Update apt and install Docker
    apt update -y >> "$LOG_FILE" 2>&1
    apt install -y docker-ce docker-ce-cli containerd.io >> "$LOG_FILE" 2>&1
    
    # Install Docker Compose
    log "Installing Docker Compose..."
    curl -L "https://github.com/docker/compose/releases/download/v2.20.3/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose >> "$LOG_FILE" 2>&1
    chmod +x /usr/local/bin/docker-compose >> "$LOG_FILE" 2>&1
    ln -sf /usr/local/bin/docker-compose /usr/bin/docker-compose >> "$LOG_FILE" 2>&1
else
    log "Docker already installed: $(docker --version)"
    log "Docker Compose already installed: $(docker-compose --version)"
fi

# Install Node.js 20.x
if ! command_exists node || [ $(node -v | cut -d. -f1 | tr -d 'v') -lt 20 ]; then
    log "Installing Node.js 20.x..."
    curl -fsSL https://deb.nodesource.com/setup_20.x | bash - >> "$LOG_FILE" 2>&1
    apt install -y nodejs >> "$LOG_FILE" 2>&1
    log "Node.js $(node -v) installed"
else
    log "Node.js $(node -v) already installed"
fi

# Install pnpm
if ! command_exists pnpm; then
    log "Installing pnpm package manager..."
    # Install pnpm globally to avoid home directory permission issues
    npm install -g pnpm >> "$LOG_FILE" 2>&1
    # Fallback method in case npm method fails
    if ! command_exists pnpm; then
        log "Trying alternative pnpm installation method..."
        curl -fsSL https://get.pnpm.io/install.sh | bash - >> "$LOG_FILE" 2>&1
        export PATH="$HOME/.local/share/pnpm:$PATH"
    fi
    log "pnpm $(pnpm --version) installed"
else
    log "pnpm $(pnpm --version) already installed"
fi

# Add pnpm to PATH for this script session
export PATH="$HOME/.local/share/pnpm:$PATH"
export PNPM_HOME="$HOME/.local/share/pnpm"

# Enable and start Docker
log "Ensuring Docker is running..."
systemctl enable docker >> "$LOG_FILE" 2>&1
systemctl start docker >> "$LOG_FILE" 2>&1

# Configure Docker for multi-architecture builds
log "Setting up Docker for multi-architecture builds..."
if ! docker buildx ls | grep -q "default"; then
    docker buildx create --name mybuilder --use >> "$LOG_FILE" 2>&1
    log "Docker buildx configured"
else
    log "Docker buildx already configured"
fi

# Make sure we have the docker directory for configuration
mkdir -p "$SCRIPT_DIR/docker/caddy"

# Check if Caddyfile exists
if [ ! -f "$SCRIPT_DIR/docker/caddy/Caddyfile" ]; then
    log "Creating Caddyfile template..."
    cat > "$SCRIPT_DIR/docker/caddy/Caddyfile" << EOF
# Caddyfile for MYP Frontend
# Replace example.com with your actual domain

:80 {
    # Automatic HTTPS will be enabled if you use a domain name
    # For local development or internal network, HTTP is fine
    
    # Reverse proxy to frontend app
    reverse_proxy frontend:3000
    
    # Basic headers for security
    header {
        # Enable HSTS
        Strict-Transport-Security "max-age=31536000; includeSubDomains; preload"
        # Enable XSS protection
        X-XSS-Protection "1; mode=block"
        # Prevent content type sniffing
        X-Content-Type-Options "nosniff"
        # Clickjacking protection
        X-Frame-Options "SAMEORIGIN"
        # Allow backend API access (CORS)
        Access-Control-Allow-Origin "http://192.168.0.105:5000"
        Access-Control-Allow-Methods "GET, POST, PUT, DELETE, OPTIONS"
        Access-Control-Allow-Headers "Origin, Content-Type, Accept, Authorization"
        Access-Control-Allow-Credentials "true"
    }
    
    # Log access
    log {
        output file /var/log/caddy/access.log
    }
}
EOF
    log "Caddyfile created. Edit it to configure your domain if needed."
fi

# Create GitHub OAuth credentials file
if [ ! -d "/srv/myp-env" ]; then
    log "Creating directory for environment variables..."
    mkdir -p /srv/myp-env
fi

if [ ! -f "/srv/myp-env/github.env" ]; then
    log "Creating GitHub OAuth credentials file with static backend URL..."
    cat > /srv/myp-env/github.env << EOF
# GitHub OAuth Credentials
# Replace these with your actual GitHub OAuth app credentials

AUTH_GITHUB_ID=your_github_client_id
AUTH_GITHUB_SECRET=your_github_client_secret
AUTH_SECRET=$(openssl rand -hex 32)
AUTH_TRUST_HOST=true
NEXT_PUBLIC_BACKEND_URL=http://192.168.0.105:5000

# Add additional environment variables as needed
EOF
    log "ATTENTION: GitHub OAuth credentials file created with generated AUTH_SECRET"
    log "           Backend URL set to http://192.168.0.105:5000"
    log "           Please edit /srv/myp-env/github.env with your actual GitHub OAuth app credentials"
fi

# Create a copy of the environment file in the git repository
log "Creating a copy of the environment file for version control..."
if [ ! -f "$SCRIPT_DIR/.env.example" ]; then
    cat > "$SCRIPT_DIR/.env.example" << EOF
# GitHub OAuth Credentials Example
# This is a template for the required environment variables

AUTH_GITHUB_ID=your_github_client_id
AUTH_GITHUB_SECRET=your_github_client_secret
AUTH_SECRET=random_string_generated_during_installation
AUTH_TRUST_HOST=true
NEXT_PUBLIC_BACKEND_URL=http://192.168.0.105:5000

# Add additional environment variables as needed
EOF
    log "Environment example file created at $SCRIPT_DIR/.env.example"
fi

# Create database directory if it doesn't exist
log "Setting up database directory..."
mkdir -p /srv/MYP-DB

# Determine if we should run in non-interactive mode
if [ -n "$1" ] && [ "$1" == "--auto-production" ]; then
    log "Running in automatic production mode (non-interactive)..."
    production_mode="y"
elif [ -n "$1" ] && [ "$1" == "--auto-development" ]; then
    log "Running in automatic development mode (non-interactive)..."
    production_mode="n"
else
    # Interactive mode
    log "Running in interactive mode..."
    # Check if we need to run in development or production mode
    read -p "Do you want to set up the frontend in production mode? (y/n): " production_mode
fi

if [ "$production_mode" = "y" ] || [ "$production_mode" = "Y" ]; then
    # Production mode - using Docker
    log "Setting up in production mode using Docker..."
    
    # Create docker-compose file if it doesn't exist
    if [ ! -f "$SCRIPT_DIR/docker/compose.yml" ]; then
        log "Creating docker-compose.yml file with network configuration..."
        cat > "$SCRIPT_DIR/docker/compose.yml" << EOF
version: '3.8'

services:
  frontend:
    image: myp-rp:latest
    restart: unless-stopped
    environment:
      - NODE_ENV=production
    env_file:
      - /srv/myp-env/github.env
    volumes:
      - /srv/MYP-DB:/app/.next/cache/drizzle
    networks:
      - myp-network
      - backend-network  # Network for communicating with backend
    
  caddy:
    image: caddy:2.8
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./caddy/Caddyfile:/etc/caddy/Caddyfile
      - caddy_data:/data
      - caddy_config:/config
    networks:
      - myp-network
    depends_on:
      - frontend

networks:
  myp-network:
    driver: bridge
  backend-network:  # Network for connecting to the backend at 192.168.0.105
    driver: bridge
    ipam:
      config:
        - subnet: 192.168.0.0/24
          gateway: 192.168.0.1

volumes:
  caddy_data:
  caddy_config:
EOF
        log "docker-compose.yml created with backend network configuration"
    fi
    
    # Build Docker image with error handling
    log "Building Docker image (this may take a while)..."
    
    # Check available disk space before starting build
    available_space=$(df -m / | awk 'NR==2 {print $4}')
    if [ "$available_space" -lt 2000 ]; then
        log "WARNING: Low disk space (${available_space}MB). Docker build may fail."
        log "Consider freeing up at least 2GB of space before continuing."
        read -p "Continue anyway? (y/n): " continue_build
        if [ "$continue_build" != "y" ] && [ "$continue_build" != "Y" ]; then
            log "Docker build aborted due to low disk space."
            exit 1
        fi
    fi
    
    # Test Docker is working properly
    if ! docker info >> "$LOG_FILE" 2>&1; then
        log "ERROR: Docker is not running or the current user doesn't have permission to use Docker."
        log "Try running 'sudo systemctl restart docker' or add your user to the docker group with:"
        log "'sudo usermod -aG docker $USER' and then log out and back in."
        exit 1
    fi
    
    # Try to use existing build script if available
    if [ -f "$SCRIPT_DIR/docker/build.sh" ]; then
        log "Using existing build script..."
        cd "$SCRIPT_DIR/docker"
        if bash build.sh >> "$LOG_FILE" 2>&1; then
            log "Docker image built successfully using build.sh"
        else
            log "ERROR: Docker build failed using build.sh script"
            log "Attempting direct build as fallback..."
            cd "$SCRIPT_DIR"
            if docker build -t myp-rp:latest . >> "$LOG_FILE" 2>&1; then
                log "Docker image built successfully using direct method"
            else
                log "ERROR: Docker build failed. Check the log at $LOG_FILE for details."
                exit 1
            fi
        fi
    else
        # Direct build method
        log "Building Docker image manually..."
        cd "$SCRIPT_DIR"
        if docker build -t myp-rp:latest . >> "$LOG_FILE" 2>&1; then
            log "Docker image built successfully"
        else
            log "ERROR: Docker build failed. Check the log at $LOG_FILE for details."
            exit 1
        fi
    fi
    
    # Verify the image was created
    if docker image inspect myp-rp:latest >> /dev/null 2>&1; then
        log "Verified: Docker image myp-rp:latest exists"
    else
        log "ERROR: Docker image myp-rp:latest does not exist after build"
        exit 1
    fi
    
    # Start the application with error handling
    log "Starting the application using Docker Compose..."
    cd "$SCRIPT_DIR/docker"
    
    # Ensure we have the compose file
    if [ ! -f "compose.yml" ]; then
        log "ERROR: compose.yml not found in $(pwd)"
        log "Looking for compose file in alternative locations..."
        find "$SCRIPT_DIR" -name "compose.yml" -o -name "docker-compose.yml" 2>/dev/null | while read compose_file; do
            log "Found compose file at: $compose_file"
        done
        exit 1
    fi
    
    # Test docker-compose to make sure it's working
    if ! docker-compose version >> "$LOG_FILE" 2>&1; then
        log "WARNING: docker-compose command failed. Trying with docker compose (with space)..."
        if ! docker compose version >> "$LOG_FILE" 2>&1; then
            log "ERROR: Both docker-compose and docker compose commands failed."
            log "Please check Docker and Docker Compose installation."
            exit 1
        else
            # Use docker compose instead
            log "Using docker compose (with space) command..."
            if docker compose -f compose.yml up -d >> "$LOG_FILE" 2>&1; then
                log "Application started successfully with docker compose!"
            else
                log "ERROR: Failed to start application with docker compose."
                log "Check logs with: docker compose -f compose.yml logs"
                exit 1
            fi
        fi
    else
        # Use docker-compose
        if docker-compose -f compose.yml up -d >> "$LOG_FILE" 2>&1; then
            log "Application started successfully with docker-compose!"
        else
            log "ERROR: Failed to start application with docker-compose."
            log "Check logs with: docker-compose -f compose.yml logs"
            exit 1
        fi
    fi
    
    # Verify containers are running
    log "Verifying containers are running..."
    sleep 5 # Give containers a moment to start
    
    running_containers=$(docker ps --format '{{.Names}}' | grep -c "myp\|frontend\|caddy" || echo "0")
    if [ "$running_containers" -gt 0 ]; then
        log "Detected $running_containers running containers related to MYP."
    else
        log "WARNING: No running containers detected for MYP frontend."
        log "Check container status with: docker ps -a"
    fi
    
    log "Frontend installed and running in production mode!"
    log "The application should be accessible at http://localhost"
    log "Check logs with: docker-compose -f $SCRIPT_DIR/docker/compose.yml logs -f"
    
else
    # Development mode
    log "Setting up in development mode..."
    
    # Install dependencies
    log "Installing project dependencies with pnpm..."
    cd "$SCRIPT_DIR"
    
    # Make sure we're in the right directory and pnpm is available
    log "Current directory: $(pwd)"
    log "Checking pnpm path: $(which pnpm 2>/dev/null || echo 'pnpm not found in PATH')"
    
    # Install dependencies with retry mechanism
    max_attempts=3
    attempt=1
    success=false
    
    while [ $attempt -le $max_attempts ] && [ "$success" = "false" ]; do
        log "Attempt $attempt of $max_attempts to install dependencies..."
        
        if command_exists pnpm; then
            if pnpm install >> "$LOG_FILE" 2>&1; then
                log "Dependencies installed successfully!"
                success=true
            else
                log "WARNING: pnpm install failed on attempt $attempt"
            fi
        else
            log "ERROR: pnpm not found in PATH. Trying to fix..."
            export PATH="$PATH:$HOME/.local/share/pnpm:$HOME/.pnpm:$(npm global bin)"
            if ! command_exists pnpm; then
                log "Attempting to reinstall pnpm..."
                npm install -g pnpm >> "$LOG_FILE" 2>&1
            fi
        fi
        
        attempt=$((attempt+1))
        
        # If we've failed but have more attempts to go, wait a bit before trying again
        if [ "$success" = "false" ] && [ $attempt -le $max_attempts ]; then
            log "Waiting 5 seconds before retry..."
            sleep 5
        fi
    done
    
    if [ "$success" = "false" ]; then
        log "ERROR: Failed to install dependencies after $max_attempts attempts."
        log "Please check the log file at $LOG_FILE for details."
        log "You may need to run 'pnpm install' manually in $SCRIPT_DIR"
    else
        log "Dependencies successfully installed."
    fi
    
    # Create .env.local file for development
    if [ ! -f "$SCRIPT_DIR/.env.local" ]; then
        log "Creating development environment file with static backend URL..."
        cat > "$SCRIPT_DIR/.env.local" << EOF
# Development Environment Variables

# GitHub OAuth
AUTH_GITHUB_ID=your_github_client_id
AUTH_GITHUB_SECRET=your_github_client_secret
AUTH_SECRET=$(openssl rand -hex 32)
AUTH_TRUST_HOST=true

# Backend URL - Static IP for backend
NEXT_PUBLIC_BACKEND_URL=http://192.168.0.105:5000
EOF
        log "ATTENTION: Development environment file created with generated AUTH_SECRET"
        log "           Backend URL set to http://192.168.0.105:5000"
        log "           Please edit $SCRIPT_DIR/.env.local with your actual GitHub OAuth credentials"
    fi
    
    # Create systemd service for development mode
    log "Creating systemd service for development mode..."
    cat > /etc/systemd/system/myp-frontend-dev.service << EOF
[Unit]
Description=MYP Frontend Development Service
After=network.target

[Service]
Type=simple
User=$SUDO_USER
WorkingDirectory=$SCRIPT_DIR
ExecStart=$(which pnpm) dev
Restart=always
RestartSec=10
Environment=PATH=/usr/bin:/usr/local/bin:$HOME/.local/share/pnpm

[Install]
WantedBy=multi-user.target
EOF
    
    # Reload systemd and enable the service
    systemctl daemon-reload
    systemctl enable myp-frontend-dev.service
    
    log "Installation complete!"
    log ""
    log "To start the frontend development service, run: systemctl start myp-frontend-dev"
    log "To check service status, run: systemctl status myp-frontend-dev"
    log "To view logs, run: journalctl -u myp-frontend-dev -f"
    log ""
    log "For manual development startup, run: cd $SCRIPT_DIR && pnpm dev"
    log ""
    log "The application should be accessible at http://localhost:3000 when running"
fi

log "For issues, check the log file at: $LOG_FILE"
# Add helpful commands for post-installation management
log "===== Post-Installation Information ====="
log "Here are some helpful commands for managing your installation:"
log ""
log "System management:"
log "  - Check system status: htop, free -h, df -h"
log "  - Network status: ip a, netstat -tulpn, ss -tulpn"
log "  - View logs: tail -f /var/log/syslog, journalctl -f"
log ""
log "Docker management:"
log "  - List containers: docker ps -a"
log "  - Container logs: docker logs <container_id>"
log "  - Stop containers: docker-compose -f $SCRIPT_DIR/docker/compose.yml down"
log "  - Start containers: docker-compose -f $SCRIPT_DIR/docker/compose.yml up -d"
log "  - Restart containers: docker-compose -f $SCRIPT_DIR/docker/compose.yml restart"
log ""
log "Backend connection:"
log "  - Test backend connection: curl -I http://192.168.0.105:5000/api/test"
log "  - Check backend accessibility: ping 192.168.0.105"
log ""
log "Installation Complete! 🎉"