#include <jni.h>
#include <string>

#include "compressor_common.h"
#include "video_compressor.h"
#include "image_compressor.h"

static std::string jstring_to_string(JNIEnv *env, jstring value, const char *fallback) {
    if (!env || !value) {
        return fallback ? std::string(fallback) : std::string();
    }

    const char *chars = env->GetStringUTFChars(value, nullptr);
    if (!chars) {
        return fallback ? std::string(fallback) : std::string();
    }

    std::string result(chars);
    env->ReleaseStringUTFChars(value, chars);
    return result;
}

extern "C"
JNIEXPORT void JNICALL
Java_com_kikyps_kcompressor_NativeCompressor_cancelCurrentJob(JNIEnv *, jclass) {
    set_cancel_requested(true);
}

extern "C"
JNIEXPORT jint JNICALL
Java_com_kikyps_kcompressor_NativeCompressor_compressFd(JNIEnv *env,
                                                        jclass,
                                                        jint inputFd,
                                                        jint outputFd,
                                                        jint targetShortSide,
                                                        jint inputRotationDegrees,
                                                        jint crf,
                                                        jstring encoderName,
                                                        jstring preset,
                                                        jstring audioMode,
                                                        jint audioBitrate,
                                                        jobject callback) {
    std::string encoder = jstring_to_string(env, encoderName, "libx264");
    std::string preset_str = jstring_to_string(env, preset, "medium");
    std::string audio_mode = jstring_to_string(env, audioMode, "copy");

    if (encoder != "libx264" && encoder != "libx265") {
        encoder = "libx264";
    }

    if (targetShortSide < 0) targetShortSide = 0;

    if (crf < 0) crf = 26;
    if (crf > 51) crf = 51;

    if (audio_mode != "copy" && audio_mode != "aac" && audio_mode != "mute") {
        audio_mode = "copy";
    }

    if (audioBitrate <= 0) {
        audioBitrate = 128000;
    }

    reset_cancel_requested();

    int ret = compress_video_fd_impl(
            env,
            static_cast<int>(inputFd),
            static_cast<int>(outputFd),
            static_cast<int>(targetShortSide),
            static_cast<int>(inputRotationDegrees),
            static_cast<int>(crf),
            encoder,
            preset_str,
            audio_mode,
            static_cast<int>(audioBitrate),
            callback
    );

    return static_cast<jint>(ret);
}

extern "C"
JNIEXPORT jint JNICALL
Java_com_kikyps_kcompressor_NativeCompressor_compressImageFd(JNIEnv *env,
                                                             jclass,
                                                             jint inputFd,
                                                             jint outputFd,
                                                             jstring inputMime,
                                                             jstring outputFormat,
                                                             jint quality,
                                                             jint maxLongSide,
                                                             jobject callback) {
    std::string mime = jstring_to_string(env, inputMime, "");
    std::string format = jstring_to_string(env, outputFormat, "jpeg");

    if (quality < 1) quality = 1;
    if (quality > 100) quality = 100;
    if (maxLongSide < 0) maxLongSide = 0;

    reset_cancel_requested();

    int ret = compress_image_fd_impl(
            env,
            static_cast<int>(inputFd),
            static_cast<int>(outputFd),
            mime,
            format,
            static_cast<int>(quality),
            static_cast<int>(maxLongSide),
            callback
    );

    return static_cast<jint>(ret);
}