#include <jni.h>
#include <android/log.h>
#include <dav1d/dav1d.h>

// VavCore includes
#include "Decoder/VideoDecoderFactory.h"
#include "Decoder/MediaCodecAV1Decoder.h"

#define LOG_TAG "VavCore"
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)

extern "C" {

JNIEXPORT jstring JNICALL
Java_com_vavcore_android_VavCore_getDav1dVersion(JNIEnv *env, jclass clazz) {
    const char* version = dav1d_version();
    LOGI("dav1d version: %s", version);
    return env->NewStringUTF(version);
}

JNIEXPORT jboolean JNICALL
Java_com_vavcore_android_VavCore_testDav1dDecoder(JNIEnv *env, jclass clazz) {
    Dav1dSettings settings;
    Dav1dContext *ctx = nullptr;

    // Initialize default settings
    dav1d_default_settings(&settings);
    settings.n_threads = 1; // Use single thread for Android

    // Create decoder context
    int ret = dav1d_open(&ctx, &settings);
    if (ret < 0) {
        LOGE("Failed to create dav1d decoder context: %d", ret);
        return JNI_FALSE;
    }

    LOGI("dav1d decoder context created successfully");

    // Clean up
    dav1d_close(&ctx);
    LOGI("dav1d decoder context closed");

    return JNI_TRUE;
}

JNIEXPORT jboolean JNICALL
Java_com_vavcore_android_VavCore_testVavCoreMediaCodec(JNIEnv *env, jclass clazz) {
    using namespace VavCore;

    LOGI("Testing VavCore MediaCodec integration");

    // Initialize VideoDecoderFactory
    VideoDecoderFactory::InitializeFactory();

    // Check if MediaCodec decoder is available
    auto available_decoders = VideoDecoderFactory::GetAvailableDecoders(VideoCodecType::AV1);
    LOGI("Available AV1 decoders:");
    for (const auto& decoder : available_decoders) {
        LOGI("  - %s", decoder.c_str());
    }

    // Try to create MediaCodec decoder
    auto decoder = VideoDecoderFactory::CreateDecoder(VideoCodecType::AV1, VideoDecoderFactory::DecoderType::MEDIACODEC);
    if (decoder) {
        LOGI("MediaCodec decoder created successfully: %s", decoder->GetCodecName().c_str());

        // Test basic functionality without actual video data
        VideoMetadata test_metadata = {};
        test_metadata.codec_type = VideoCodecType::AV1;
        test_metadata.width = 1920;
        test_metadata.height = 1080;

        bool initialized = decoder->Initialize(test_metadata);
        LOGI("MediaCodec decoder initialization: %s", initialized ? "SUCCESS" : "FAILED");

        decoder->Cleanup();
        return initialized ? JNI_TRUE : JNI_FALSE;
    } else {
        LOGE("Failed to create MediaCodec decoder");
        return JNI_FALSE;
    }
}

JNIEXPORT jstring JNICALL
Java_com_vavcore_android_VavCore_getAvailableDecoders(JNIEnv *env, jclass clazz) {
    using namespace VavCore;

    VideoDecoderFactory::InitializeFactory();
    auto available_decoders = VideoDecoderFactory::GetAvailableDecoders(VideoCodecType::AV1);

    std::string result = "Available AV1 decoders: ";
    for (size_t i = 0; i < available_decoders.size(); i++) {
        if (i > 0) result += ", ";
        result += available_decoders[i];
    }

    return env->NewStringUTF(result.c_str());
}

} // extern "C"