#!/usr/bin/env bash
# Populate src-tauri/gen/android with the parts `tauri android init` cannot know
# about.
#
# `tauri android init` regenerates gen/android from tauri.conf.json, and gen/ is
# not tracked (see .gitignore). Anything hand-maintained therefore lives under
# src-tauri/android/ and is copied in by this script after every init. Run it
# between `tauri android init` and `tauri android build`.
#
# Two kinds of thing are copied:
#
#   1. Our own files — AndroidManifest.xml (BLE permissions), MainActivity.kt,
#      the app build.gradle.kts (signing config + BLE Java sources), ProGuard
#      keep rules.
#
#   2. btleplug's Android backend, which is a *hybrid* Rust/Java crate: the Rust
#      side registers native methods on Java classes that must be compiled into
#      the APK. Upstream tells you to publish a SNAPSHOT maven artifact; we
#      instead lift the Java straight out of the crate sources that Cargo has
#      already downloaded, keyed on the exact versions in Cargo.lock. That makes
#      a Java/Rust version mismatch — the failure mode here is a
#      NoSuchMethodError at first scan, not a build error — impossible by
#      construction.
set -euo pipefail

ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
SRC="$ROOT/src-tauri/android"
GEN="$ROOT/src-tauri/gen/android"
APP="$GEN/app/src/main"
PKG_PATH="paris/tourolle/bikecontrol"

if [ ! -d "$GEN" ]; then
  echo "❌ $GEN does not exist — run 'cargo tauri android init' first." >&2
  exit 1
fi

echo "Syncing Android sources into gen/android…"

# ---------------------------------------------------------------------------
# 1. Our own files.

mkdir -p "$APP/java/$PKG_PATH"
cp "$SRC/src/main/java/$PKG_PATH/MainActivity.kt" "$APP/java/$PKG_PATH/MainActivity.kt"
echo "  ✓ MainActivity.kt"

# Gradle reads ONLY the gen/ copy — there is no manifest-merger hook for our
# entries — so this tracked file must be the complete manifest.
cp "$SRC/src/main/AndroidManifest.xml" "$APP/AndroidManifest.xml"
echo "  ✓ AndroidManifest.xml"

cp "$SRC/app/build.gradle.kts" "$GEN/app/build.gradle.kts"
echo "  ✓ app/build.gradle.kts"

# build.gradle.kts globs **/*.pro, so dropping this in app/ is enough.
cp "$SRC/app/proguard-bikecontrol.pro" "$GEN/app/proguard-bikecontrol.pro"
echo "  ✓ proguard-bikecontrol.pro"

if [ -d "$SRC/src/main/res" ]; then
  for dir in "$SRC/src/main/res"/*/; do
    [ -d "$dir" ] || continue
    name="$(basename "$dir")"
    mkdir -p "$APP/res/$name"
    cp "$dir"/* "$APP/res/$name/"
    echo "  ✓ res/$name"
  done
fi

# ---------------------------------------------------------------------------
# 2. btleplug's Java backend, at the versions Cargo.lock pins.

crate_version() {
  # First `version = "x"` line after the crate's `name =` line in Cargo.lock.
  awk -v pkg="name = \"$1\"" '
    $0 == pkg { found = 1; next }
    found && /^version = / { gsub(/[",]/, "", $3); print $3; exit }
  ' "$ROOT/Cargo.lock"
}

crate_src() {
  local name="$1" version="$2" dir
  for dir in "${CARGO_HOME:-$HOME/.cargo}"/registry/src/*/"$name-$version"; do
    [ -d "$dir" ] && { printf '%s' "$dir"; return 0; }
  done
  return 1
}

BTLEPLUG_VERSION="$(crate_version btleplug)"
JNI_UTILS_VERSION="$(crate_version jni-utils)"

if [ -z "$BTLEPLUG_VERSION" ] || [ -z "$JNI_UTILS_VERSION" ]; then
  echo "❌ Could not read btleplug/jni-utils versions from Cargo.lock." >&2
  exit 1
fi

# jni-utils is an Android-only dependency of btleplug, so a plain `cargo fetch`
# for the host will not have downloaded it.
if ! crate_src jni-utils "$JNI_UTILS_VERSION" >/dev/null; then
  echo "  ↓ fetching Android-target crate sources"
  (cd "$ROOT" && cargo fetch --target aarch64-linux-android >/dev/null)
fi

BTLEPLUG_SRC="$(crate_src btleplug "$BTLEPLUG_VERSION")" || {
  echo "❌ btleplug $BTLEPLUG_VERSION sources not found in the cargo registry." >&2
  exit 1
}
JNI_UTILS_SRC="$(crate_src jni-utils "$JNI_UTILS_VERSION")" || {
  echo "❌ jni-utils $JNI_UTILS_VERSION sources not found in the cargo registry." >&2
  exit 1
}

# Drop any previous copy first: a class left behind from an older crate version
# would still compile and would still be found at runtime.
rm -rf "$APP/java/com/nonpolynomial" "$APP/java/io/github/gedgygedgy"
mkdir -p "$APP/java"

cp -r "$BTLEPLUG_SRC/src/droidplug/java/src/main/java/com" "$APP/java/"
echo "  ✓ btleplug $BTLEPLUG_VERSION Java backend (com.nonpolynomial.btleplug)"

cp -r "$JNI_UTILS_SRC/java/src/main/java/io" "$APP/java/"
echo "  ✓ jni-utils $JNI_UTILS_VERSION Java support (io.github.gedgygedgy.rust)"

echo "✅ Android sources synced"