#!/bin/sh
# Senate One-Click Installer
# Usage: sh -c "$(curl -sSL https://get.senate.sh)"
#        sh -c "$(curl -sSL https://get.senate.sh)" -- --version latest
#        sh -c "$(curl -sSL https://get.senate.sh)" -- --version v1.2.3
#
# Options:
#   --version, -v <tag>   Docker image tag to install (default: stable)
#                         Examples: stable, latest, v1.2.3
#
# This script will:
# 1. Check if running as root
# 2. Check if Docker is installed
# 3. Offer to install Docker if not present
# 4. Pull and run the Senate container

set -e

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

# Default version
SENATE_VERSION="stable"

# Parse command line arguments
while [ $# -gt 0 ]; do
    case "$1" in
        --version|-v)
            if [ -n "$2" ] && [ "${2#-}" = "$2" ]; then
                SENATE_VERSION="$2"
                shift 2
            else
                printf "${RED}[ERROR]${NC} --version requires a value (e.g., stable, latest, v1.2.3)\n"
                exit 1
            fi
            ;;
        --help|-h)
            printf "Senate Installer\n\n"
            printf "Usage: sh -c \"\$(curl -sSL https://get.senate.sh)\" -- [OPTIONS]\n\n"
            printf "Options:\n"
            printf "  --version, -v <tag>   Docker image tag (default: stable)\n"
            printf "                        Examples: stable, latest, v1.2.3\n"
            printf "  --help, -h            Show this help message\n"
            exit 0
            ;;
        --)
            shift
            ;;
        *)
            printf "${RED}[ERROR]${NC} Unknown option: %s\n" "$1"
            printf "Use --help for usage information.\n"
            exit 1
            ;;
    esac
done

# Senate container configuration
SENATE_IMAGE="senatestack/senate:${SENATE_VERSION}"
SENATE_CONTAINER_NAME="senate"
SENATE_PORT="2999"
SENATE_DATA_VOLUME="senate-data"
SENATE_FILE_VOLUME="senate-file"
SENATE_NETWORK="senate"

# Print colored output
print_info() {
    printf "${BLUE}[INFO]${NC} %s\n" "$1"
}

print_success() {
    printf "${GREEN}[SUCCESS]${NC} %s\n" "$1"
}

print_warning() {
    printf "${YELLOW}[WARNING]${NC} %s\n" "$1"
}

print_error() {
    printf "${RED}[ERROR]${NC} %s\n" "$1"
}

# Print banner
print_banner() {
    printf "${BLUE}"
    cat << 'EOF'
   __  ___ __  _  __ _____ ___  
 /' _/| __|  \| |/  \_   _| __| 
 `._`.| _|| | ' | /\ || | | _|  
 |___/|___|_|\__|_||_||_| |___| 
                                  
 Self-hosted PaaS - Your Own Cloud
EOF
    printf "${NC}\n"
}

# Check if running as root
check_root() {
    if [ "$(id -u)" -ne 0 ]; then
        print_error "This script must be run as root or with sudo"
        print_info "Please run: sudo sh -c \"\$(curl -sSL https://get.senate.sh)\""
        exit 1
    fi
}

# Check if Docker is installed
check_docker() {
    if command -v docker >/dev/null 2>&1; then
        return 0
    else
        return 1
    fi
}

# Check if Docker daemon is running
check_docker_running() {
    if docker info >/dev/null 2>&1; then
        return 0
    else
        return 1
    fi
}

# Install Docker using official script
install_docker() {
    print_info "Docker is not installed on this system."
    printf "\n"
    printf "Would you like to install Docker? [Y/n] "
    read -r response
    
    case "$response" in
        [nN][oO]|[nN])
            print_error "Docker is required to run Senate. Exiting."
            exit 1
            ;;
        *)
            print_info "Installing Docker..."
            curl -fsSL https://get.docker.com | sh
            
            # Start Docker service
            if command -v systemctl >/dev/null 2>&1; then
                systemctl start docker
                systemctl enable docker
            fi
            
            print_success "Docker installed successfully!"
            ;;
    esac
}

# Ensure the Senate Docker network exists
ensure_network() {
    if ! docker network inspect "$SENATE_NETWORK" >/dev/null 2>&1; then
        print_info "Creating Docker network: $SENATE_NETWORK"
        docker network create "$SENATE_NETWORK"
        print_success "Network created."
    fi
}

# Check if Senate container already exists
check_existing_container() {
    if docker ps -a --format '{{.Names}}' | grep -q "^${SENATE_CONTAINER_NAME}$"; then
        return 0
    else
        return 1
    fi
}

# Stop and remove existing Senate container
remove_existing_container() {
    print_warning "Existing Senate container found."
    printf "Would you like to remove it and install fresh? [Y/n] "
    read -r response
    
    case "$response" in
        [nN][oO]|[nN])
            print_info "Keeping existing container. Exiting."
            exit 0
            ;;
        *)
            print_info "Stopping and removing existing container..."
            docker stop "$SENATE_CONTAINER_NAME" >/dev/null 2>&1 || true
            docker rm "$SENATE_CONTAINER_NAME" >/dev/null 2>&1 || true
            print_success "Existing container removed."
            ;;
    esac
}

# Run Senate container
run_senate() {
    print_info "Installing Senate version: ${SENATE_VERSION}"
    print_info "Pulling Senate image..."
    docker pull "$SENATE_IMAGE"
    
    print_info "Starting Senate container..."
    docker run -d \
        --name "$SENATE_CONTAINER_NAME" \
        --network "$SENATE_NETWORK" \
        -p "${SENATE_PORT}:2999" \
        -v /var/run/docker.sock:/var/run/docker.sock \
        -v "${SENATE_DATA_VOLUME}:/app/pb_data" \
        -v "${SENATE_FILE_VOLUME}:/root/.senate" \
        --restart unless-stopped \
        "$SENATE_IMAGE"
    
    print_success "Senate is now running!"
}

# Print success message with access info
print_access_info() {
    printf "\n"
    print_success "Installation complete!"
    printf "\n"
    printf "  Access Senate at: ${GREEN}http://localhost:${SENATE_PORT}${NC}\n"
    printf "  Or use your server IP: ${GREEN}http://<your-ip>:${SENATE_PORT}${NC}\n"
    printf "\n"
    printf "  Version:        ${BLUE}${SENATE_VERSION}${NC}\n"
    printf "  Container name: ${BLUE}${SENATE_CONTAINER_NAME}${NC}\n"
    printf "  Data volume:    ${BLUE}${SENATE_DATA_VOLUME}${NC}\n"
    printf "  Files volume:   ${BLUE}${SENATE_FILE_VOLUME}${NC}\n"
    printf "\n"
    printf "  Useful commands:\n"
    printf "    View logs:    ${YELLOW}docker logs -f ${SENATE_CONTAINER_NAME}${NC}\n"
    printf "    Stop:         ${YELLOW}docker stop ${SENATE_CONTAINER_NAME}${NC}\n"
    printf "    Start:        ${YELLOW}docker start ${SENATE_CONTAINER_NAME}${NC}\n"
    printf "    Uninstall:    ${YELLOW}docker rm -f ${SENATE_CONTAINER_NAME}${NC}\n"
    printf "\n"
}

# Main function
main() {
    print_banner
    
    # Check root
    check_root
    
    # Check Docker
    if ! check_docker; then
        install_docker
    fi
    
    # Check Docker is running
    if ! check_docker_running; then
        print_error "Docker is installed but not running."
        print_info "Please start Docker and try again."
        exit 1
    fi
    
    print_success "Docker is installed and running."
    
    # Ensure network exists
    ensure_network
    
    # Check for existing container
    if check_existing_container; then
        remove_existing_container
    fi
    
    # Run Senate
    run_senate
    
    # Print access info
    print_access_info
}

# Run main
main