install.sh

#!/bin/bash
#
# install.sh - Installer for carbon2cocoa
#
# This script detects the platform, checks for prerequisites, builds the
# application, and installs all files to the correct locations.
#
# Usage: ./install.sh [OPTIONS]
#
# Options:
#   --prefix=PATH    Installation prefix (default: /usr/local)
#   --uninstall      Remove installed files
#   --help           Show this help message
#
# Copyright (c) 2025 Pascal Harris, 45RPM Software
# Licensed under the MIT License
#

set -e

# Configuration
PROGRAM="carbon2cocoa"
VERSION="1.1.0"
DEFAULT_PREFIX="/usr/local"

# Colors for output (if terminal supports it)
if [ -t 1 ]; then
    RED='\033[0;31m'
    GREEN='\033[0;32m'
    YELLOW='\033[1;33m'
    BLUE='\033[0;34m'
    NC='\033[0m'
else
    RED=''
    GREEN=''
    YELLOW=''
    BLUE=''
    NC=''
fi

# Print functions
info() {
    echo -e "${BLUE}[INFO]${NC} $1"
}

success() {
    echo -e "${GREEN}[OK]${NC} $1"
}

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

error() {
    echo -e "${RED}[ERROR]${NC} $1" >&2
}

# Show help
show_help() {
    cat << EOF
carbon2cocoa Installer v${VERSION}

Usage: $0 [OPTIONS]

Options:
  --prefix=PATH    Installation prefix (default: ${DEFAULT_PREFIX})
  --uninstall      Remove installed files
  --help           Show this help message

The installer will:
  1. Detect your operating system
  2. Check for required build tools (C compiler, make)
  3. Prompt to install missing prerequisites
  4. Build the application
  5. Install files to:
     - \${PREFIX}/bin/${PROGRAM}
     - \${PREFIX}/share/man/man1/${PROGRAM}.1

Examples:
  $0                        # Install to /usr/local
  $0 --prefix=\$HOME/.local  # Install to ~/.local
  $0 --uninstall            # Remove installed files
EOF
}

# Parse command line arguments
PREFIX="${DEFAULT_PREFIX}"
UNINSTALL=false

for arg in "$@"; do
    case $arg in
        --prefix=*)
            PREFIX="${arg#*=}"
            ;;
        --uninstall)
            UNINSTALL=true
            ;;
        --help|-h)
            show_help
            exit 0
            ;;
        *)
            error "Unknown option: $arg"
            echo "Use --help for usage information."
            exit 1
            ;;
    esac
done

# Derived paths
BINDIR="${PREFIX}/bin"
MANDIR="${PREFIX}/share/man/man1"

# Detect operating system
detect_os() {
    info "Detecting operating system..."
    
    OS_NAME="$(uname -s)"
    OS_ARCH="$(uname -m)"
    
    case "${OS_NAME}" in
        Darwin*)
            OS_TYPE="macos"
            OS_PRETTY="macOS"
            if command -v sw_vers &> /dev/null; then
                OS_VERSION="$(sw_vers -productVersion)"
                OS_PRETTY="macOS ${OS_VERSION}"
            fi
            ;;
        Linux*)
            OS_TYPE="linux"
            if [ -f /etc/os-release ]; then
                . /etc/os-release
                OS_PRETTY="${NAME} ${VERSION_ID:-}"
            elif [ -f /etc/lsb-release ]; then
                . /etc/lsb-release
                OS_PRETTY="${DISTRIB_DESCRIPTION:-Linux}"
            else
                OS_PRETTY="Linux"
            fi
            ;;
        FreeBSD*)
            OS_TYPE="freebsd"
            OS_PRETTY="FreeBSD $(uname -r)"
            ;;
        CYGWIN*|MINGW*|MSYS*)
            OS_TYPE="windows"
            OS_PRETTY="Windows ($(uname -s))"
            ;;
        *)
            OS_TYPE="unknown"
            OS_PRETTY="${OS_NAME}"
            ;;
    esac
    
    success "Detected: ${OS_PRETTY} (${OS_ARCH})"
}

# Check if a command exists
command_exists() {
    command -v "$1" &> /dev/null
}

# Prompt user for yes/no
prompt_yn() {
    local prompt="$1"
    local default="${2:-n}"
    local reply
    
    if [ "$default" = "y" ]; then
        prompt="${prompt} [Y/n] "
    else
        prompt="${prompt} [y/N] "
    fi
    
    read -p "$prompt" reply
    reply="${reply:-$default}"
    
    case "$reply" in
        [Yy]*) return 0 ;;
        *) return 1 ;;
    esac
}

# Install prerequisites on macOS
install_prereqs_macos() {
    info "Checking for Xcode Command Line Tools..."
    
    if ! xcode-select -p &> /dev/null; then
        warning "Xcode Command Line Tools not installed."
        
        if prompt_yn "Install Xcode Command Line Tools?" "y"; then
            info "Installing Xcode Command Line Tools..."
            xcode-select --install
            echo ""
            echo "A dialog should have appeared to install the tools."
            echo "Please complete the installation and run this script again."
            exit 0
        else
            error "Cannot proceed without Xcode Command Line Tools."
            exit 1
        fi
    fi
    
    success "Xcode Command Line Tools installed"
}

# Install prerequisites on Linux
install_prereqs_linux() {
    local missing=()
    
    if ! command_exists gcc && ! command_exists clang; then
        missing+=("gcc")
    fi
    
    if ! command_exists make; then
        missing+=("make")
    fi
    
    if [ ${#missing[@]} -eq 0 ]; then
        return 0
    fi
    
    warning "Missing prerequisites: ${missing[*]}"
    
    if prompt_yn "Install missing prerequisites?" "y"; then
        if command_exists apt-get; then
            info "Using apt-get to install prerequisites..."
            sudo apt-get update
            sudo apt-get install -y build-essential
        elif command_exists dnf; then
            info "Using dnf to install prerequisites..."
            sudo dnf install -y gcc make
        elif command_exists yum; then
            info "Using yum to install prerequisites..."
            sudo yum install -y gcc make
        elif command_exists pacman; then
            info "Using pacman to install prerequisites..."
            sudo pacman -S --noconfirm base-devel
        elif command_exists zypper; then
            info "Using zypper to install prerequisites..."
            sudo zypper install -y gcc make
        elif command_exists apk; then
            info "Using apk to install prerequisites..."
            sudo apk add build-base
        else
            error "Could not detect package manager."
            echo "Please install manually: ${missing[*]}"
            exit 1
        fi
        
        success "Prerequisites installed"
    else
        error "Cannot proceed without prerequisites: ${missing[*]}"
        exit 1
    fi
}

# Check prerequisites
check_prereqs() {
    info "Checking prerequisites..."
    
    local have_cc=false
    local cc_name=""
    
    if command_exists cc; then
        have_cc=true
        cc_name="cc"
    elif command_exists gcc; then
        have_cc=true
        cc_name="gcc"
    elif command_exists clang; then
        have_cc=true
        cc_name="clang"
    fi
    
    if ! $have_cc; then
        warning "No C compiler found."
        case "${OS_TYPE}" in
            macos) install_prereqs_macos ;;
            linux) install_prereqs_linux ;;
            *) error "Please install a C compiler (gcc or clang) and try again."; exit 1 ;;
        esac
    else
        success "C compiler: ${cc_name}"
    fi
    
    if ! command_exists make; then
        warning "make not found."
        case "${OS_TYPE}" in
            macos) install_prereqs_macos ;;
            linux) install_prereqs_linux ;;
            *) error "Please install make and try again."; exit 1 ;;
        esac
    else
        success "make: $(command -v make)"
    fi
}

# Build the project
build_project() {
    info "Building ${PROGRAM}..."
    
    make clean &> /dev/null || true
    
    if make; then
        success "Build complete"
    else
        error "Build failed"
        exit 1
    fi
    
    if [ ! -f "${PROGRAM}" ]; then
        error "Binary not found after build"
        exit 1
    fi
    
    info "Running quick test..."
    if ./"${PROGRAM}" --version; then
        success "Binary works correctly"
    else
        error "Binary test failed"
        exit 1
    fi
}

# Install files
install_files() {
    info "Installing to ${PREFIX}..."
    
    local use_sudo=""
    if [ ! -w "${PREFIX}" ] 2>/dev/null; then
        if [ -d "${PREFIX}" ]; then
            warning "Installation directory requires elevated privileges."
            use_sudo="sudo"
        fi
    fi
    
    info "Creating directories..."
    ${use_sudo} mkdir -p "${BINDIR}"
    ${use_sudo} mkdir -p "${MANDIR}"
    
    info "Installing binary..."
    ${use_sudo} install -m 755 "${PROGRAM}" "${BINDIR}/${PROGRAM}"
    success "Installed: ${BINDIR}/${PROGRAM}"
    
    if [ -f "${PROGRAM}.1" ]; then
        info "Installing man page..."
        ${use_sudo} install -m 644 "${PROGRAM}.1" "${MANDIR}/${PROGRAM}.1"
        success "Installed: ${MANDIR}/${PROGRAM}.1"
        
        if command_exists mandb; then
            ${use_sudo} mandb -q 2>/dev/null || true
        fi
    else
        warning "Man page not found, skipping"
    fi
    
    echo ""
    success "Installation complete!"
    echo ""
    echo "The following files were installed:"
    echo "  ${BINDIR}/${PROGRAM}"
    echo "  ${MANDIR}/${PROGRAM}.1"
    echo ""
    
    if [[ ":$PATH:" != *":${BINDIR}:"* ]]; then
        warning "${BINDIR} is not in your PATH."
        echo ""
        echo "Add the following to your shell configuration:"
        echo "  export PATH=\"${BINDIR}:\$PATH\""
        echo ""
    else
        echo "You can now run: ${PROGRAM} --help"
    fi
}

# Uninstall files
uninstall_files() {
    info "Uninstalling from ${PREFIX}..."
    
    local use_sudo=""
    if [ ! -w "${BINDIR}" ] 2>/dev/null; then
        use_sudo="sudo"
    fi
    
    local removed=false
    
    if [ -f "${BINDIR}/${PROGRAM}" ]; then
        info "Removing binary..."
        ${use_sudo} rm -f "${BINDIR}/${PROGRAM}"
        success "Removed: ${BINDIR}/${PROGRAM}"
        removed=true
    fi
    
    if [ -f "${MANDIR}/${PROGRAM}.1" ]; then
        info "Removing man page..."
        ${use_sudo} rm -f "${MANDIR}/${PROGRAM}.1"
        success "Removed: ${MANDIR}/${PROGRAM}.1"
        removed=true
    fi
    
    if $removed; then
        echo ""
        success "Uninstallation complete!"
    else
        warning "No installed files found at ${PREFIX}"
    fi
}

# Get the script's directory
get_script_dir() {
    local script_path="${BASH_SOURCE[0]}"
    
    while [ -L "$script_path" ]; do
        local link_target="$(readlink "$script_path")"
        if [[ "$link_target" == /* ]]; then
            script_path="$link_target"
        else
            script_path="$(dirname "$script_path")/$link_target"
        fi
    done
    
    cd "$(dirname "$script_path")" && pwd
}

# Main function
main() {
    echo "========================================"
    echo " ${PROGRAM} Installer v${VERSION}"
    echo "========================================"
    echo ""
    
    local script_dir="$(get_script_dir)"
    cd "$script_dir" || {
        error "Cannot change to script directory: $script_dir"
        exit 1
    }
    
    if [ ! -f "Makefile" ] || [ ! -f "main.c" ]; then
        error "Source files not found in current directory."
        error "Please run this script from the carbon2cocoa source directory."
        exit 1
    fi
    
    detect_os
    
    case "${OS_TYPE}" in
        macos|linux|freebsd) ;;
        *)
            warning "This OS (${OS_PRETTY}) has not been tested."
            if ! prompt_yn "Continue anyway?" "n"; then
                exit 0
            fi
            ;;
    esac
    
    echo ""
    
    if $UNINSTALL; then
        uninstall_files
        exit 0
    fi
    
    check_prereqs
    echo ""
    build_project
    echo ""
    
    echo "Installation summary:"
    echo "  Binary:    ${BINDIR}/${PROGRAM}"
    echo "  Man page:  ${MANDIR}/${PROGRAM}.1"
    echo ""
    
    if prompt_yn "Proceed with installation?" "y"; then
        install_files
    else
        echo ""
        info "Installation cancelled."
        echo "The binary has been built. You can:"
        echo "  - Run it directly: ./${PROGRAM} --help"
        echo "  - Install manually: sudo make install PREFIX=${PREFIX}"
    fi
}

main "$@"