#!/bin/bash
# Fukura CLI Installation Script
# This script installs the latest version of Fukura CLI
# 
# Security features:
# - Verifies SHA256 checksums
# - Uses HTTPS for all downloads
# - Provides clear feedback on each step
# - Allows user inspection before execution

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

# Configuration
REPO_OWNER="boostbit-inc"
REPO_NAME="fukura"
# Where to install the binary. Defaults to /usr/local/bin (sudo), but
# users without sudo (corporate laptops, CI, restricted runners) can
# override by exporting FUKURA_INSTALL_DIR=$HOME/.local/bin before the
# curl | bash pipe.
INSTALL_DIR="${FUKURA_INSTALL_DIR:-/usr/local/bin}"
GITHUB_API="https://api.github.com/repos/${REPO_OWNER}/${REPO_NAME}/releases/latest"
GITHUB_RELEASES="https://github.com/${REPO_OWNER}/${REPO_NAME}/releases/latest/download"

# Helper functions
info() {
    echo -e "${BLUE}ℹ${NC} $1"
}

success() {
    echo -e "${GREEN}✓${NC} $1"
}

error() {
    echo -e "${RED}✗${NC} $1"
    exit 1
}

warning() {
    echo -e "${YELLOW}⚠${NC} $1"
}

# Check if APT is available (Debian/Ubuntu)
has_apt() {
    command -v apt-get >/dev/null 2>&1
}

# Install via APT repository
install_via_apt() {
    info "Setting up APT repository for Fukura..."
    
    # Check if repository already exists
    if [ -f /etc/apt/sources.list.d/fukura.list ]; then
        info "Fukura repository already configured"
    else
        # Add GPG key
        info "Adding Fukura GPG key..."
        if ! curl -fsSL https://fukura.dev/fukura-gpg.asc | $SUDO gpg --dearmor -o /usr/share/keyrings/fukura-archive-keyring.gpg 2>/dev/null; then
            warning "GPG key not yet available (repository setup in progress)"
            warning "Falling back to direct binary installation..."
            return 1
        fi
        
        # Add repository
        info "Adding Fukura APT repository..."
        echo "deb [signed-by=/usr/share/keyrings/fukura-archive-keyring.gpg] https://fukura.dev/apt stable main" | $SUDO tee /etc/apt/sources.list.d/fukura.list >/dev/null
        success "Repository added successfully"
    fi
    
    # Update package list
    info "Updating package list..."
    if ! $SUDO apt-get update 2>&1 | grep -q "fukura\|Reading package lists"; then
        warning "Failed to update package list"
        warning "Falling back to direct binary installation..."
        return 1
    fi
    
    # Try to install
    info "Installing fukura via APT..."
    if $SUDO apt-get install -y fukura 2>/dev/null; then
        success "Fukura installed via APT repository!"
        return 0
    else
        warning "Package not yet available in repository"
        warning "Falling back to direct binary installation..."
        info "Repository configured for future automatic updates"
        return 1
    fi
}

# Detect OS and architecture
detect_platform() {
    local os=$(uname -s | tr '[:upper:]' '[:lower:]')
    local arch=$(uname -m)
    
    case "$os" in
        linux*)
            OS="linux"
            ;;
        darwin*)
            OS="darwin"
            ;;
        *)
            error "Unsupported operating system: $os"
            ;;
    esac
    
    case "$arch" in
        x86_64|amd64)
            ARCH="x86_64"
            ;;
        aarch64|arm64)
            ARCH="aarch64"
            ;;
        *)
            error "Unsupported architecture: $arch"
            ;;
    esac
    
    # Determine platform-specific naming
    if [ "$OS" = "darwin" ]; then
        PLATFORM="apple-darwin"
    else
        PLATFORM="unknown-linux-gnu"
    fi
    
    BINARY_NAME="fukura-${ARCH}-${PLATFORM}"
    ARCHIVE_EXT="tar.xz"
    ARCHIVE_NAME="${BINARY_NAME}.${ARCHIVE_EXT}"
    
    info "Detected platform: $OS ($ARCH)"
}

# Check if running as root (needed for system-wide install)
check_permissions() {
    # Directories the current user can already write to don't need sudo.
    # This lets FUKURA_INSTALL_DIR=$HOME/.local/bin install from a
    # curl | bash pipe on a laptop that has no sudo rights.
    if [ -w "$INSTALL_DIR" ] || { [ ! -e "$INSTALL_DIR" ] && mkdir -p "$INSTALL_DIR" 2>/dev/null; }; then
        SUDO=""
        info "Installing to ${INSTALL_DIR} (no sudo needed)"
        return
    fi

    if [ "${EUID:-$(id -u)}" -eq 0 ]; then
        SUDO=""
    else
        if command -v sudo >/dev/null 2>&1; then
            SUDO="sudo"
            info "Installation requires sudo privileges (target: ${INSTALL_DIR})"
            info "Tip: export FUKURA_INSTALL_DIR=\$HOME/.local/bin to install without sudo"
        else
            error "sudo not found and ${INSTALL_DIR} is not writable. Export FUKURA_INSTALL_DIR=\$HOME/.local/bin to install to your home directory."
        fi
    fi
}

# Fetch latest version from GitHub API
get_latest_version() {
    info "Fetching latest version..."
    
    if command -v curl >/dev/null 2>&1; then
        LATEST_VERSION=$(curl -sSf "$GITHUB_API" | grep -o '"tag_name": *"[^"]*"' | sed 's/"tag_name": *"\(.*\)"/\1/')
    elif command -v wget >/dev/null 2>&1; then
        LATEST_VERSION=$(wget -qO- "$GITHUB_API" | grep -o '"tag_name": *"[^"]*"' | sed 's/"tag_name": *"\(.*\)"/\1/')
    else
        error "Neither curl nor wget found. Please install one of them."
    fi
    
    if [ -z "$LATEST_VERSION" ]; then
        error "Failed to fetch latest version"
    fi
    
    success "Latest version: $LATEST_VERSION"
}

# Download file with checksum verification
download_and_verify() {
    local url=$1
    local output=$2
    
    info "Downloading: $(basename $output)"
    
    if command -v curl >/dev/null 2>&1; then
        curl -sSfL "$url" -o "$output" || error "Download failed: $url"
    elif command -v wget >/dev/null 2>&1; then
        wget -q "$url" -O "$output" || error "Download failed: $url"
    fi
    
    success "Downloaded: $(basename $output)"
}

# Verify SHA256 checksum
verify_checksum() {
    local file=$1
    local checksum_file=$2
    
    info "Verifying checksum..."
    
    if [ ! -f "$checksum_file" ]; then
        warning "Checksum file not found, skipping verification"
        return
    fi
    
    # Extract expected checksum
    local expected_checksum=$(cat "$checksum_file" | awk '{print $1}')
    
    # Calculate actual checksum
    if command -v shasum >/dev/null 2>&1; then
        local actual_checksum=$(shasum -a 256 "$file" | awk '{print $1}')
    elif command -v sha256sum >/dev/null 2>&1; then
        local actual_checksum=$(sha256sum "$file" | awk '{print $1}')
    else
        warning "No SHA256 tool found, skipping verification"
        return
    fi
    
    if [ "$expected_checksum" != "$actual_checksum" ]; then
        error "Checksum verification failed!\nExpected: $expected_checksum\nActual:   $actual_checksum"
    fi
    
    success "Checksum verified"
}

# Extract and install binary
install_binary() {
    local archive=$1
    local temp_dir=$2
    
    info "Extracting archive..."
    
    tar -xf "$archive" -C "$temp_dir" || error "Failed to extract archive"
    
    # Archive structure: fukura-{arch}-{platform}/fukura and fukura-{arch}-{platform}/fuku
    local extract_dir="${temp_dir}/${BINARY_NAME}"
    local binary_fukura="${extract_dir}/fukura"
    local binary_fuku="${extract_dir}/fuku"
    
    if [ ! -f "$binary_fukura" ]; then
        error "Binary 'fukura' not found at expected path: ${binary_fukura}"
    fi
    
    info "Found binaries in ${extract_dir}"
    
    # Make binaries executable
    chmod +x "$binary_fukura"
    [ -f "$binary_fuku" ] && chmod +x "$binary_fuku"
    
    info "Installing to ${INSTALL_DIR}..."
    
    # Install fukura
    $SUDO mv "$binary_fukura" "${INSTALL_DIR}/fukura" || error "Failed to install fukura binary"
    
    # Install fuku (short alias) if it exists
    if [ -f "$binary_fuku" ]; then
        $SUDO mv "$binary_fuku" "${INSTALL_DIR}/fuku" || warning "Failed to install fuku alias"
        success "Fukura and fuku installed to ${INSTALL_DIR}/"
    else
        # Create fuku symlink as fallback
        $SUDO ln -sf "${INSTALL_DIR}/fukura" "${INSTALL_DIR}/fuku" 2>/dev/null || true
        success "Fukura installed to ${INSTALL_DIR}/fukura"
        info "Created 'fuku' symlink for convenience"
    fi
}

# Main installation process
main() {
    echo -e "${GREEN}"
    echo "╔════════════════════════════════════════╗"
    echo "║   Fukura CLI Installation Script      ║"
    echo "╚════════════════════════════════════════╝"
    echo -e "${NC}"
    
    # Detect platform
    detect_platform
    
    # Check permissions
    check_permissions
    
    # Try APT installation first on Debian/Ubuntu
    if [ "$OS" = "linux" ] && has_apt; then
        info "Debian/Ubuntu detected, trying APT installation..."
        if install_via_apt; then
            echo ""
            success "Fukura CLI has been successfully installed via APT!"
            echo ""
            info "Run 'fukura --version' to verify the installation"
            info "Run 'fukura --help' to see available commands"
            echo ""
            info "To update: sudo apt update && sudo apt upgrade fukura"
            info "Documentation: https://fukura.dev/docs"
            info "GitHub: https://github.com/${REPO_OWNER}/${REPO_NAME}"
            echo ""
            return 0
        fi
        
        info "Falling back to manual installation..."
    fi
    
    # Get latest version
    get_latest_version
    
    # Create temporary directory
    TEMP_DIR=$(mktemp -d)
    trap "rm -rf $TEMP_DIR" EXIT
    
    # Download URLs
    ARCHIVE_URL="${GITHUB_RELEASES}/${ARCHIVE_NAME}"
    CHECKSUM_URL="${ARCHIVE_URL}.sha256"
    
    # Download files
    download_and_verify "$ARCHIVE_URL" "${TEMP_DIR}/${ARCHIVE_NAME}"
    download_and_verify "$CHECKSUM_URL" "${TEMP_DIR}/${ARCHIVE_NAME}.sha256"
    
    # Verify checksum
    verify_checksum "${TEMP_DIR}/${ARCHIVE_NAME}" "${TEMP_DIR}/${ARCHIVE_NAME}.sha256"
    
    # Install binary
    install_binary "${TEMP_DIR}/${ARCHIVE_NAME}" "$TEMP_DIR"
    
    echo ""
    success "Fukura CLI has been successfully installed!"
    echo ""
    info "Run 'fukura --version' or 'fuku --version' to verify the installation"
    info "Run 'fukura --help' or 'fuku --help' to see available commands"
    info "Quick start: fuku init"
    echo ""
    info "Documentation: https://fukura.dev/docs"
    info "GitHub: https://github.com/${REPO_OWNER}/${REPO_NAME}"
    echo ""
}

# Run main installation
main