#!/bin/bash

# Create Android AAR with mock native libraries
set -e

PROJECT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
AAR_DIR="$PROJECT_DIR/android-example/app/libs/aar-temp"
BINDINGS_DIR="$PROJECT_DIR/bindings/android/generated"

echo "Creating Android AAR structure..."

# Clean and create AAR directory
rm -rf "$AAR_DIR"
mkdir -p "$AAR_DIR"

# Create required directories
mkdir -p "$AAR_DIR/META-INF"
mkdir -p "$AAR_DIR/classes/org/guardianproject/proofmode"
mkdir -p "$AAR_DIR/jni/arm64-v8a"
mkdir -p "$AAR_DIR/jni/armeabi-v7a"
mkdir -p "$AAR_DIR/jni/x86"
mkdir -p "$AAR_DIR/jni/x86_64"

# Create AndroidManifest.xml
cat > "$AAR_DIR/AndroidManifest.xml" << 'EOF'
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="org.guardianproject.proofmode">
    <uses-sdk android:minSdkVersion="21" />
</manifest>
EOF

# Copy Kotlin bindings
if [ -f "$BINDINGS_DIR/org/guardianproject/proofmode/ProofModeKt.kt" ]; then
    cp "$BINDINGS_DIR/org/guardianproject/proofmode/ProofModeKt.kt" "$AAR_DIR/classes/org/guardianproject/proofmode/"
    echo "Copied Kotlin bindings"
else
    echo "Warning: Kotlin bindings not found, using fallback"
    # Copy the existing ProofMode.kt as fallback
    cp "$PROJECT_DIR/bindings/android/org/guardianproject/proofmode/ProofMode.kt" "$AAR_DIR/classes/org/guardianproject/proofmode/"
fi

# Create mock native libraries (these should be replaced with real ones later)
echo "Creating mock native libraries..."

# Create C header for the library
cat > "$AAR_DIR/proofmode.h" << 'EOF'
#ifndef PROOFMODE_H
#define PROOFMODE_H

// Mock ProofMode native functions
const char* proofmode_get_version(void);
const char* proofmode_get_file_hash(const char* data, int len);
const char* proofmode_generate_proof_mobile(const char* media_data, int data_len, const char* metadata_json, long callback_handle);
const char* proofmode_check_files_mobile(const char** file_paths, int path_count, long callback_handle);

#endif
EOF

# Create C implementation
cat > "$AAR_DIR/proofmode.c" << 'EOF'
#include "proofmode.h"
#include <string.h>
#include <stdlib.h>

const char* proofmode_get_version(void) {
    return "0.4.0-mock";
}

const char* proofmode_get_file_hash(const char* data, int len) {
    // Mock implementation - returns a fake hash
    static char hash[65];
    snprintf(hash, sizeof(hash), "mock_hash_%d_%p", len, data);
    return hash;
}

const char* proofmode_generate_proof_mobile(const char* media_data, int data_len, const char* metadata_json, long callback_handle) {
    // Mock implementation
    static char result[256];
    snprintf(result, sizeof(result), "mock_proof_hash_%d_%ld", data_len, callback_handle);
    return result;
}

const char* proofmode_check_files_mobile(const char** file_paths, int path_count, long callback_handle) {
    // Mock implementation
    return "{\"status\":\"success\",\"files\":[],\"mock\":true}";
}
EOF

# Function to create a mock .so file with proper ELF structure
create_mock_so() {
    local arch=$1
    local output=$2
    
    echo "Creating mock .so for $arch..."
    
    # Create a minimal C file that exports our symbols
    cat > "$AAR_DIR/mock_${arch}.c" << 'EOF'
#include "proofmode.h"

// Export symbols for JNI
const char* Java_org_guardianproject_proofmode_ProofModeNative_getVersion() {
    return proofmode_get_version();
}

const char* Java_org_guardianproject_proofmode_ProofModeNative_getFileHash(void* env, void* class, void* data) {
    return "mock_hash";
}

const char* Java_org_guardianproject_proofmode_ProofModeNative_generateProofMobile(void* env, void* class, void* data, void* metadata, long callback) {
    return "mock_proof_hash";
}

const char* Java_org_guardianproject_proofmode_ProofModeNative_checkFilesMobile(void* env, void* class, void* paths, long callback) {
    return "{\"mock\":true}";
}
EOF

    # For now, create a simple binary file that looks like a shared library
    # In a real implementation, this would be compiled with the NDK
    printf '\x7fELF\x02\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00' > "$output"
    printf '\x03\x00\x3e\x00\x01\x00\x00\x00' >> "$output"
    printf 'Mock ProofMode library for %s\x00' "$arch" >> "$output"
    
    # Add some padding to make it look more realistic
    dd if=/dev/zero bs=1024 count=1 >> "$output" 2>/dev/null
}

# Create mock .so files for each architecture
create_mock_so "arm64-v8a" "$AAR_DIR/jni/arm64-v8a/libproofmode.so"  
create_mock_so "armeabi-v7a" "$AAR_DIR/jni/armeabi-v7a/libproofmode.so"
create_mock_so "x86" "$AAR_DIR/jni/x86/libproofmode.so"
create_mock_so "x86_64" "$AAR_DIR/jni/x86_64/libproofmode.so"

# Create the AAR file
cd "$AAR_DIR"
echo "Creating AAR archive..."
zip -r "../proofmode-rust.aar" . -x "*.c" "*.h" "mock_*.c"

# Clean up temporary files  
rm -f proofmode.h proofmode.c mock_*.c

cd "$PROJECT_DIR"
echo "Android AAR created at: android-example/app/libs/proofmode-rust.aar"
echo "AAR structure:"
unzip -l android-example/app/libs/proofmode-rust.aar