#!/bin/bash
# New Setuper script for A/D Infrastructure
# Downloads Packmate, moded_distructive_farm, Firegex OUTSIDE SERVICES_DIR, starts them, then starts all game services from SERVICES_DIR, and registers only Packmate and Firegex with controller.

set +e

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
ROOT_DIR="$SCRIPT_DIR/.."

# Read .env for SERVICES_DIR, CONTROLLER_API, SECRET_TOKEN
ENV_FILE="$ROOT_DIR/.env"
if [ ! -f "$ENV_FILE" ]; then
    echo ".env file not found in $ROOT_DIR. Exiting."
    exit 1
fi

SERVICES_DIR=$(grep '^SERVICES_DIR=' "$ENV_FILE" | cut -d'=' -f2- | tr -d '"')
CONTROLLER_API=$(grep '^CONTROLLER_API=' "$ENV_FILE" | cut -d'=' -f2- | tr -d '"')
SECRET_TOKEN=$(grep '^SECRET_TOKEN=' "$ENV_FILE" | cut -d'=' -f2- | tr -d '"')

# Defaults
CONTROLLER_API="${CONTROLLER_API:-http://localhost:8001}"
SECRET_TOKEN="${SECRET_TOKEN:-change-me-in-production}"

echo "=== A/D Infrastructure Setuper (NEW) ==="
echo "Game services directory: $SERVICES_DIR"
echo ""

# Function to call controller API
call_api() {
    local endpoint="$1"
    local method="${2:-GET}"
    local data="${3:-}"
    if [ "$method" = "POST" ]; then
        curl -s -X POST "$CONTROLLER_API$endpoint" \
            -H "Authorization: Bearer $SECRET_TOKEN" \
            -H "Content-Type: application/json" \
            -d "$data"
    else
        curl -s "$CONTROLLER_API$endpoint" \
            -H "Authorization: Bearer $SECRET_TOKEN"
    fi
}

# Function to setup and start Packmate
setup_packmate() {
    echo "=== Setting up Packmate ==="
    local packmate_dir="$ROOT_DIR/packmate"
    if [ -d "$packmate_dir" ]; then
        echo "Packmate directory already exists, updating..."
        cd "$packmate_dir"
        git pull
        git submodule update --init --recursive
    else
        echo "Cloning Packmate with submodules..."
        git clone --recursive https://gitlab.com/packmate/Packmate.git "$packmate_dir"
        cd "$packmate_dir"
    fi
    mkdir -p pcaps rsa_keys Packmate_stuff
    # .env and config generation (minimal)
    cat > .env <<'ENVEOF'
BUILD_TAG=latest
PACKMATE_DB_PASSWORD=K604YnL3G1hp2RDkCZNjGpxbyNpNHTRb
NET_INTERFACE=eth0
PACKMATE_LOCAL_IP=10.60.0.1
WEB_LOGIN=admin
WEB_PASSWORD=admin123
ENVEOF
    cat > Packmate_stuff/postgresql.conf <<'PGEOF'
port = 65001
max_connections = 100
shared_buffers = 128MB
PGEOF
    cat > Packmate_stuff/update_db_config.sh <<'SHEOF'
#!/bin/bash
cp /tmp/postgresql.conf /var/lib/postgresql/data/postgresql.conf
SHEOF
    chmod +x Packmate_stuff/update_db_config.sh
    # docker-compose.yml (minimal)
    cat > docker-compose.yml <<'DCEOF'
version: '3.8'
services:
  packmate:
    environment:
      DB_PASSWORD: ${PACKMATE_DB_PASSWORD:-K604YnL3G1hp2RDkCZNjGpxbyNpNHTRb}
      INTERFACE: ${NET_INTERFACE:-}
      LOCAL_IP: ${PACKMATE_LOCAL_IP}
      MODE: LIVE
      WEB_LOGIN: ${WEB_LOGIN:-admin}
      WEB_PASSWORD: ${WEB_PASSWORD:-admin123}
      OLD_STREAMS_CLEANUP_ENABLED: true
      OLD_STREAMS_CLEANUP_INTERVAL: 5
      OLD_STREAMS_CLEANUP_THRESHOLD: 240
    env_file:
      - .env
    container_name: packmate-app
    network_mode: "host"
    image: registry.gitlab.com/packmate/packmate:${BUILD_TAG:-latest}
    volumes:
      - "./pcaps/:/app/pcaps/:ro"
      - "./rsa_keys/:/app/rsa_keys/:ro"
    depends_on:
      db:
        condition: service_healthy
  db:
    container_name: packmate-db
    environment:
      POSTGRES_USER: packmate
      POSTGRES_PASSWORD: ${PACKMATE_DB_PASSWORD:-K604YnL3G1hp2RDkCZNjGpxbyNpNHTRb}
      POSTGRES_DB: packmate
    network_mode: "host"
    image: postgres:15.2
    volumes:
      - "./Packmate_stuff/postgresql.conf:/tmp/postgresql.conf:ro"
      - "./Packmate_stuff/update_db_config.sh:/docker-entrypoint-initdb.d/_update_db_config.sh:ro"
    healthcheck:
      test: [ "CMD-SHELL", "pg_isready -U packmate -p 65001" ]
      interval: 2s
      timeout: 5s
      retries: 15
DCEOF
    echo "Starting Packmate containers..."
    docker compose up -d
    echo "Registering Packmate with controller..."
    call_api "/services" "POST" "{\"name\": \"packmate\", \"path\": \"$packmate_dir\", \"git_url\": \"https://gitlab.com/packmate/Packmate.git\"}"
    cd "$SCRIPT_DIR"
}

# Function to setup and start moded_distructive_farm
setup_farm() {
    echo "=== Setting up moded_distructive_farm ==="
    local farm_dir="$ROOT_DIR/moded_distructive_farm"
    if [ -d "$farm_dir" ]; then
        echo "Farm directory already exists, updating..."
        cd "$farm_dir"
        git pull
    else
        echo "Cloning moded_distructive_farm..."
        git clone https://github.com/ilyastar9999/moded_distructive_farm.git "$farm_dir"
        cd "$farm_dir"
    fi
    cat > .env <<'ENVEOF'
DB_PORT=5432
DB_HOST=postgres
DB_USER=farm
DB_PASS=farmpassword123
DB_NAME=farm
BOARD_URL=http://10.60.0.1
TEAM_TOKEN=your-team-token
WEB_PASSWORD=farmadmin
NUM_TEAMS=10
IP_TEAM_BASE=10.60.
API_TOKEN=farm-api-token-123
ENVEOF
    cat > docker-compose.yml <<'DCEOF'
version: '3.8'
services:
  farm:
    image: ghcr.io/ilyastar9999/moded_distructive_farm:latest
    depends_on:
      postgres:
        condition: service_healthy
    environment:
      - DB_PORT=${DB_PORT}
      - DB_HOST=${DB_HOST}
      - DB_USER=${DB_USER}
      - DB_PASS=${DB_PASS}
      - DB_NAME=${DB_NAME}
      - BOARD_URL=${BOARD_URL}
      - TEAM_TOKEN=${TEAM_TOKEN}
      - WEB_PASSWORD=${WEB_PASSWORD}
      - NUM_TEAMS=${NUM_TEAMS}
      - IP_TEAM_BASE=${IP_TEAM_BASE}
      - API_TOKEN=${API_TOKEN}
    env_file:
      - .env
    container_name: farm-app
    restart: always
    ports:
      - "3333:8000"
  postgres:
    image: postgres:18
    environment:
      - POSTGRES_USER=${DB_USER}
      - POSTGRES_PASSWORD=${DB_PASS}
      - POSTGRES_DB=${DB_NAME}
    healthcheck:
      test: pg_isready -U ${DB_USER} -d ${DB_NAME}
      interval: 10s
      timeout: 3s
      retries: 3
    volumes:
      - farm-db:/var/lib/postgresql/data
volumes:
  farm-db:
DCEOF
    echo "Starting moded_distructive_farm containers..."
    docker compose up -d
    cd "$SCRIPT_DIR"
}

# Function to setup and start Firegex
setup_firegex() {
    echo "=== Setting up Firegex ==="
    local firegex_dir="$ROOT_DIR/firegex"
    if [ -d "$firegex_dir" ]; then
        echo "Firegex directory already exists, updating..."
        cd "$firegex_dir"
        git pull
    else
        echo "Cloning Firegex..."
        git clone https://github.com/Pwnzer0tt1/firegex.git "$firegex_dir"
        cd "$firegex_dir"
    fi
    cat > .env <<'ENVEOF'
TEAM_TOKEN=your-team-token
SCOREBOARD_URL=http://10.60.0.1
FIREGEX_PORT=5000
ENVEOF
    if [ ! -f "docker-compose.yml" ]; then
        cat > docker-compose.yml <<'DCEOF'
version: '3.8'
services:
  firegex:
    build: .
    env_file:
      - .env
    environment:
      - TEAM_TOKEN=${TEAM_TOKEN}
      - SCOREBOARD_URL=${SCOREBOARD_URL}
    container_name: firegex-app
    restart: always
    ports:
      - "${FIREGEX_PORT:-5000}:5000"
DCEOF
    fi
    echo "Starting Firegex containers..."
    docker compose up -d
    echo "Registering Firegex with controller..."
    call_api "/services" "POST" "{\"name\": \"firegex\", \"path\": \"$firegex_dir\", \"git_url\": \"https://github.com/Pwnzer0tt1/firegex.git\"}"
    cd "$SCRIPT_DIR"
}

# Start all game services from SERVICES_DIR
start_game_services() {
    echo "=== Starting all game services from $SERVICES_DIR ==="
    if [ -f "$SERVICES_DIR/docker-compose.yml" ]; then
        cd "$SERVICES_DIR"
        docker compose up -d
        cd "$SCRIPT_DIR"
    else
        echo "No docker-compose.yml found in $SERVICES_DIR, skipping game services startup."
    fi
}

# Main setup flow
main() {
    echo "Starting setup process..."
    echo ""
    read -p "Setup Packmate? (y/n): " setup_pm
    read -p "Setup moded_distructive_farm? (y/n): " setup_fm
    read -p "Setup Firegex? (y/n): " setup_fg
    echo ""
    if [ "$setup_pm" = "y" ]; then
        setup_packmate
    fi
    if [ "$setup_fm" = "y" ]; then
        setup_farm
    fi
    if [ "$setup_fg" = "y" ]; then
        setup_firegex
    fi
    start_game_services
    echo ""
    echo "=== Setup Complete! ==="
    echo "Game services have been started from: $SERVICES_DIR"
    echo ""
    echo "Next steps:"
    echo "  1. Access web dashboard: http://localhost:8000"
    echo "  2. Register services via the dashboard if auto-registration failed"
    echo ""
}

if [ "${BASH_SOURCE[0]}" = "${0}" ]; then
    main
fi