/*
 * Copyright (C) 2014 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/* This is a JNI example where we use native methods to play video
 * using the native AMedia* APIs.
 * See the corresponding Java source file located at:
 *
 *   src/com/example/nativecodec/NativeMedia.java
 *
 * In this example we use assert() for "impossible" error conditions,
 * and explicit handling and recovery for more likely error conditions.
 */

#include <assert.h>
#include <jni.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <limits.h>

#include "looper.h"
#include "media/NdkMediaCodec.h"
#include "media/NdkMediaExtractor.h"

#ifndef LOG_TAG
    #define LOG_TAG "NativeCodec"
#endif

#include <logger.h>

#include <android/log.h>

// for __android_log_print(ANDROID_LOG_INFO, "YourApp", "formatted message");
#define LOGV(...) __android_log_print(ANDROID_LOG_VERBOSE, LOG_TAG, __VA_ARGS__)
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)

// for native windowRender JNI
#include <android/native_window_jni.h>
#include <android/asset_manager.h>
#include <android/asset_manager_jni.h>

typedef struct {
    int fd;
    ANativeWindow* window;
    AMediaExtractor* ex;
    AMediaCodec *codec;
    int64_t renderstart;
    bool sawInputEOS;
    bool sawOutputEOS;
    bool isPlaying;
    bool renderonce;
} workerdata;

workerdata data = {-1, NULL, NULL, NULL, 0, false, false, false, false};

enum {
    kMsgCodecBuffer,
    kMsgPause,
    kMsgResume,
    kMsgPauseAck,
    kMsgDecodeDone,
    kMsgSeek
};




#include <iostream>
#include <sstream>
#include <Logger/src/logger.hpp>
std::stringstream logss;
Logger g_logger(logss);


#include <liveMedia/liveMedia.hh>
#include <BasicUsageEnvironment/BasicUsageEnvironment.hh>

void rtsp_client_sdp_callback(void* arg, const char* val)
{}

void rtsp_client_fmtp_callback(void* arg, const char* val)
{

}

void rtsp_client_frame_callback(void* arg, uint8_t* buffer, size_t buffSize, timeval presentationTime)
{
    ssize_t bufidx = -1;

    bufidx = AMediaCodec_dequeueInputBuffer(data.codec, 2000);
    static int framecount = 0;
    LOGV("input buffer bufidx=%zd, framecount=%d", bufidx, framecount++);

    if (bufidx >= 0) {
        size_t bufsize;
        uint8_t* buf = AMediaCodec_getInputBuffer(data.codec, bufidx, &bufsize);
        size_t sampleSize = std::min(bufsize, buffSize);
        memcpy(buf, buffer, sampleSize);
        //auto sampleSize = AMediaExtractor_readSampleData(d->ex, buf, bufsize);
        //if (sampleSize < 0) {
        //    sampleSize = 0;
        //    d->sawInputEOS = true;
        //    LOGV("EOS");
        //}
        //auto presentationTimeUs = AMediaExtractor_getSampleTime(d->ex);
        uint64_t presentationTimeUs = presentationTime.tv_sec * 1000 * 1000 + presentationTime.tv_usec; //microseconds

        media_status_t ms = AMediaCodec_queueInputBuffer(data.codec, bufidx, 0, sampleSize, presentationTimeUs, 0);
        //LOGV("media_status_t=%d", ms);
        //AMediaExtractor_advance(d->ex);
    }


}

void rtsp_client_continue_callback(void* arg)
{}

struct PL_RTSPClient_Config
{
    std::string progName;
    std::string rtspURL;
    bool aux; // frame data start with 0x00000001
    int verbosityLevel;
    int tunnelOverHTTPPortNum; // portNumBits
    void* args;

    PL_RTSPClient_Config() :
            progName(), rtspURL() ,aux(true), verbosityLevel(1), tunnelOverHTTPPortNum(0), args(nullptr)
    { }
};
static PL_RTSPClient_Config rtspConfig;

#include <live555/testProgs/testRTSPClient.hpp>






class mylooper: public looper {
    virtual void handle(int what, void* obj);
};

static mylooper *mlooper = NULL;

int64_t systemnanotime() {
    timespec now;
    clock_gettime(CLOCK_MONOTONIC, &now);
    return now.tv_sec * 1000000000LL + now.tv_nsec;
}

void doCodecWork(workerdata *d) {
    ssize_t bufidx = -1;

    // from file
    if (!d->sawInputEOS) {
        bufidx = AMediaCodec_dequeueInputBuffer(d->codec, 2000);
        static int framecount = 0;
        LOGV("input buffer bufidx=%zd, framecount=%d", bufidx, framecount++);
        if (bufidx >= 0) {
            size_t bufsize;
            auto buf = AMediaCodec_getInputBuffer(d->codec, bufidx, &bufsize);
            auto sampleSize = AMediaExtractor_readSampleData(d->ex, buf, bufsize);
            if (sampleSize < 0) {
                sampleSize = 0;
                d->sawInputEOS = true;
                LOGV("EOS");
            }
            auto presentationTimeUs = AMediaExtractor_getSampleTime(d->ex);

            AMediaCodec_queueInputBuffer(d->codec, bufidx, 0, sampleSize, presentationTimeUs,
                    d->sawInputEOS ? AMEDIACODEC_BUFFER_FLAG_END_OF_STREAM : 0);
            AMediaExtractor_advance(d->ex);
        }
    }

    if (!d->sawOutputEOS) {
        AMediaCodecBufferInfo info;
        bufidx = AMediaCodec_dequeueOutputBuffer(d->codec, &info, 0); // ret buffer index
        if (bufidx >= 0) {
            if (info.flags & AMEDIACODEC_BUFFER_FLAG_END_OF_STREAM) {
                LOGV("output EOS");
                d->sawOutputEOS = true;
            }
            int64_t presentationNano = info.presentationTimeUs * 1000;
            if (d->renderstart < 0) {
                d->renderstart = systemnanotime() - presentationNano;
            }
            int64_t delay = (d->renderstart + presentationNano) - systemnanotime();
            if (delay > 0) {
                usleep(delay / 1000);
            }

            //AMediaCodec_getOutputBuffer

            AMediaCodec_releaseOutputBuffer(d->codec, bufidx, info.size != 0);
            if (d->renderonce) {
                d->renderonce = false;
                return;
            }
        } else if (bufidx == AMEDIACODEC_INFO_OUTPUT_BUFFERS_CHANGED) {
            LOGV("output buffers changed");
        } else if (bufidx == AMEDIACODEC_INFO_OUTPUT_FORMAT_CHANGED) {
            auto format = AMediaCodec_getOutputFormat(d->codec);
            LOGV("format changed to: %s", AMediaFormat_toString(format));
            AMediaFormat_delete(format);
        } else if (bufidx == AMEDIACODEC_INFO_TRY_AGAIN_LATER) {
            //LOGV("no output buffer right now");
        } else {
            LOGV("unexpected info code: %zd", bufidx);
        }
    }

    if (!d->sawInputEOS || !d->sawOutputEOS) {
        mlooper->post(kMsgCodecBuffer, d);
    }
}

void mylooper::handle(int what, void* obj) {
    switch (what) {
        case kMsgCodecBuffer:
            doCodecWork((workerdata*)obj);
            break;

        case kMsgDecodeDone:
        {
            workerdata *d = (workerdata*)obj;
            AMediaCodec_stop(d->codec);
            AMediaCodec_delete(d->codec);
            AMediaExtractor_delete(d->ex);
            d->sawInputEOS = true;
            d->sawOutputEOS = true;
        }
        break;

        case kMsgSeek:
        {
            workerdata *d = (workerdata*)obj;
            AMediaExtractor_seekTo(d->ex, 0, AMEDIAEXTRACTOR_SEEK_NEXT_SYNC);
            AMediaCodec_flush(d->codec);
            d->renderstart = -1;
            d->sawInputEOS = false;
            d->sawOutputEOS = false;
            if (!d->isPlaying) {
                d->renderonce = true;
                post(kMsgCodecBuffer, d);
            }
            LOGV("seeked");
        }
        break;

        case kMsgPause:
        {
            workerdata *d = (workerdata*)obj;
            if (d->isPlaying) {
                // flush all outstanding codecbuffer messages with a no-op message
                d->isPlaying = false;
                post(kMsgPauseAck, NULL, true);
            }
        }
        break;

        case kMsgResume:
        {
            workerdata *d = (workerdata*)obj;
            if (!d->isPlaying) {
                d->renderstart = -1;
                d->isPlaying = true;
                post(kMsgCodecBuffer, d);
            }
        }
        break;
    }
}

static void* live_daemon_thd(void* arg)
{
    TaskScheduler* scheduler = BasicTaskScheduler::createNew();
    UsageEnvironment* env = BasicUsageEnvironment::createNew(*scheduler);

    usage(*env, rtspConfig.progName.c_str());

    openURL(*env, rtspConfig);

    char eventLoopWatchVariable = 0;

    bool live_daemon_running = true;
    env->taskScheduler().doEventLoop(&eventLoopWatchVariable);
    live_daemon_running = false;
}

extern "C" {

jboolean Java_com_example_nativecodec_NativeCodec_createStreamingMediaPlayer_rtsp(JNIEnv* env,
                                                                             jclass clazz, jobject assetMgr, jstring filename) {
    LOGV("@@@ create");

    // convert Java string to UTF-8
    const char *utf8 = env->GetStringUTFChars(filename, NULL);
    LOGV("opening %s", utf8);

    rtspConfig.progName = "RtspFace";
    rtspConfig.rtspURL = utf8;
    rtspConfig.aux = true; // ffmpeg need aux, but live555 not
    rtspConfig.verbosityLevel = 1;
    rtspConfig.tunnelOverHTTPPortNum = 0;
    rtspConfig.args = nullptr;

    env->ReleaseStringUTFChars(filename, utf8);

    //AMediaFormat *format = AMediaExtractor_getTrackFormat(ex, i);
    AMediaFormat* format = AMediaFormat_new();
    //MediaFormat mediaFormat = MediaFormat.createVideoFormat(mime, width, height);

    AMediaFormat_setString(format, AMEDIAFORMAT_KEY_MIME, "video/avc");
    AMediaFormat_setInt32(format, AMEDIAFORMAT_KEY_HEIGHT, 1080);
    AMediaFormat_setInt32(format, AMEDIAFORMAT_KEY_WIDTH, 1920);

    //const uint8_t sps[] = {0x67, 0x4d, 0x00, 0x2a, 0x95, 0xa8, 0x1e, 0x00, 0x89, 0xf9, 0x61, 0x00, 0x00, 0x07, 0x08, 0x00, 0x01, 0x5f, 0x90, 0x04};
    //const uint8_t pps[] = {0x68, 0xee, 0x3c, 0x80};
    //AMediaFormat_setBuffer(format, "csd-0", (void*)sps, sizeof(sps)); // sps
    //AMediaFormat_setBuffer(format, "csd-1", (void*)pps, sizeof(pps)); // pps

    // should like:
    // mime: string(video/avc), durationUs: int64(10000000), width: int32(480), height: int32(360), max-input-size: int32(55067), csd-0: data, csd-1: data}
    LOGV("AMediaFormat_toString: %s", AMediaFormat_toString(format));

    AMediaCodec *codec = AMediaCodec_createDecoderByType("video/avc");
    if (AMediaCodec_configure(codec, format, data.window, NULL, 0) != AMEDIA_OK)
        LOGE("AMediaCodec_configure error");
    data.ex = NULL;
    data.codec = codec;
    data.renderstart = -1;
    data.sawInputEOS = true; // input from rtsp
    data.sawOutputEOS = false;
    data.isPlaying = false;
    data.renderonce = true;
    if (AMediaCodec_start(codec) != AMEDIA_OK)
        LOGE("AMediaCodec_start error");

    AMediaFormat_delete(format);

    mlooper = new mylooper();
    mlooper->post(kMsgCodecBuffer, &data);

    pthread_t live_daemon_thid;
    int ret = pthread_create(&live_daemon_thid, NULL, live_daemon_thd, NULL);

    return JNI_TRUE;
}

jboolean Java_com_example_nativecodec_NativeCodec_createStreamingMediaPlayer(JNIEnv* env,
        jclass clazz, jobject assetMgr, jstring filename)
{
    LOGV("@@@ create");

    // convert Java string to UTF-8
    const char *utf8 = env->GetStringUTFChars(filename, NULL);
    LOGV("opening %s", utf8);

   if (strncmp(utf8, "rtsp://", 7) == 0)//#todo release utf8
       return Java_com_example_nativecodec_NativeCodec_createStreamingMediaPlayer_rtsp(env, clazz, assetMgr, filename);

    off_t outStart, outLen;
    int fd = AAsset_openFileDescriptor(AAssetManager_open(AAssetManager_fromJava(env, assetMgr), utf8, 0),
                                       &outStart, &outLen);

    env->ReleaseStringUTFChars(filename, utf8);
    if (fd < 0) {
        LOGE("failed to open file: %s %d (%s)", utf8, fd, strerror(errno));
        return JNI_FALSE;
    }

    data.fd = fd;

    workerdata *d = &data;

    AMediaExtractor *ex = AMediaExtractor_new();
    media_status_t err = AMediaExtractor_setDataSourceFd(ex, d->fd,
                                                         static_cast<off64_t>(outStart),
                                                         static_cast<off64_t>(outLen));
    close(d->fd);
    if (err != AMEDIA_OK) {
        LOGV("setDataSource error: %d", err);
        return JNI_FALSE;
    }

    int numtracks = AMediaExtractor_getTrackCount(ex);

    AMediaCodec *codec = NULL;

    LOGV("input has %d tracks", numtracks);
    for (int i = 0; i < numtracks; i++) {
        AMediaFormat *format = AMediaExtractor_getTrackFormat(ex, i);
        const char *s = AMediaFormat_toString(format);
        LOGV("track %d format: %s", i, s);
        const char *mime;
        if (!AMediaFormat_getString(format, AMEDIAFORMAT_KEY_MIME, &mime)) {
            LOGV("no mime type");
            return JNI_FALSE;
        } else if (!strncmp(mime, "video/", 6)) {
            // Omitting most error handling for clarity.
            // Production code should check for errors.
            AMediaExtractor_selectTrack(ex, i);
            codec = AMediaCodec_createDecoderByType(mime);
            AMediaCodec_configure(codec, format, d->window, NULL, 0);
            d->ex = ex;
            d->codec = codec;
            d->renderstart = -1;
            d->sawInputEOS = false;
            d->sawOutputEOS = false;
            d->isPlaying = false;
            d->renderonce = true;
            AMediaCodec_start(codec);
        }
        AMediaFormat_delete(format);
    }

    mlooper = new mylooper();
    mlooper->post(kMsgCodecBuffer, d);

    return JNI_TRUE;
}

// set the playing state for the streaming media player
//void Java_com_example_nativecodec_NativeCodec_setPlayingStreamingMediaPlayer(JNIEnv* env,
//        jclass clazz, jboolean isPlaying)
//{
//    LOGV("@@@ playpause: %d", isPlaying);
//    if (mlooper) {
//        if (isPlaying) {
//            mlooper->post(kMsgResume, &data);
//        } else {
//            mlooper->post(kMsgPause, &data);
//        }
//    }
//}


// rewind the streaming media player
//void Java_RtspNativeCodec_rewindStreamingMediaPlayer(JNIEnv *env, jclass clazz)
//{
//    LOGV("@@@ rewind");
//    if (mlooper) {
//        mlooper->post(kMsgSeek, &data);
//    }
//}

// set the surface
void Java_RtspNativeCodec_setSurface(JNIEnv *env, jclass clazz, jint cameraIdx, jobject surface)
{
    LOGV("@@@ Java_RtspNativeCodec_setSurface");

    // obtain a native windowRender from a Java surface
    if (data.window) {
        ANativeWindow_release(data.window);
        data.window = NULL;
    }
    data.window = ANativeWindow_fromSurface(env, surface);
    LOGV("@@@ setsurface %p", data.window);
}

jboolean Java_RtspNativeCodec_createPlayer(JNIEnv* env, jclass clazz, jobject assetMgr, jint cameraIdx, jstring uri)
{
    LOGV("@@@ Java_RtspNativeCodec_createPlayer");

    return JNI_TRUE;
}

// shut down the native media system
void Java_RtspNativeCodec_shutdown(JNIEnv* env, jclass clazz, jint cameraIdx)
{
    LOGV("@@@ Java_RtspNativeCodec_shutdown");
    if (mlooper) {
        mlooper->post(kMsgDecodeDone, &data, true /* flush */);
        mlooper->quit();
        delete mlooper;
        mlooper = NULL;
    }
    if (data.window) {
        ANativeWindow_release(data.window);
        data.window = NULL;
    }
}

jboolean Java_RtspNativeCodec_setFaceCallback(JNIEnv* env, jclass clazz, jobject assetMgr, jint cameraIdx, jstring func)
{
    return JNI_TRUE;
}

jboolean Java_RtspNativeCodec_getFaceList(JNIEnv* env, jclass clazz, jobject assetMgr, jint cameraIdx, jobjectRefType faceList)
{
    return JNI_TRUE;
}

}