#!/bin/bash
# FTC Project Generator - Shared Library Functions
# Copyright (c) 2026 Nexus Workshops LLC
# Licensed under MIT License

# Get the directory where this script lives
get_script_dir() {
    echo "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
}

# Get generator version
get_generator_version() {
    local script_dir="$(get_script_dir)"
    local version_file="$script_dir/../VERSION"
    if [ -f "$version_file" ]; then
        cat "$version_file" | tr -d '\n\r'
    else
        echo "unknown"
    fi
}

# Process template file, replacing placeholders
process_template() {
    local input="$1"
    local output="$2"
    
    sed -e "s|{{PROJECT_NAME}}|${PROJECT_NAME}|g" \
        -e "s|{{SDK_DIR}}|${FTC_SDK_DIR}|g" \
        -e "s|{{FTC_VERSION}}|${FTC_VERSION}|g" \
        -e "s|{{GENERATOR_VERSION}}|${GENERATOR_VERSION}|g" \
        "$input" > "$output"
}

# Copy template file
copy_template() {
    local src="$1"
    local dest="$2"
    cp "$src" "$dest"
}

# Create project structure
create_project_structure() {
    local project_dir="$1"
    
    mkdir -p "$project_dir"
    cd "$project_dir"
    
    mkdir -p src/main/java/robot/subsystems
    mkdir -p src/main/java/robot/hardware
    mkdir -p src/main/java/robot/opmodes
    mkdir -p src/test/java/robot/subsystems
    mkdir -p src/test/java/robot/hardware
    mkdir -p gradle/wrapper
}

# Install all project templates
install_templates() {
    local project_dir="$1"
    local template_dir="$2"
    
    cd "$project_dir"
    
    copy_template "$template_dir/Pose2d.java" "src/main/java/robot/Pose2d.java"
    copy_template "$template_dir/Drive.java" "src/main/java/robot/subsystems/Drive.java"
    copy_template "$template_dir/MecanumDrive.java" "src/main/java/robot/hardware/MecanumDrive.java"
    copy_template "$template_dir/TeleOp.java" "src/main/java/robot/opmodes/TeleOp.java"
    copy_template "$template_dir/DriveTest.java" "src/test/java/robot/subsystems/DriveTest.java"
    
    copy_template "$template_dir/build.gradle.kts" "build.gradle.kts"
    process_template "$template_dir/settings.gradle.kts.template" "settings.gradle.kts"
    process_template "$template_dir/gitignore.template" ".gitignore"
    process_template "$template_dir/README.md.template" "README.md"
    
    copy_template "$template_dir/build.sh" "build.sh"
    chmod +x "build.sh"
    
    create_deploy_script "$project_dir"
    
    echo "${GENERATOR_VERSION}" > ".ftc-generator-version"
}

# Create deploy script  
create_deploy_script() {
    local project_dir="$1"
    cat > "$project_dir/deploy-to-robot.sh" <<'ENDSCRIPT'
#!/bin/bash
set -e
CONTROL_HUB_IP="${CONTROL_HUB_IP:-192.168.43.1}"
CONTROL_HUB_PORT="5555"

while [[ $# -gt 0 ]]; do
    case $1 in
        -h|--help)
            echo "════════════════════════════════════════════════════════════════"
            echo "  Deploy FTC Project to Control Hub"
            echo "════════════════════════════════════════════════════════════════"
            echo ""
            echo "Usage: $0 [options]"
            echo ""
            echo "Options:"
            echo "  --usb              Force USB connection"
            echo "  --wifi             Force WiFi Direct connection"
            echo "  -i, --ip <ip>      Custom Control Hub IP"
            echo "  -h, --help         Show this help"
            echo ""
            echo "Examples:"
            echo "  $0                 # Auto-detect connection"
            echo "  $0 --usb           # Use USB only"
            echo "  $0 --wifi          # Use WiFi Direct"
            echo "  $0 -i 192.168.1.5  # Custom IP"
            echo ""
            exit 0
            ;;
        -i|--ip) CONTROL_HUB_IP="$2"; shift 2 ;;
        --usb) FORCE_USB=true; shift ;;
        --wifi) FORCE_WIFI=true; shift ;;
        *) shift ;;
    esac
done

echo "════════════════════════════════════════════════════════════════"
echo "  FTC Project Deployment"
echo "════════════════════════════════════════════════════════════════"
echo ""

# Step 1: Deploy code to SDK
echo "Step 1: Deploying code to SDK TeamCode..."
if ! ./gradlew deployToSDK; then
    echo ""
    echo "Error: Failed to deploy code"
    echo "Make sure you're in the project directory"
    exit 1
fi
echo "✓ Code deployed"
echo ""

# Step 2: Build APK
echo "Step 2: Building APK..."
SDK_DIR="${HOME}/ftc-sdk"

if [ ! -d "$SDK_DIR" ]; then
    echo ""
    echo "════════════════════════════════════════════════════════════════"
    echo "  Error: FTC SDK Not Found"
    echo "════════════════════════════════════════════════════════════════"
    echo ""
    echo "The FTC SDK should be at: $SDK_DIR"
    echo ""
    echo "This should have been set up when you created the project."
    echo ""
    echo "To fix:"
    echo "  git clone --depth 1 --branch v10.1.1 \\"
    echo "    https://github.com/FIRST-Tech-Challenge/FtcRobotController.git \\"
    echo "    ~/ftc-sdk"
    echo ""
    exit 1
fi

cd "$SDK_DIR" || exit 1

# Check for Android SDK configuration
if [ ! -f "local.properties" ] && [ -z "$ANDROID_HOME" ]; then
    echo ""
    echo "════════════════════════════════════════════════════════════════"
    echo "  Error: Android SDK Not Configured"
    echo "════════════════════════════════════════════════════════════════"
    echo ""
    echo "The FTC SDK needs the Android SDK to build APKs."
    echo ""
    echo "FIX OPTION 1: Set ANDROID_HOME (recommended)"
    echo "  export ANDROID_HOME=/path/to/android/sdk"
    echo "  echo 'export ANDROID_HOME=/path/to/android/sdk' >> ~/.bashrc"
    echo ""
    echo "FIX OPTION 2: Create local.properties"
    echo "  echo 'sdk.dir=/path/to/android/sdk' > ~/ftc-sdk/local.properties"
    echo ""
    echo "════════════════════════════════════════════════════════════════"
    echo "  How to Install Android SDK"
    echo "════════════════════════════════════════════════════════════════"
    echo ""
    echo "1. Download Android Studio:"
    echo "   https://developer.android.com/studio"
    echo ""
    echo "2. Install and open Android Studio"
    echo ""
    echo "3. Go to: Tools → SDK Manager"
    echo ""
    echo "4. Note the 'Android SDK Location' path shown"
    echo ""
    echo "5. Use that path in FIX OPTION 1 or 2 above"
    echo ""
    echo "Typical Android SDK locations:"
    echo "  • Linux:   ~/Android/Sdk"
    echo "  • macOS:   ~/Library/Android/sdk"
    echo "  • Windows: C:\\Users\\YourName\\AppData\\Local\\Android\\Sdk"
    echo ""
    echo "════════════════════════════════════════════════════════════════"
    echo ""
    exit 1
fi

if ! ./gradlew build; then
    echo ""
    echo "Error: APK build failed"
    echo "Check the error messages above for details"
    exit 1
fi

APK_PATH="$SDK_DIR/FtcRobotController/build/outputs/apk/debug/FtcRobotController-debug.apk"
if [ ! -f "$APK_PATH" ]; then
    echo ""
    echo "Error: APK not found at expected location"
    echo "Expected: $APK_PATH"
    exit 1
fi
echo "✓ APK built"
echo ""

# Step 3: Install to Control Hub
echo "Step 3: Installing to Control Hub..."

if ! command -v adb &> /dev/null; then
    echo ""
    echo "════════════════════════════════════════════════════════════════"
    echo "  Error: adb Command Not Found"
    echo "════════════════════════════════════════════════════════════════"
    echo ""
    echo "The 'adb' tool is needed to install APKs to the Control Hub."
    echo ""
    echo "Install:"
    echo "  • Ubuntu/Debian: sudo apt install android-tools-adb"
    echo "  • Arch Linux:    sudo pacman -S android-tools"
    echo "  • macOS:         brew install android-platform-tools"
    echo ""
    echo "Or download Android Platform Tools:"
    echo "  https://developer.android.com/studio/releases/platform-tools"
    echo ""
    exit 1
fi

INSTALLED=false

# Try USB first
if [ "$FORCE_WIFI" != "true" ]; then
    USB_COUNT=$(adb devices | grep -v "List" | grep "device$" | wc -l)
    if [ "$USB_COUNT" -gt 0 ]; then
        echo "✓ Control Hub connected via USB"
        if adb install -r "$APK_PATH"; then
            INSTALLED=true
        fi
    elif [ "$FORCE_USB" = "true" ]; then
        echo ""
        echo "Error: No USB device found (--usb specified)"
        echo ""
        echo "Make sure:"
        echo "  • Control Hub is powered on"
        echo "  • USB cable is connected"
        echo "  • USB debugging is enabled"
        echo ""
        exit 1
    fi
fi

# Try WiFi if USB didn't work
if [ "$INSTALLED" = "false" ] && [ "$FORCE_USB" != "true" ]; then
    echo "Connecting to Control Hub via WiFi ($CONTROL_HUB_IP:$CONTROL_HUB_PORT)..."
    adb connect "$CONTROL_HUB_IP:$CONTROL_HUB_PORT" 2>&1 | grep -v "cannot connect" || true
    sleep 2
    if adb devices | grep -q "$CONTROL_HUB_IP"; then
        echo "✓ Connected via WiFi"
        if adb install -r "$APK_PATH"; then
            INSTALLED=true
        fi
    fi
fi

if [ "$INSTALLED" = "false" ]; then
    echo ""
    echo "════════════════════════════════════════════════════════════════"
    echo "  Error: Could Not Connect to Control Hub"
    echo "════════════════════════════════════════════════════════════════"
    echo ""
    echo "Connection options:"
    echo ""
    echo "1. USB (Recommended)"
    echo "   • Plug Control Hub into computer"
    echo "   • Run: $0 --usb"
    echo ""
    echo "2. WiFi Direct"
    echo "   • Connect to 'FIRST-xxxx-RC' network"
    echo "   • Run: $0 --wifi"
    echo "   • Default IP: 192.168.43.1"
    echo ""
    echo "3. Custom Network"
    echo "   • Find Control Hub IP on your network"
    echo "   • Run: $0 -i YOUR_IP"
    echo ""
    echo "Debug:"
    echo "  • Check devices: adb devices"
    echo "  • Test connection: adb connect $CONTROL_HUB_IP:$CONTROL_HUB_PORT"
    echo ""
    exit 1
fi

echo ""
echo "════════════════════════════════════════════════════════════════"
echo "  ✓ Deployment Complete!"
echo "════════════════════════════════════════════════════════════════"
echo ""
echo "On Driver Station:"
echo "  1. Go to OpModes menu"
echo "  2. Select TeleOp → 'Main TeleOp'"
echo "  3. Press INIT, then START"
echo ""
echo "Your code is now running on the robot! 🤖"
echo ""
ENDSCRIPT
    chmod +x "$project_dir/deploy-to-robot.sh"
}

# Setup Gradle wrapper
setup_gradle_wrapper() {
    local project_dir="$1"
    cd "$project_dir"
    
    # Create gradle wrapper properties
    mkdir -p gradle/wrapper
    cat > gradle/wrapper/gradle-wrapper.properties <<EOF
distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-8.9-bin.zip
networkTimeout=10000
validateDistributionUrl=true
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists
EOF
    
    # Check if gradle is available
    if ! command -v gradle &> /dev/null; then
        echo "Error: gradle command not found"
        echo "Gradle must be installed to generate wrapper scripts"
        echo ""
        echo "Install:"
        echo "  Ubuntu/Debian: sudo apt install gradle"
        echo "  macOS: brew install gradle"
        return 1
    fi
    
    echo "Generating Gradle wrapper..."
    
    # Try with system gradle first
    if gradle wrapper --gradle-version 8.9 --no-daemon 2>/dev/null; then
        echo "✓ Gradle wrapper created"
    else
        echo ""
        echo "System Gradle failed. Using fallback method..."
        
        # Download wrapper jar directly
        local wrapper_jar_url="https://raw.githubusercontent.com/gradle/gradle/v8.9.0/gradle/wrapper/gradle-wrapper.jar"
        if command -v curl &> /dev/null; then
            curl -sL "$wrapper_jar_url" -o gradle/wrapper/gradle-wrapper.jar 2>/dev/null
        elif command -v wget &> /dev/null; then
            wget -q "$wrapper_jar_url" -O gradle/wrapper/gradle-wrapper.jar 2>/dev/null
        else
            echo "Error: Need curl or wget to download wrapper jar"
            return 1
        fi
        
        if [ ! -f "gradle/wrapper/gradle-wrapper.jar" ]; then
            echo "Error: Failed to download gradle-wrapper.jar"
            return 1
        fi
        
        # Create proper gradlew script
        cat > gradlew <<'GRADLEW_END'
#!/bin/sh

APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
APP_BASE_NAME=${0##*/}

# Determine the Java command
if [ -n "$JAVA_HOME" ] ; then
    JAVACMD=$JAVA_HOME/bin/java
else
    JAVACMD=java
fi

# Check if Java is available
if ! "$JAVACMD" -version > /dev/null 2>&1; then
    echo "ERROR: JAVA_HOME is not set and no 'java' command could be found"
    exit 1
fi

# Execute Gradle
exec "$JAVACMD" -Xmx64m -Xms64m -Dorg.gradle.appname="$APP_BASE_NAME" -classpath "$(dirname "$0")/gradle/wrapper/gradle-wrapper.jar" org.gradle.wrapper.GradleWrapperMain "$@"
GRADLEW_END
        chmod +x gradlew
        
        # Create Windows batch file
        cat > gradlew.bat <<'GRADLEWBAT_END'
@if "%DEBUG%" == "" @echo off
setlocal enabledelayedexpansion
set DIRNAME=%~dp0
set APP_BASE_NAME=%~n0
set APP_HOME=%DIRNAME%
set CLASSPATH=%APP_HOME%gradle\wrapper\gradle-wrapper.jar
if defined JAVA_HOME goto findJavaFromJavaHome
set JAVA_EXE=java.exe
goto execute
:findJavaFromJavaHome
set JAVA_HOME=%JAVA_HOME:"=%
set JAVA_EXE=%JAVA_HOME%\bin\java.exe
:execute
"%JAVA_EXE%" -Xmx64m -Xms64m -Dorg.gradle.appname="%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
:end
GRADLEWBAT_END
        
        echo "✓ Gradle wrapper created (via fallback)"
    fi
    
    # Verify wrapper was created
    if [ ! -f "gradlew" ]; then
        echo "Error: gradlew script not created"
        return 1
    fi
}

# Check if project is a generator project
is_generator_project() {
    local project_dir="$1"
    [ -f "$project_dir/.ftc-generator-version" ]
}

# Get project generator version
get_project_generator_version() {
    local project_dir="$1"
    if [ -f "$project_dir/.ftc-generator-version" ]; then
        cat "$project_dir/.ftc-generator-version" | tr -d '\n\r'
    else
        echo "unknown"
    fi
}

# Upgrade project
upgrade_project() {
    local project_dir="$1"
    local template_dir="$2"
    local old_version=$(get_project_generator_version "$project_dir")
    
    echo "Upgrading project from $old_version to ${GENERATOR_VERSION}..."
    
    cd "$project_dir"
    
    copy_template "$template_dir/build.gradle.kts" "build.gradle.kts"
    process_template "$template_dir/settings.gradle.kts.template" "settings.gradle.kts"
    process_template "$template_dir/gitignore.template" ".gitignore"
    
    copy_template "$template_dir/build.sh" "build.sh"
    chmod +x "build.sh"
    create_deploy_script "$project_dir"
    
    echo "${GENERATOR_VERSION}" > ".ftc-generator-version"
    
    echo "✓ Upgrade complete"
}

# Initialize git repo
init_git_repo() {
    local project_dir="$1"
    cd "$project_dir"
    if [ ! -d ".git" ]; then
        git init > /dev/null 2>&1
        git add . > /dev/null 2>&1
        git commit -m "Initial commit from FTC Project Generator v${GENERATOR_VERSION}" > /dev/null 2>&1
        echo "✓ Git repository initialized"
    fi
}

# Check prerequisites
check_prerequisites() {
    local missing=()
    
    command -v git &> /dev/null || missing+=("git")
    command -v java &> /dev/null || missing+=("java")
    command -v gradle &> /dev/null || missing+=("gradle")
    
    if [ "${#missing[@]}" -gt 0 ]; then
        echo "Error: Missing tools: ${missing[*]}"
        echo "Install: sudo apt install ${missing[*]}"
        return 1
    fi
    
    echo "✓ All prerequisites satisfied"
    return 0
}