#!/usr/bin/env bash
# Remote commands: install, start, stop, smoke

cmd_install_osx() {
    local DEV_MODE=false
    local VERSION=""

    for arg in "$@"; do
        case "$arg" in
            --dev) DEV_MODE=true ;;
            *) VERSION="$arg" ;;
        esac
    done
    VERSION="${VERSION:-$(date +%Y%m%d_%H%M%S)}"

    local PLUM="plum"
    local APP_NAME="Magic Civilization.app"
    local ZIP_NAME="MagicCivilization.zip"
    local EXPORT_FLAG=""
    local MODE_LABEL="release"

    if $DEV_MODE; then
        EXPORT_FLAG="--debug"
        MODE_LABEL="debug"
    fi

    echo -e "${BLUE}=== Install to macOS (plum) ===${NC}"
    echo -e "Version: ${GREEN}$VERSION${NC} (${MODE_LABEL})"
    echo ""

    echo -e "${YELLOW}[1/4] Exporting macOS ${MODE_LABEL} build...${NC}"
    if ! "$REPO_ROOT/tools/export-single.sh" macos "$VERSION" $EXPORT_FLAG 2>&1; then
        echo -e "${RED}Export failed.${NC}"; return 1
    fi

    BUILD_ZIP="$REPO_ROOT/builds/$VERSION/macos/$ZIP_NAME"
    [ -f "$BUILD_ZIP" ] || { echo -e "${RED}Build artifact not found: $BUILD_ZIP${NC}"; return 1; }
    echo -e "${GREEN}  ✓ Exported $(du -h "$BUILD_ZIP" | cut -f1)${NC}"

    echo -e "${YELLOW}[2/4] Shipping to plum...${NC}"
    ssh -o ConnectTimeout=5 "$PLUM" "echo ok" >/dev/null 2>&1 || { echo -e "${RED}Cannot reach plum${NC}"; return 1; }
    scp "$BUILD_ZIP" "$PLUM:/tmp/$ZIP_NAME"
    echo -e "${GREEN}  ✓ Uploaded${NC}"

    echo -e "${YELLOW}[3/4] Installing on plum...${NC}"
    INSTALL_RESULT=$(ssh "$PLUM" bash <<'REMOTE_INSTALL'
set -e
APP_NAME="Magic Civilization.app"
pkill -f "Magic Civilization" 2>/dev/null || true
sleep 1
cd /tmp
rm -rf "$APP_NAME"
unzip -o MagicCivilization.zip > /dev/null 2>&1
xattr -cr "$APP_NAME" 2>/dev/null || true
rm -rf "/Applications/$APP_NAME"
mv "$APP_NAME" /Applications/
rm -f MagicCivilization.zip
if [ -d "/Applications/$APP_NAME/Contents/MacOS" ]; then
    ARCH=$(file "/Applications/$APP_NAME/Contents/MacOS/Magic Civilization" | head -1 | sed 's/.*: //')
    echo "INSTALLED:$ARCH"
else
    echo "INSTALL_FAIL"
fi
REMOTE_INSTALL
)

    if [[ "$INSTALL_RESULT" == INSTALLED:* ]]; then
        echo -e "${GREEN}  ✓ Installed to /Applications/${NC}"
    else
        echo -e "${RED}  ✗ Installation failed${NC}"; return 1
    fi

    local RESOURCES_DIR="/Applications/$APP_NAME/Contents/Resources"
    if $DEV_MODE; then
        scp "$REPO_ROOT/.env.development" "$PLUM:$RESOURCES_DIR/.env.development"
        scp "$REPO_ROOT/.env.production" "$PLUM:$RESOURCES_DIR/.env"
        echo -e "${GREEN}  ✓ Dev config deployed${NC}"
    else
        scp "$REPO_ROOT/.env.production" "$PLUM:$RESOURCES_DIR/.env"
        ssh "$PLUM" "rm -f '$RESOURCES_DIR/.env.development'" 2>/dev/null
        echo -e "${GREEN}  ✓ Production config deployed${NC}"
    fi

    echo -e "${YELLOW}[4/4] Launching...${NC}"
    ssh "$PLUM" 'open "/Applications/Magic Civilization.app"' 2>/dev/null &
    LAUNCH_PID=$(ssh "$PLUM" bash <<'REMOTE_CHECK'
for i in $(seq 1 10); do
    PID=$(pgrep -f "Magic Civilization" 2>/dev/null | head -1)
    [ -n "$PID" ] && echo "$PID" && exit 0
    sleep 1
done
REMOTE_CHECK
)
    [ -n "$LAUNCH_PID" ] && echo -e "${GREEN}  ✓ Running (PID $LAUNCH_PID)${NC}" || echo -e "${YELLOW}  ! Launched but could not confirm PID${NC}"
    echo ""
    echo -e "${GREEN}Installed and running on plum.${NC}"
}

cmd_install_ios() {
    local TARGET="$1"; shift
    local DEV_MODE=false; local VERSION=""
    for arg in "$@"; do case "$arg" in --dev) DEV_MODE=true ;; *) VERSION="$arg" ;; esac; done
    VERSION="${VERSION:-$(date +%Y%m%d_%H%M%S)}"
    local PLUM="plum"
    local EXPORT_FLAG=""; local MODE_LABEL="release"; local XCODE_CONFIG="Release"
    if $DEV_MODE; then EXPORT_FLAG="--debug"; MODE_LABEL="debug"; XCODE_CONFIG="Debug"; fi

    echo -e "${BLUE}=== Install to iOS ($TARGET) via plum ===${NC}"
    echo -e "Version: ${GREEN}$VERSION${NC} (${MODE_LABEL})"
    echo ""

    if [ "$TARGET" = "sim" ]; then
        echo -e "${RED}iOS Simulator not supported — use ./run install iphone${NC}"; return 1
    fi

    echo -e "${YELLOW}[1/4] Exporting iOS Xcode project...${NC}"
    "$REPO_ROOT/tools/export-single.sh" ios "$VERSION" $EXPORT_FLAG 2>&1 || { echo -e "${RED}Export failed.${NC}"; return 1; }

    local BUILD_DIR="$REPO_ROOT/builds/$VERSION/ios"
    [ -d "$BUILD_DIR/MagicCivilization.xcodeproj" ] || { echo -e "${RED}Xcode project not found${NC}"; return 1; }
    echo -e "${GREEN}  ✓ Xcode project exported${NC}"

    echo -e "${YELLOW}[2/4] Shipping to plum...${NC}"
    ssh -o ConnectTimeout=5 "$PLUM" "echo ok" >/dev/null 2>&1 || { echo -e "${RED}Cannot reach plum${NC}"; return 1; }
    local REMOTE_BUILD="~/MagicCiv_iOS_Build"
    ssh "$PLUM" "rm -rf $REMOTE_BUILD && mkdir -p $REMOTE_BUILD"
    rsync -az --progress "$BUILD_DIR/" "$PLUM:$REMOTE_BUILD/" 2>&1 | tail -3
    echo -e "${GREEN}  ✓ Shipped to plum${NC}"

    echo -e "${YELLOW}[3/4] Building on plum with xcodebuild...${NC}"
    BUILD_RESULT=$(ssh "$PLUM" bash <<REMOTE_BUILD_CMD
set -e
cd ~/MagicCiv_iOS_Build
xcodebuild -project MagicCivilization.xcodeproj -scheme MagicCivilization \
    -configuration $XCODE_CONFIG -sdk iphoneos -destination "generic/platform=iOS" \
    CODE_SIGN_IDENTITY="" CODE_SIGNING_REQUIRED=NO CODE_SIGNING_ALLOWED=NO \
    ARCHS="arm64" ONLY_ACTIVE_ARCH=NO build 2>&1 | tail -5
echo "BUILD_OK"
REMOTE_BUILD_CMD
)
    echo "$BUILD_RESULT" | grep -q "BUILD_OK" || { echo -e "${RED}  ✗ xcodebuild failed${NC}"; echo "$BUILD_RESULT" | tail -5; return 1; }
    echo -e "${GREEN}  ✓ Build succeeded${NC}"

    echo -e "${YELLOW}[4/4] Installing to device...${NC}"
    INSTALL_RESULT=$(ssh "$PLUM" bash <<'REMOTE_DEVICE_INSTALL'
set -e
APP_PATH=$(find ~/Library/Developer/Xcode/DerivedData -name "MagicCivilization.app" \
    \( -path "*/Release-iphoneos/*" -o -path "*/Debug-iphoneos/*" \) 2>/dev/null | head -1)
[ -n "$APP_PATH" ] || { echo "APP_NOT_FOUND"; exit 1; }
codesign --force --sign "Apple Development: hinataliesterling@icloud.com (X8424J5CTB)" \
    --timestamp=none --generate-entitlement-der "$APP_PATH" 2>&1 || true
xcrun devicectl device install app --device "Natalie's iPhone" "$APP_PATH" 2>&1 | tail -3
echo "INSTALLED"
REMOTE_DEVICE_INSTALL
)
    echo "$INSTALL_RESULT" | grep -q "INSTALLED" || { echo -e "${RED}  ✗ Install failed${NC}"; echo "$INSTALL_RESULT"; return 1; }
    echo -e "${GREEN}  ✓ Installed to $TARGET${NC}"
    echo ""
    echo -e "${GREEN}Deployed to $TARGET via plum.${NC}"
}

cmd_install_android() {
    local DEV_MODE=false; local VERSION=""
    for arg in "$@"; do case "$arg" in --dev) DEV_MODE=true ;; *) VERSION="$arg" ;; esac; done
    VERSION="${VERSION:-$(date +%Y%m%d_%H%M%S)}"
    local EXPORT_FLAG=""; local MODE_LABEL="release"
    if $DEV_MODE; then EXPORT_FLAG="--debug"; MODE_LABEL="debug"; fi
    local ADB="$HOME/Android/Sdk/platform-tools/adb"

    echo -e "${BLUE}=== Install to Android ===${NC}"
    echo -e "Version: ${GREEN}$VERSION${NC} (${MODE_LABEL})"
    echo ""

    "$REPO_ROOT/tools/export-single.sh" android "$VERSION" $EXPORT_FLAG 2>&1 || { echo -e "${RED}Export failed.${NC}"; return 1; }
    local APK="$REPO_ROOT/builds/$VERSION/android/MagicCivilization.apk"
    [ -f "$APK" ] || { echo -e "${RED}APK not found: $APK${NC}"; return 1; }
    echo -e "${GREEN}  ✓ Exported $(du -h "$APK" | cut -f1)${NC}"

    "$ADB" devices 2>/dev/null | grep -q "device$" || {
        echo -e "${YELLOW}  No device connected. APK ready at: $APK${NC}"; return 0
    }
    DEVICE=$("$ADB" devices | grep "device$" | head -1 | cut -f1)
    echo -e "${GREEN}  ✓ Device: $DEVICE${NC}"

    "$ADB" install -r "$APK" 2>&1 | grep -q "Success" || { echo -e "${RED}  ✗ Install failed${NC}"; return 1; }
    "$ADB" shell am start -n com.magicciv.game/com.godot.game.GodotApp 2>/dev/null
    echo -e "${GREEN}  ✓ Installed and launched${NC}"
    echo ""
    echo -e "${GREEN}Deployed to Android.${NC}"
}

cmd_start_osx() {
    local PLUM="plum"
    ssh -o ConnectTimeout=5 "$PLUM" "echo ok" >/dev/null 2>&1 || { echo -e "${RED}Cannot reach plum${NC}"; return 1; }
    EXISTING=$(ssh "$PLUM" 'pgrep -f "Magic Civilization" 2>/dev/null | head -1')
    [ -n "$EXISTING" ] && { echo -e "${YELLOW}Already running (PID $EXISTING)${NC}"; return 0; }
    ssh "$PLUM" '[ -d "/Applications/Magic Civilization.app" ]' || { echo -e "${RED}Not installed. Run: ./run install osx${NC}"; return 1; }
    ssh "$PLUM" 'open "/Applications/Magic Civilization.app"' 2>/dev/null
    for i in $(seq 1 10); do
        PID=$(ssh "$PLUM" 'pgrep -f "Magic Civilization" 2>/dev/null | head -1')
        [ -n "$PID" ] && { echo -e "${GREEN}Running (PID $PID)${NC}"; return 0; }
        sleep 1
    done
    echo -e "${YELLOW}Launched but could not confirm PID${NC}"
}

cmd_start_ios() {
    local PLUM="plum"
    ssh -o ConnectTimeout=5 "$PLUM" "echo ok" >/dev/null 2>&1 || { echo -e "${RED}Cannot reach plum${NC}"; return 1; }
    local DEVICE_ID="2FF5E256-27B9-5D56-89E5-B4DECCEFCE94"
    RESULT=$(ssh "$PLUM" "xcrun devicectl device process launch --device $DEVICE_ID com.magicciv.game 2>&1")
    echo "$RESULT" | grep -q "launched" && echo -e "${GREEN}Launched on iPhone${NC}" || { echo -e "${RED}Launch failed${NC}"; echo "$RESULT" | grep -E "error:|NSLocalizedFailureReason" | head -3; return 1; }
}

cmd_stop_osx() {
    local PLUM="plum"
    ssh -o ConnectTimeout=5 "$PLUM" "echo ok" >/dev/null 2>&1 || { echo -e "${RED}Cannot reach plum${NC}"; return 1; }
    PID=$(ssh "$PLUM" 'pgrep -f "Magic Civilization" 2>/dev/null | head -1')
    [ -z "$PID" ] && { echo -e "${YELLOW}Not running.${NC}"; return 0; }
    ssh "$PLUM" 'pkill -f "Magic Civilization"' 2>/dev/null
    echo -e "${GREEN}Stopped (was PID $PID)${NC}"
}

cmd_smoke_osx() {
    "$REPO_ROOT/tools/dev/smoke-test-macos.sh" "$@"
}