install.sh

#!/usr/bin/env bash
#
# gsheet-cli installer
# https://github.com/dipankar/gsheet-cli
#
# Usage:
#   curl -fsSL https://raw.githubusercontent.com/dipankar/gsheet-cli/main/install.sh | bash
#   or
#   ./install.sh [OPTIONS]
#
# Options:
#   --prefix DIR      Installation prefix (default: ~/.local)
#   --completions     Install shell completions
#   --no-modify-path  Don't modify shell profile
#   --help            Show this help message
#

set -e

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

# Defaults
PREFIX="${HOME}/.local"
INSTALL_COMPLETIONS=false
MODIFY_PATH=true
BIN_NAME="gsheet"

# Print functions
info() {
    echo -e "${BLUE}==>${NC} ${BOLD}$1${NC}"
}

success() {
    echo -e "${GREEN}==>${NC} ${BOLD}$1${NC}"
}

warn() {
    echo -e "${YELLOW}Warning:${NC} $1"
}

error() {
    echo -e "${RED}Error:${NC} $1" >&2
    exit 1
}

# Show help
show_help() {
    cat << EOF
gsheet-cli installer

Usage: ./install.sh [OPTIONS]

Options:
    --prefix DIR        Installation prefix (default: ~/.local)
    --completions       Install shell completions
    --no-modify-path    Don't modify shell profile
    --help              Show this help message

Examples:
    ./install.sh
    ./install.sh --prefix /usr/local --completions
    ./install.sh --prefix ~/.local --completions --no-modify-path

EOF
    exit 0
}

# Parse arguments
while [[ $# -gt 0 ]]; do
    case $1 in
        --prefix)
            PREFIX="$2"
            shift 2
            ;;
        --completions)
            INSTALL_COMPLETIONS=true
            shift
            ;;
        --no-modify-path)
            MODIFY_PATH=false
            shift
            ;;
        --help|-h)
            show_help
            ;;
        *)
            error "Unknown option: $1. Use --help for usage."
            ;;
    esac
done

# Detect OS
detect_os() {
    case "$(uname -s)" in
        Linux*)     OS=linux;;
        Darwin*)    OS=macos;;
        MINGW*|MSYS*|CYGWIN*) OS=windows;;
        *)          OS=unknown;;
    esac
    echo "$OS"
}

# Detect shell
detect_shell() {
    basename "${SHELL:-/bin/bash}"
}

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

# Check Rust installation
check_rust() {
    if ! command_exists rustc; then
        warn "Rust is not installed."
        info "Installing Rust via rustup..."
        curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
        source "${HOME}/.cargo/env"
    fi

    RUST_VERSION=$(rustc --version | cut -d' ' -f2)
    info "Rust version: $RUST_VERSION"
}

# Build from source
build_from_source() {
    info "Building gsheet-cli from source..."

    # Check if we're in the repo directory
    if [[ -f "Cargo.toml" ]] && grep -q 'name = "gsheet-cli"' Cargo.toml 2>/dev/null; then
        info "Building in current directory..."
        cargo build --release
    else
        # Clone the repo
        TEMP_DIR=$(mktemp -d)
        info "Cloning repository to $TEMP_DIR..."
        git clone --depth 1 https://github.com/dipankar/gsheet-cli.git "$TEMP_DIR"
        cd "$TEMP_DIR"
        cargo build --release

        # Copy binary
        mkdir -p "${PREFIX}/bin"
        cp "target/release/${BIN_NAME}" "${PREFIX}/bin/"

        # Cleanup
        cd - >/dev/null
        rm -rf "$TEMP_DIR"
        return
    fi

    # Copy binary from local build
    mkdir -p "${PREFIX}/bin"
    cp "target/release/${BIN_NAME}" "${PREFIX}/bin/"
}

# Install shell completions
install_completions() {
    local shell=$(detect_shell)
    local bin="${PREFIX}/bin/${BIN_NAME}"

    if [[ ! -x "$bin" ]]; then
        warn "Binary not found at $bin, skipping completions"
        return
    fi

    info "Installing completions for $shell..."

    case "$shell" in
        bash)
            COMP_DIR="${HOME}/.local/share/bash-completion/completions"
            mkdir -p "$COMP_DIR"
            "$bin" completions bash > "${COMP_DIR}/${BIN_NAME}"
            success "Bash completions installed to ${COMP_DIR}/${BIN_NAME}"
            ;;
        zsh)
            COMP_DIR="${HOME}/.zfunc"
            mkdir -p "$COMP_DIR"
            "$bin" completions zsh > "${COMP_DIR}/_${BIN_NAME}"
            success "Zsh completions installed to ${COMP_DIR}/_${BIN_NAME}"
            echo ""
            echo "Add to your ~/.zshrc if not already present:"
            echo "  fpath=(~/.zfunc \$fpath)"
            echo "  autoload -Uz compinit && compinit"
            ;;
        fish)
            COMP_DIR="${HOME}/.config/fish/completions"
            mkdir -p "$COMP_DIR"
            "$bin" completions fish > "${COMP_DIR}/${BIN_NAME}.fish"
            success "Fish completions installed to ${COMP_DIR}/${BIN_NAME}.fish"
            ;;
        *)
            warn "Unknown shell: $shell. Skipping completions."
            ;;
    esac
}

# Add to PATH in shell profile
add_to_path() {
    local shell=$(detect_shell)
    local bin_dir="${PREFIX}/bin"
    local profile=""
    local path_line="export PATH=\"${bin_dir}:\$PATH\""

    # Check if already in PATH
    if echo "$PATH" | tr ':' '\n' | grep -q "^${bin_dir}$"; then
        info "Directory already in PATH"
        return
    fi

    case "$shell" in
        bash)
            if [[ -f "${HOME}/.bashrc" ]]; then
                profile="${HOME}/.bashrc"
            elif [[ -f "${HOME}/.bash_profile" ]]; then
                profile="${HOME}/.bash_profile"
            fi
            ;;
        zsh)
            profile="${HOME}/.zshrc"
            ;;
        fish)
            profile="${HOME}/.config/fish/config.fish"
            path_line="set -gx PATH ${bin_dir} \$PATH"
            ;;
    esac

    if [[ -n "$profile" ]]; then
        if ! grep -q "${bin_dir}" "$profile" 2>/dev/null; then
            echo "" >> "$profile"
            echo "# Added by gsheet-cli installer" >> "$profile"
            echo "$path_line" >> "$profile"
            success "Added ${bin_dir} to PATH in ${profile}"
            echo ""
            echo "Run this to update your current session:"
            echo "  source ${profile}"
        else
            info "PATH already configured in ${profile}"
        fi
    else
        warn "Could not detect shell profile. Add this to your shell config:"
        echo "  $path_line"
    fi
}

# Create config directory
create_config_dir() {
    local config_dir="${HOME}/.config/gsheet-cli"

    if [[ ! -d "$config_dir" ]]; then
        mkdir -p "$config_dir"
        info "Created config directory: $config_dir"
    fi
}

# Print post-install instructions
print_instructions() {
    echo ""
    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
    success "gsheet-cli installed successfully!"
    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
    echo ""
    echo "Binary location: ${PREFIX}/bin/${BIN_NAME}"
    echo ""
    echo "Next steps:"
    echo ""
    echo "  1. Authenticate with Google Sheets:"
    echo "     ${BIN_NAME} auth login"
    echo ""
    echo "  2. Add a spreadsheet profile:"
    echo "     ${BIN_NAME} config profile add mysheet --spreadsheet \"YOUR_SPREADSHEET_ID\""
    echo ""
    echo "  3. Start using:"
    echo "     ${BIN_NAME} -p mysheet sheet list"
    echo ""
    echo "Documentation: https://github.com/dipankar/gsheet-cli"
    echo ""
}

# Main installation flow
main() {
    echo ""
    echo "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓"
    echo "┃                    gsheet-cli installer                     ┃"
    echo "┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛"
    echo ""

    OS=$(detect_os)
    info "Detected OS: $OS"
    info "Installation prefix: $PREFIX"

    # Check dependencies
    if ! command_exists git; then
        error "git is required but not installed. Please install git first."
    fi

    # Check/install Rust
    check_rust

    # Build and install
    build_from_source

    # Create config directory
    create_config_dir

    # Install completions if requested
    if [[ "$INSTALL_COMPLETIONS" == "true" ]]; then
        install_completions
    fi

    # Add to PATH if requested
    if [[ "$MODIFY_PATH" == "true" ]]; then
        add_to_path
    fi

    # Verify installation
    if [[ -x "${PREFIX}/bin/${BIN_NAME}" ]]; then
        VERSION=$("${PREFIX}/bin/${BIN_NAME}" --version 2>/dev/null || echo "unknown")
        success "Installed: $VERSION"
    else
        error "Installation failed. Binary not found at ${PREFIX}/bin/${BIN_NAME}"
    fi

    print_instructions
}

# Run main
main