#!/bin/bash

# Fungsi untuk warna
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
CYAN='\033[0;36m'
NC='\033[0m' # No Color

# Fungsi untuk menampilkan pesan
error() {
    echo -e "${RED}[ERROR]${NC} $1" > /dev/tty
}

success() {
    echo -e "${GREEN}[SUCCESS]${NC} $1" > /dev/tty
}

info() {
    echo -e "${BLUE}[INFO]${NC} $1" > /dev/tty
}

warning() {
    echo -e "${YELLOW}[WARNING]${NC} $1" > /dev/tty
}

# Deteksi platform
PLATFORM="linux"
if [ -n "${TERMUX_VERSION:-}" ] || [ -d "/data/data/com.termux/files/usr" ]; then
    PLATFORM="termux"
elif [ -f /etc/os-release ] && grep -qiE 'ubuntu|debian' /etc/os-release; then
    PLATFORM="ubuntu"
fi

ARCH="$(uname -m)"
info "Architecture detected: $ARCH"
case "${PLATFORM}:${ARCH}" in
    termux:aarch64|termux:arm64) ;;
    ubuntu:x86_64|ubuntu:amd64|linux:x86_64|linux:amd64) ;;
    *)
        error "Unsupported architecture for this platform."
        exit 1
        ;;
esac

if [ "$PLATFORM" = "termux" ]; then
    BASHRC_FILE="/data/data/com.termux/files/usr/etc/bash.bashrc"
else
    BASHRC_FILE="$HOME/.bashrc"
fi

ensure_sudo() {
    if [ "$(id -u)" -ne 0 ]; then
        if command -v sudo >/dev/null 2>&1; then
            SUDO="sudo"
        else
            error "Perintah ini membutuhkan akses root. Jalankan sebagai root atau install sudo."
            exit 1
        fi
    fi
}

apt_cmd() {
    if ! command -v apt-get >/dev/null 2>&1; then
        error "apt-get tidak ditemukan. Script ini fokus untuk Ubuntu/Debian."
        exit 1
    fi
    if [ -n "$SUDO" ]; then
        $SUDO env DEBIAN_FRONTEND=noninteractive apt-get "$@"
    else
        env DEBIAN_FRONTEND=noninteractive apt-get "$@"
    fi
}

update_packages() {
    if [ "$PLATFORM" = "termux" ]; then
        if [ -t 0 ]; then
            pkg update
            pkg upgrade
        else
            yes | pkg update && yes | pkg upgrade
        fi
    else
        ensure_sudo
        apt_cmd update
        apt_cmd upgrade -y
    fi
}

install_packages() {
    if [ "$PLATFORM" = "termux" ]; then
        yes | pkg install libjansson wget nano git
    else
        ensure_sudo
        apt_cmd install -y libjansson4 wget nano curl git
    fi
}

setup_systemd_service() {
    if [ "$PLATFORM" = "termux" ]; then
        return
    fi
    if ! command -v systemctl >/dev/null 2>&1 || [ ! -d /run/systemd/system ]; then
        warning "Systemd tidak terdeteksi. Lewati setup service."
        return
    fi
    ensure_sudo
    RUN_USER="${SUDO_USER:-$(id -un)}"
    RUN_HOME="$(getent passwd "$RUN_USER" | cut -d: -f6)"
    [ -n "$RUN_HOME" ] || RUN_HOME="$HOME"
    SERVICE_PATH="/etc/systemd/system/ccminer.service"

    $SUDO tee "$SERVICE_PATH" >/dev/null <<EOL
[Unit]
Description=ccminer miner
After=network-online.target
Wants=network-online.target

[Service]
Type=simple
User=${RUN_USER}
WorkingDirectory=${RUN_HOME}/ccminer
Environment=TERM=xterm
ExecStart=/bin/bash -lc 'cd ${RUN_HOME}/ccminer && ./start.sh'
Restart=on-failure
RestartSec=5

[Install]
WantedBy=multi-user.target
EOL

    $SUDO systemctl daemon-reload
    $SUDO systemctl enable --now ccminer
    success "Service systemd ccminer aktif. Cek status: systemctl status ccminer"
}

# Fungsi validasi
validate_verus_address() {
    local address=$1
    [[ $address =~ ^R[a-zA-Z0-9]{33}$ ]]
    return $?
}

validate_url() {
    local url=$1
    [[ $url =~ ^[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$ ]]
    return $?
}

validate_port() {
    local port=$1
    [[ "$port" =~ ^[0-9]+$ ]] && [ "$port" -ge 1 ] && [ "$port" -le 65535 ]
    return $?
}

# Fungsi cleanup
cleanup() {
    local exit_code=$?
    if [ $exit_code -ne 0 ]; then
        error "Script terminated with error code $exit_code"
    fi
    exit $exit_code
}

# Set trap
trap cleanup EXIT
trap 'error "Script interrupted by user"; exit 1' INT

clear
info "Starting setup..."
info "Platform detected: $PLATFORM"

# Update packages
info "Updating packages..."
if ! update_packages; then
    error "Failed to update packages"
    exit 1
fi
success "Packages updated successfully"

# Install required packages
info "Installing required packages..."
if ! install_packages; then
    error "Failed to install required packages"
    exit 1
fi
success "Required packages installed successfully"

# Change directory
cd $HOME || exit 1
clear

# Check existing ccminer directory
if [ -d "$HOME/ccminer" ]; then
    warning "CCMiner directory already exists!"
    echo -e "${CYAN}Do you want to delete and replace it? (Y/n):${NC} " > /dev/tty
    read -r replace_choice < /dev/tty
    replace_choice=${replace_choice:-Y}

    if [ "${replace_choice^^}" = "Y" ]; then
        rm -rf "$HOME/ccminer"
        success "Old CCMiner directory removed"
    else
        error "Setup cancelled by user"
        exit 1
    fi
fi

# Clone repository
info "Cloning CCMiner repository..."
if ! git clone https://github.com/alpian9890/ccminer.git; then
    error "Failed to clone repository"
    exit 1
fi

cd "$HOME/ccminer" || exit 1

# Set permissions
chmod +x "$HOME/ccminer" "$HOME/ccminer/ccminer" "$HOME/ccminer/start.sh" 2>/dev/null || true
chmod +x "$HOME/ccminer/setupverus" "$HOME/ccminer/setup-verus-mining.sh" 2>/dev/null || true
if [ -d "$HOME/ccminer/bin" ]; then
    find "$HOME/ccminer/bin" -type f -name ccminer -exec chmod +x {} + 2>/dev/null || true
fi
success "CCMiner cloned and permissions set"

# Autorun configuration
echo -e "${CYAN}Do you want to enable autorun mining when shell starts? (Y/n):${NC} " > /dev/tty
read -r autorun_choice < /dev/tty
autorun_choice=${autorun_choice:-Y}

if [ "${autorun_choice^^}" = "Y" ]; then
    autorun_cmd="cd $HOME/ccminer && ./start.sh"
    if ! grep -Fq "$autorun_cmd" "$BASHRC_FILE" 2>/dev/null; then
        echo "$autorun_cmd" >> "$BASHRC_FILE"
    fi
    autorun_status="yes"
else
    autorun_status="no"
fi

# Pool selection
echo -e "\n${YELLOW}Choose pool:${NC}" > /dev/tty
echo -e "${CYAN}1) Luckpool (ap.luckpool.net:3956)${NC}" > /dev/tty
echo -e "${CYAN}2) Vipor (sg.vipor.net:5040)${NC}" > /dev/tty
echo -e "${CYAN}Select pool (1/2):${NC} " > /dev/tty
read -r pool_choice < /dev/tty
pool_choice=${pool_choice:-1}

if [ "$pool_choice" = "2" ]; then
    server_url_default="sg.vipor.net"
    port_default="5040"
    pass_default=""
else
    server_url_default="ap.luckpool.net"
    port_default="3956"
    pass_default="x"
fi

# Pool configuration
echo -e "\n${YELLOW}Choose pool configuration method:${NC}" > /dev/tty
echo -e "${CYAN}1) Full URL (example: stratum+tcp://${server_url_default}:${port_default})${NC}" > /dev/tty
echo -e "${CYAN}2) Separate server and port${NC}" > /dev/tty
echo -e "${CYAN}3) Default (stratum+tcp://${server_url_default}:${port_default})${NC}" > /dev/tty
echo -e "${CYAN}Select option (1/2/3):${NC} " > /dev/tty
read -r url_choice < /dev/tty

if [ "$url_choice" = "1" ]; then
    while true; do
        echo -e "${CYAN}Enter full pool URL:${NC} " > /dev/tty
        read -r full_url < /dev/tty
        if [[ $full_url =~ ^stratum\+tcp://[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}:[0-9]+$ ]]; then
            server_url=$(echo "$full_url" | sed 's|stratum+tcp://\([^:]*\):.*|\1|')
            port=$(echo "$full_url" | sed 's|.*:\([0-9]*\)$|\1|')
            break
        else
            error "Invalid URL format. Please use format: stratum+tcp://server:port"
        fi
    done
elif [ "$url_choice" = "2" ]; then
    while true; do
        echo -e "${CYAN}Enter server/domain (default: ${server_url_default}):${NC} " > /dev/tty
        read -r server_url < /dev/tty
        server_url=${server_url:-$server_url_default}
        
        if validate_url "$server_url"; then
            break
        else
            error "Invalid server format"
        fi
    done

    while true; do
        echo -e "${CYAN}Enter port (default: ${port_default}):${NC} " > /dev/tty
        read -r port < /dev/tty
        port=${port:-$port_default}
        
        if validate_port "$port"; then
            break
        else
            error "Invalid port number (must be between 1-65535)"
        fi
    done
else
    server_url="$server_url_default"
    port="$port_default"
    success "Using default pool: stratum+tcp://${server_url}:${port}"
fi

# Wallet configuration
while true; do
    echo -e "${YELLOW}Example wallet address: RGJS61iPSNMhrkfqT9SWX6cjLqzCPLQSW1${NC}" > /dev/tty
    echo -e "${CYAN}Enter your Veruscoin wallet address (if blank = Donations):${NC} " > /dev/tty
    read -r wallet_address < /dev/tty
    wallet_address=${wallet_address:-RGJS61iPSNMhrkfqT9SWX6cjLqzCPLQSW1}
    
    if validate_verus_address "$wallet_address"; then
        break
    else
        error "Invalid Verus address format (must start with R and be 34 characters long)"
    fi
done

# Worker configuration
while true; do
    echo -e "${CYAN}Enter worker name (default: worker1):${NC} " > /dev/tty
    read -r worker_name < /dev/tty
    worker_name=${worker_name:-worker1}
    
    if [[ $worker_name =~ ^[a-zA-Z0-9_-]+$ ]]; then
        break
    else
        error "Invalid worker name (use only letters, numbers, underscore, and hyphen)"
    fi
done

# CPU configuration
total_cores=$(nproc)
while true; do
    echo -e "${CYAN}Enter number of CPU threads to use (max: $total_cores):${NC} " > /dev/tty
    read -r cpu_threads < /dev/tty
    cpu_threads=${cpu_threads:-$total_cores}
    
    if [[ "$cpu_threads" =~ ^[0-9]+$ ]] && [ "$cpu_threads" -le "$total_cores" ] && [ "$cpu_threads" -gt 0 ]; then
        break
    else
        error "Invalid number of threads (must be between 1 and $total_cores)"
    fi
done

# Create config file
cat > config.json << EOL
{
    "pools": [
        {
            "name": "${server_url}",
            "url": "stratum+tcp://${server_url}:${port}",
            "timeout": 180,
            "disabled": 0,
            "user": "${wallet_address}.${worker_name}",
            "pass": "${pass_default}"
        }
    ],
    "algo": "verus",
    "threads": ${cpu_threads},
    "cpu-priority": 1,
    "cpu-affinity": -1,
    "retry-pause": 10,
    "api-allow": "192.168.0.0/16",
    "api-bind": "0.0.0.0:4068"
}
EOL

# Final messages
success "Setup completed successfully!"
echo -e "${YELLOW}Make sure to check your configuration in:${NC} $HOME/ccminer/config.json" > /dev/tty

if [ "$PLATFORM" != "termux" ] && [ "$ARCH" = "x86_64" ]; then
    setup_systemd_service
fi
info "Autorun mining: $autorun_status"

if [ "$autorun_status" = "no" ]; then
    info "Since you chose not to autorun, to start mining manually run:"
    echo -e "${GREEN}cd $HOME/ccminer && ./start.sh${NC}" > /dev/tty
fi