#!/bin/bash

# Darkmatter Terminal Setup - Remote configuration installer

# Downloads and installs terminal configuration from GitHub

# Requires: Homebrew (https://brew.sh)

set -euo pipefail  # Exit on any error, undefined variables, and pipe failures

# Configuration - Update these URLs to match your GitHub repo

GITHUB_RAW_BASE="https://raw.githubusercontent.com/stevedylandev/darkmatter/main"

TEMP_DIR="/tmp/darkmatter_install"

DEBUG_MODE="${DEBUG:-false}"

# Colors for output

RED='\033[0;31m'

GREEN='\033[0;32m'

YELLOW='\033[1;33m'

BLUE='\033[0;34m'

PURPLE='\033[0;35m'

NC='\033[0m' # No Color

# Function to print colored output

print_status() {

    echo -e "${BLUE}[INFO]${NC} $1"

}

print_success() {

    echo -e "${GREEN}[SUCCESS]${NC} $1"

}

print_warning() {

    echo -e "${YELLOW}[WARNING]${NC} $1"

}

print_error() {

    echo -e "${RED}[ERROR]${NC} $1"

}

print_debug() {

    if [ "$DEBUG_MODE" = "true" ]; then

        echo -e "${PURPLE}[DEBUG]${NC} $1"

    fi

}

# Enhanced error handler

error_handler() {

    local line_number="$1"

    local error_code="$2"

    local command="$BASH_COMMAND"

    print_error "Script failed at line $line_number with exit code $error_code"

    print_error "Failed command: $command"

    print_error "Current function: ${FUNCNAME[1]:-main}"

    # Show some context

    if [ -f "$0" ]; then

        print_error "Context around line $line_number:"

        sed -n "$((line_number-2)),$((line_number+2))p" "$0" | nl -ba

    fi

    cleanup

    exit $error_code

}

# Set up error trap

trap 'error_handler ${LINENO} $?' ERR

# Check if required tools are available

check_dependencies() {

    print_status "Checking dependencies..."

    print_debug "Checking for brew command..."

    if ! command -v brew &> /dev/null; then

        print_error "Homebrew is not installed. Please install it first:"

        print_error "https://brew.sh"

        exit 1

    fi

    print_success "Homebrew found at: $(which brew)"

    print_debug "Checking for curl command..."

    if ! command -v curl &> /dev/null; then

        print_error "curl is not installed. Please install it first."

        exit 1

    fi

}

# Create temporary directory for downloads

setup_temp_dir() {

    print_status "Setting up temporary directory..."

    print_debug "Removing existing temp dir: $TEMP_DIR"

    if [ -d "$TEMP_DIR" ]; then

        rm -rf "$TEMP_DIR" || {

            print_error "Failed to remove existing temp directory: $TEMP_DIR"

            exit 1

        }

    fi

    print_debug "Creating temp dir: $TEMP_DIR"

    mkdir -p "$TEMP_DIR" || {

        print_error "Failed to create temporary directory: $TEMP_DIR"

        exit 1

    }

    print_success "Temporary directory created: $TEMP_DIR"

    print_debug "Temp directory permissions: $(ls -ld "$TEMP_DIR")"

}

# Test GitHub connectivity

test_github_connection() {

    print_status "Testing GitHub connectivity..."

    print_debug "Testing connection to: $GITHUB_RAW_BASE"

    # Test with a simple HEAD request

    if curl -I -f -s --connect-timeout 10 --max-time 30 "$GITHUB_RAW_BASE/.zshrc" > /dev/null; then

        print_success "Successfully connected to GitHub repository"

    else

        local exit_code=$?

        print_error "Failed to connect to GitHub repository"

        print_error "URL tested: $GITHUB_RAW_BASE/.zshrc"

        print_error "curl exit code: $exit_code"

        # Try to give more specific error information

        case $exit_code in

            6) print_error "Could not resolve host - check your internet connection" ;;

            7) print_error "Failed to connect to host - check the repository URL" ;;

            22) print_error "HTTP error - the file might not exist or repository might be private" ;;

            28) print_error "Timeout - check your internet connection" ;;

            *) print_error "Unknown curl error - check the repository URL and your internet connection" ;;

        esac

        exit 1

    fi

}

# Download file from GitHub with detailed error reporting

download_file() {

    local filename="$1"

    local url="$GITHUB_RAW_BASE/$filename"

    local dest="$TEMP_DIR/$filename"

    print_status "Downloading $filename..."

    print_debug "From: $url"

    print_debug "To: $dest"

    # Create directory if needed

    local dest_dir=$(dirname "$dest")

    if [ ! -d "$dest_dir" ]; then

        mkdir -p "$dest_dir" || {

            print_error "Failed to create directory: $dest_dir"

            return 1

        }

    fi

    # Download with verbose error reporting

    local curl_output

    curl_output=$(curl -L -f -s -w "HTTP_CODE:%{http_code};SIZE:%{size_download};TIME:%{time_total}" -o "$dest" "$url" 2>&1) || {

        local exit_code=$?

        print_error "Failed to download $filename"

        print_error "URL: $url"

        print_error "curl exit code: $exit_code"

        print_error "curl output: $curl_output"

        return 1

    }

    print_debug "curl response: $curl_output"

    # Verify file was downloaded and has content

    if [ ! -f "$dest" ]; then

        print_error "File was not created: $dest"

        return 1

    fi

    local file_size=$(wc -c < "$dest" 2>/dev/null || echo "0")

    if [ "$file_size" -eq 0 ]; then

        print_error "Downloaded file is empty: $filename"

        return 1

    fi

    print_success "Downloaded $filename (${file_size} bytes)"

    print_debug "File content preview:"

    if [ "$DEBUG_MODE" = "true" ]; then

        head -3 "$dest" || true

    fi

    return 0

}

# Download all configuration files

download_configs() {

    print_status "Downloading configuration files from GitHub..."

    local files=(

        ".zshrc"

        "config"

        "dark.tmTheme"

    )

    local success_count=0

    local total_files=${#files[@]}

    print_debug "Starting download loop for ${total_files} files"

    for file in "${files[@]}"; do

        print_debug "=== Processing file $((success_count + 1))/$total_files: $file ==="

        # Disable error exit temporarily for this specific operation

        set +e

        download_file "$file"

        local download_result=$?

        set -e

        print_debug "Download result for $file: $download_result"

        if [ $download_result -eq 0 ]; then

            success_count=$((success_count + 1))

            print_success "Successfully downloaded: $file (count: $success_count)"

        else

            print_error "Failed to download $file (exit code: $download_result)"

            print_error "This will cause installation issues"

            # Continue with other files to see what we can get

        fi

        print_debug "Completed processing $file, moving to next file"

    done

    print_debug "Download loop completed"

    print_status "Downloaded $success_count/$total_files configuration files"

    if [ $success_count -eq $total_files ]; then

        print_success "All configuration files downloaded successfully"

    else

        print_error "Failed to download some configuration files ($success_count/$total_files succeeded)"

        print_error "Installation cannot continue without all config files"

        # Show what files we do have

        print_status "Files in temp directory:"

        ls -la "$TEMP_DIR" || true

        exit 1

    fi

}

# Download and install font

download_and_install_font() {

    print_status "Downloading CommitMono Nerd Font..."

    local font_filename="CommitMonoNerdFont-Regular.otf"

    local font_url="$GITHUB_RAW_BASE/assets/$font_filename"

    local font_dest="$TEMP_DIR/$font_filename"

    print_debug "Font download URL: $font_url"

    # Create assets subdirectory in temp

    mkdir -p "$TEMP_DIR/assets"

    font_dest="$TEMP_DIR/assets/$font_filename"

    if curl -L -f -s  -o "$font_dest" "$font_url" 2>/dev/null; then

        local file_size=$(wc -c < "$font_dest" 2>/dev/null || echo "0")

        print_success "Downloaded CommitMono Nerd Font (${file_size} bytes)"

        # Verify it's actually a font file (should be reasonably large)

        if [ "$file_size" -lt 10000 ]; then

            print_warning "Font file seems too small, might be an error page"

            print_debug "Font file content preview:"

            if [ "$DEBUG_MODE" = "true" ]; then

                head -3 "$font_dest" || true

            fi

        fi

    else

        print_warning "Failed to download font from $font_url"

        print_warning "Continuing without font installation..."

        return 1

    fi

    # Install the font

    print_status "Installing CommitMono Nerd Font..."

    local user_fonts_dir="$HOME/Library/Fonts"

    print_debug "Font installation directory: $user_fonts_dir"

    if [ ! -d "$user_fonts_dir" ]; then

        mkdir -p "$user_fonts_dir" || {

            print_error "Failed to create fonts directory: $user_fonts_dir"

            return 1

        }

    fi

    local dest_file="$user_fonts_dir/$font_filename"

    if [ -f "$dest_file" ]; then

        print_warning "Font $font_filename already installed, skipping"

    else

        cp "$font_dest" "$dest_file" || {

            print_error "Failed to copy font to $dest_file"

            return 1

        }

        print_success "Installed font: $font_filename"

        # Clear font cache on macOS

        print_status "Refreshing font cache..."

        if command -v atsutil &> /dev/null; then

            sudo atsutil databases -remove 2>/dev/null || print_debug "atsutil databases -remove failed"

            atsutil server -shutdown 2>/dev/null || print_debug "atsutil server -shutdown failed"

            atsutil server -ping 2>/dev/null || print_debug "atsutil server -ping failed"

        else

            print_debug "atsutil not found, skipping font cache refresh"

        fi

        print_success "Font installation complete!"

        print_status "You may need to restart applications to see the new font"

    fi

}

# Install packages via Homebrew with better error handling

install_packages() {

    print_status "Installing packages via Homebrew..."

    local packages=(

        "zsh"

        "zsh-autosuggestions"

        "zsh-syntax-highlighting"

        "starship"

        "eza"

        "zoxide"

        "aichat"

        "btop"

        "fzf"

        "bat"

    )

    local cask_packages=(

        "ghostty"

    )

    # Install regular packages

    for package in "${packages[@]}"; do

        print_status "Installing $package..."

        print_debug "Checking if $package is already installed..."

        if brew list "$package" &>/dev/null; then

            print_warning "$package is already installed"

        else

            print_debug "Installing $package with brew..."

            if brew install "$package"; then

                print_success "Installed $package"

            else

                print_error "Failed to install $package"

                # Don't exit, try to continue with other packages

            fi

        fi

    done

    # Install cask packages

    for package in "${cask_packages[@]}"; do

        print_status "Installing $package (cask)..."

        print_debug "Checking if cask $package is already installed..."

        if brew list --cask "$package" &>/dev/null; then

            print_warning "$package is already installed"

        else

            print_debug "Installing cask $package with brew..."

            if brew install --cask "$package"; then

                print_success "Installed $package"

            else

                print_warning "Failed to install $package (cask) - this might not be critical"

                # Ghostty might not be available, but don't fail the whole script

            fi

        fi

    done

}

# Backup existing config files

backup_configs() {

    print_status "Backing up existing configuration files..."

    local timestamp=$(date +%Y%m%d_%H%M%S)

    local backup_dir="$HOME/.config_backup_$timestamp"

    print_debug "Backup directory: $backup_dir"

    mkdir -p "$backup_dir" || {

        print_error "Failed to create backup directory: $backup_dir"

        exit 1

    }

    local backed_up=false

    if [ -f "$HOME/.zshrc" ]; then

        cp "$HOME/.zshrc" "$backup_dir/" && {

            print_success "Backed up .zshrc to $backup_dir"

            backed_up=true

        } || print_warning "Failed to backup .zshrc"

    fi

    if [ -f "$HOME/.config/ghostty/config" ]; then

        mkdir -p "$backup_dir/.config/ghostty"

        cp "$HOME/.config/ghostty/config" "$backup_dir/.config/ghostty/" && {

            print_success "Backed up ghostty config to $backup_dir"

            backed_up=true

        } || print_warning "Failed to backup ghostty config"

    fi

    if [ "$backed_up" = false ]; then

        print_status "No existing configuration files to backup"

        rmdir "$backup_dir" 2>/dev/null || true

    fi

}

check_darkmatter_in_zshrc() {

    local zshrc_file="$1"

    if [ ! -f "$zshrc_file" ]; then

        return 1  # File doesn't exist

    fi

    # Look for our marker comment

    if grep -q "# Darkmatter Terminal Configuration" "$zshrc_file" 2>/dev/null; then

        return 0  # Already present

    else

        return 1  # Not present

    fi

}

# Copy downloaded configuration files to their destinations

install_configs() {

    print_status "Installing configuration files..."

    local install_errors=0

    # Handle .zshrc installation

    if [ -f "$TEMP_DIR/.zshrc" ]; then

        if [ -f "$HOME/.zshrc" ]; then

            # Existing .zshrc found

            print_status "Existing .zshrc found, checking for Darkmatter configuration..."

            if check_darkmatter_in_zshrc "$HOME/.zshrc"; then

                print_warning "Darkmatter configuration already exists in .zshrc"

                print_status "Skipping .zshrc modification to avoid duplicates"

            else

                print_status "Appending Darkmatter configuration to existing .zshrc"

                # Add a separator and our config

                {

                    echo ""

                    echo "# ============================================="

                    echo "# Darkmatter Terminal Configuration"

                    echo "# Added by Darkmatter installer on $(date)"

                    echo "# ============================================="

                    echo ""

                    cat "$TEMP_DIR/.zshrc"

                } >> "$HOME/.zshrc" && {

                    print_success "Successfully appended Darkmatter configuration to .zshrc"

                } || {

                    print_error "Failed to append to existing .zshrc"

                    ((install_errors++))

                }

            fi

        else

            # No existing .zshrc, create new one

            print_status "No existing .zshrc found, creating new one"

            if cp "$TEMP_DIR/.zshrc" "$HOME/"; then

                print_success "Installed .zshrc"

            else

                print_error "Failed to install .zshrc"

                ((install_errors++))

            fi

        fi

    else

        print_error ".zshrc not found in downloaded files: $TEMP_DIR/.zshrc"

        ((install_errors++))

    fi

    # Install ghostty config (keep existing logic for replacement)

    if [ -f "$TEMP_DIR/config" ]; then

        print_debug "Installing ghostty config to $HOME/.config/ghostty/"

        mkdir -p "$HOME/.config/ghostty"

        if [ -f "$HOME/.config/ghostty/config" ]; then

            print_status "Existing Ghostty config found, it will be replaced"

            print_status "(Previous config was backed up)"

        fi

        if cp "$TEMP_DIR/config" "$HOME/.config/ghostty/"; then

            print_success "Installed Ghostty config"

        else

            print_error "Failed to install Ghostty config"

            ((install_errors++))

        fi

    else

        print_error "Ghostty config not found in downloaded files: $TEMP_DIR/config"

        ((install_errors++))

    fi

    # Install aichat theme

    if [ -f "$TEMP_DIR/dark.tmTheme" ]; then

        print_debug "Installing aichat theme to $HOME/Library/Application Support/aichat/"

        mkdir -p "$HOME/Library/Application Support/aichat"

        if [ -f "$HOME/Library/Application Support/aichat/dark.tmTheme" ]; then

            print_status "Existing aichat theme found, it will be replaced"

        fi

        if cp "$TEMP_DIR/dark.tmTheme" "$HOME/Library/Application Support/aichat/"; then

            print_success "Installed aichat theme"

        else

            print_error "Failed to install aichat theme"

            ((install_errors++))

        fi

    else

        print_error "aichat theme not found in downloaded files: $TEMP_DIR/dark.tmTheme"

        ((install_errors++))

    fi

    if [ $install_errors -gt 0 ]; then

        print_error "$install_errors configuration files failed to install"

        exit 1

    fi

}

# Set zsh as default shell

set_default_shell() {

    print_status "Checking default shell..."

    local current_shell="${SHELL}"

    local zsh_path

    zsh_path=$(which zsh) || {

        print_error "zsh not found in PATH"

        exit 1

    }

    print_debug "Current shell: $current_shell"

    print_debug "zsh path: $zsh_path"

    if [ "$current_shell" != "$zsh_path" ]; then

        print_status "Setting zsh as default shell..."

        # Add zsh to /etc/shells if not present

        if ! grep -q "$zsh_path" /etc/shells 2>/dev/null; then

            print_debug "Adding $zsh_path to /etc/shells"

            echo "$zsh_path" | sudo tee -a /etc/shells > /dev/null || {

                print_error "Failed to add zsh to /etc/shells"

                exit 1

            }

        fi

        # Change default shell

        print_debug "Changing default shell to $zsh_path"

        if chsh -s "$zsh_path"; then

            print_success "Default shell set to zsh"

            print_warning "Please restart your terminal or run 'exec zsh' to use the new shell"

        else

            print_error "Failed to change default shell"

            exit 1

        fi

    else

        print_success "zsh is already the default shell"

    fi

}

# Cleanup temporary files

cleanup() {

    if [ -d "$TEMP_DIR" ]; then

        print_debug "Cleaning up temporary files from: $TEMP_DIR"

        rm -rf "$TEMP_DIR" || print_warning "Failed to clean up temporary directory"

        print_success "Cleanup complete"

    fi

}

# Show debug information

show_debug_info() {

    if [ "$DEBUG_MODE" = "true" ]; then

        print_debug "=== Debug Information ==="

        print_debug "Script: $0"

        print_debug "Working directory: $(pwd)"

        print_debug "User: $USER"

        print_debug "Home: $HOME"

        print_debug "Shell: $SHELL"

        print_debug "PATH: $PATH"

        print_debug "GitHub base URL: $GITHUB_RAW_BASE"

        print_debug "Temp directory: $TEMP_DIR"

        print_debug "========================="

    fi

}

# Main installation function

main() {

    echo "🌑 Darkmatter Setup Installer (Remote)"

    echo "======================================"

    echo

    # Enable debug mode if requested

    if [ "${1:-}" = "--debug" ] || [ "${1:-}" = "-d" ]; then

        DEBUG_MODE="true"

        print_status "Debug mode enabled"

    fi

    show_debug_info

    # Check if GITHUB_RAW_BASE needs to be updated

    if [[ "$GITHUB_RAW_BASE" == *"your-username/your-repo"* ]]; then

        print_error "Please update the GITHUB_RAW_BASE variable in this script"

        print_error "Set it to your actual GitHub repository URL"

        print_error "Example: https://raw.githubusercontent.com/username/repo-name/main"

        exit 1

    fi

    print_status "Starting installation process..."

    check_dependencies

    setup_temp_dir

    install_packages

    test_github_connection

    download_configs

    download_and_install_font

    backup_configs

    install_configs

    set_default_shell

    cleanup

    echo

    print_success "Installation complete! 🌌"

    echo

    print_status "Next steps:"

    echo "  1. Restart your terminal or run: exec zsh"

    echo "  2. Open Ghostty to use your new terminal setup"

    echo "  3. Enjoy your Darkmatter terminal experience!"

    echo

}

# Handle script interruption

trap cleanup EXIT

# Run main function with all arguments

main "$@"