/*
 * Copyright (C) 2015 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.
 */

package org.drrickorang.loopback;

import java.nio.ByteBuffer;
import java.util.Arrays;

import android.content.Context;
import android.media.AudioManager;
import android.media.AudioTrack;
import android.os.Build;
import android.os.Handler;
import android.os.Message;
import android.util.Log;


/**
 * A thread/audio track based audio synth.
 */

public class NativeAudioThread extends Thread {
    private static final String TAG = "NativeAudioThread";

    // for latency test
    static final int LOOPBACK_NATIVE_AUDIO_THREAD_MESSAGE_LATENCY_REC_STARTED = 891;
    static final int LOOPBACK_NATIVE_AUDIO_THREAD_MESSAGE_LATENCY_REC_ERROR = 892;
    static final int LOOPBACK_NATIVE_AUDIO_THREAD_MESSAGE_LATENCY_REC_COMPLETE = 893;
    static final int LOOPBACK_NATIVE_AUDIO_THREAD_MESSAGE_LATENCY_REC_COMPLETE_ERRORS = 894;
    static final int LOOPBACK_NATIVE_AUDIO_THREAD_MESSAGE_LATENCY_REC_STOP = 895;

    // for buffer test
    static final int LOOPBACK_NATIVE_AUDIO_THREAD_MESSAGE_BUFFER_REC_STARTED = 896;
    static final int LOOPBACK_NATIVE_AUDIO_THREAD_MESSAGE_BUFFER_REC_ERROR = 897;
    static final int LOOPBACK_NATIVE_AUDIO_THREAD_MESSAGE_BUFFER_REC_COMPLETE = 898;
    static final int LOOPBACK_NATIVE_AUDIO_THREAD_MESSAGE_BUFFER_REC_COMPLETE_ERRORS = 899;
    static final int LOOPBACK_NATIVE_AUDIO_THREAD_MESSAGE_BUFFER_REC_STOP = 900;

    public boolean  mIsRunning = false;
    public int      mSessionId;
    public double[] mSamples; // store samples that will be shown on WavePlotView
    int             mSamplesIndex;

    private int mThreadType;
    private int mTestType;
    private int mSamplingRate;
    private int mMinPlayerBufferSizeInBytes = 0;
    private int mMinRecorderBuffSizeInBytes = 0; // currently not used
    private int mMicSource;
    private int mPerformanceMode = -1;
    private int mIgnoreFirstFrames;

    private boolean mIsRequestStop = false;
    private Handler mMessageHandler;
    private boolean isDestroying = false;
    private boolean hasDestroyingErrors = false;

    // for buffer test
    private int[]   mRecorderBufferPeriod;
    private int     mRecorderMaxBufferPeriod;
    private double  mRecorderStdDevBufferPeriod;
    private int[]   mPlayerBufferPeriod;
    private int     mPlayerMaxBufferPeriod;
    private double  mPlayerStdDevBufferPeriod;
    private BufferCallbackTimes mPlayerCallbackTimes;
    private BufferCallbackTimes mRecorderCallbackTimes;
    private int     mBufferTestWavePlotDurationInSeconds;
    private double  mFrequency1 = Constant.PRIME_FREQUENCY_1;
    private double  mFrequency2 = Constant.PRIME_FREQUENCY_2; // not actually used
    private int     mBufferTestDurationInSeconds;
    private int     mFFTSamplingSize;
    private int     mFFTOverlapSamples;
    private int[]   mAllGlitches;
    private boolean mGlitchingIntervalTooLong;
    private final CaptureHolder mCaptureHolder;

    private PipeByteBuffer        mPipeByteBuffer;
    private GlitchDetectionThread mGlitchDetectionThread;

    /** Check if it's safe to use getProperty(). */
    static boolean isSafeToUseGetProperty() {
        return Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1;
    }

    public static TestSettings computeDefaultSettings(Context context,
            int threadType, int performanceMode) {
        TestSettings nativeResult = nativeComputeDefaultSettings(
                Constant.BYTES_PER_FRAME, threadType, performanceMode);
        if (nativeResult != null) {
            return nativeResult;
        }

        int samplingRate = AudioTrack.getNativeOutputSampleRate(AudioManager.STREAM_MUSIC);
        int minBufferSizeInFrames = 1024;
        if (isSafeToUseGetProperty()) {
            AudioManager am = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
            String value = am.getProperty(AudioManager.PROPERTY_OUTPUT_FRAMES_PER_BUFFER);
            minBufferSizeInFrames = Integer.parseInt(value);
        }
        int minBufferSizeInBytes = Constant.BYTES_PER_FRAME * minBufferSizeInFrames;
        return new TestSettings(samplingRate, minBufferSizeInBytes, minBufferSizeInBytes);
    }

    public NativeAudioThread(int threadType, int samplingRate, int playerBufferInBytes,
                             int recorderBufferInBytes, int micSource, int performanceMode,
                             int testType, int bufferTestDurationInSeconds,
                             int bufferTestWavePlotDurationInSeconds, int ignoreFirstFrames,
                             CaptureHolder captureHolder) {
        mThreadType = threadType;
        mSamplingRate = samplingRate;
        mMinPlayerBufferSizeInBytes = playerBufferInBytes;
        mMinRecorderBuffSizeInBytes = recorderBufferInBytes;
        mMicSource = micSource;
        mPerformanceMode = performanceMode;
        mTestType = testType;
        mBufferTestDurationInSeconds = bufferTestDurationInSeconds;
        mBufferTestWavePlotDurationInSeconds = bufferTestWavePlotDurationInSeconds;
        mIgnoreFirstFrames = ignoreFirstFrames;
        mCaptureHolder = captureHolder;
        setName("Loopback_NativeAudio");
    }

    public NativeAudioThread(NativeAudioThread old) {
        mThreadType = old.mThreadType;
        mSamplingRate = old.mSamplingRate;
        mMinPlayerBufferSizeInBytes = old.mMinPlayerBufferSizeInBytes;
        mMinRecorderBuffSizeInBytes = old.mMinRecorderBuffSizeInBytes;
        mMicSource = old.mMicSource;
        mPerformanceMode = old.mPerformanceMode;
        mTestType = old.mTestType;
        mBufferTestDurationInSeconds = old.mBufferTestDurationInSeconds;
        mBufferTestWavePlotDurationInSeconds = old.mBufferTestWavePlotDurationInSeconds;
        mIgnoreFirstFrames = old.mIgnoreFirstFrames;
        mCaptureHolder = old.mCaptureHolder;
        setName("Loopback_NativeAudio");
    }

    //JNI load
    static {
        try {
            System.loadLibrary("loopback");
        } catch (UnsatisfiedLinkError e) {
            log("Error loading loopback JNI library");
            e.printStackTrace();
        }
        /* TODO: gracefully fail/notify if the library can't be loaded */
    }


    //jni calls
    public static native TestSettings nativeComputeDefaultSettings(
            int bytesPerFrame, int threadType, int performanceMode);
    public native long  nativeInit(int threadType,
                                 int samplingRate, int frameCount, int micSource,
                                 int performanceMode,
                                 int testType, double frequency1, ByteBuffer byteBuffer,
                                 short[] sincTone, int maxRecordedLateCallbacks,
                                 int ignoreFirstFrames);
    public native int   nativeProcessNext(long nativeHandle, double[] samples, long offset);
    public native int   nativeDestroy(long nativeHandle);

    // to get buffer period data
    public native int[]  nativeGetRecorderBufferPeriod(long nativeHandle);
    public native int    nativeGetRecorderMaxBufferPeriod(long nativeHandle);
    public native double nativeGetRecorderVarianceBufferPeriod(long nativeHandle);
    public native int[]  nativeGetPlayerBufferPeriod(long nativeHandle);
    public native int    nativeGetPlayerMaxBufferPeriod(long nativeHandle);
    public native double nativeGetPlayerVarianceBufferPeriod(long nativeHandle);
    public native BufferCallbackTimes nativeGetPlayerCallbackTimeStamps(long nativeHandle);
    public native BufferCallbackTimes nativeGetRecorderCallbackTimeStamps(long nativeHandle);

    public native int nativeGetCaptureRank(long nativeHandle);


    public void run() {
        setPriority(Thread.MAX_PRIORITY);
        mIsRunning = true;

        //erase output buffer
        if (mSamples != null)
            mSamples = null;

        //start playing
        log(" Started capture test");
        if (mMessageHandler != null) {
            Message msg = Message.obtain();
            switch (mTestType) {
            case Constant.LOOPBACK_PLUG_AUDIO_THREAD_TEST_TYPE_LATENCY:
                msg.what = LOOPBACK_NATIVE_AUDIO_THREAD_MESSAGE_LATENCY_REC_STARTED;
                break;
            case Constant.LOOPBACK_PLUG_AUDIO_THREAD_TEST_TYPE_BUFFER_PERIOD:
                msg.what = LOOPBACK_NATIVE_AUDIO_THREAD_MESSAGE_BUFFER_REC_STARTED;
                break;
            }
            mMessageHandler.sendMessage(msg);
        }

        // generate windowed tone use for loopback test
        short loopbackTone[] = new short[mMinPlayerBufferSizeInBytes / Constant.BYTES_PER_FRAME];
        if (mTestType == Constant.LOOPBACK_PLUG_AUDIO_THREAD_TEST_TYPE_LATENCY) {
            ToneGeneration sincToneGen = new RampedSineTone(mSamplingRate,
                    Constant.LOOPBACK_FREQUENCY);
            int sincLength = Math.min(Constant.LOOPBACK_SAMPLE_FRAMES, loopbackTone.length);
            sincToneGen.generateTone(loopbackTone, sincLength);
        }

        log(String.format("about to init, sampling rate: %d, buffer:%d", mSamplingRate,
                mMinPlayerBufferSizeInBytes / Constant.BYTES_PER_FRAME));

        // mPipeByteBuffer is only used in buffer test
        mPipeByteBuffer = new PipeByteBuffer(Constant.MAX_SHORTS);
        long startTimeMs = System.currentTimeMillis();
        long nativeHandle = nativeInit(mThreadType, mSamplingRate,
                mMinPlayerBufferSizeInBytes / Constant.BYTES_PER_FRAME, mMicSource,
                mPerformanceMode, mTestType,
                mFrequency1, mPipeByteBuffer.getByteBuffer(), loopbackTone,
                mBufferTestDurationInSeconds * Constant.MAX_RECORDED_LATE_CALLBACKS_PER_SECOND,
                mIgnoreFirstFrames);
        log(String.format("nativeHandle = 0x%X", nativeHandle));

        if (nativeHandle == 0) {
            //notify error!!
            log(" ERROR at JNI initialization");
            if (mMessageHandler != null) {
                Message msg = Message.obtain();
                switch (mTestType) {
                case Constant.LOOPBACK_PLUG_AUDIO_THREAD_TEST_TYPE_LATENCY:
                    msg.what = LOOPBACK_NATIVE_AUDIO_THREAD_MESSAGE_LATENCY_REC_ERROR;
                    break;
                case Constant.LOOPBACK_PLUG_AUDIO_THREAD_TEST_TYPE_BUFFER_PERIOD:
                    msg.what = LOOPBACK_NATIVE_AUDIO_THREAD_MESSAGE_BUFFER_REC_ERROR;
                    break;
                }
                mMessageHandler.sendMessage(msg);
            }
        } else {
            // wait a little bit
            try {
                final int setUpTime = 10;
                sleep(setUpTime); //just to let it start properly
            } catch (InterruptedException e) {
                e.printStackTrace();
            }


            int totalSamplesRead = 0;
            switch (mTestType) {
            case Constant.LOOPBACK_PLUG_AUDIO_THREAD_TEST_TYPE_LATENCY:
                final int latencyTestDurationInSeconds = 2;
                int nNewSize = (int) (1.1 * mSamplingRate * latencyTestDurationInSeconds);
                mSamples = new double[nNewSize];
                mSamplesIndex = 0; //reset index
                Arrays.fill(mSamples, 0);

                //TODO use a ByteBuffer to retrieve recorded data instead
                long offset = 0;
                // retrieve native recorder's recorded data
                for (int ii = 0; ii < latencyTestDurationInSeconds; ii++) {
                    log(String.format("block %d...", ii));
                    int samplesRead = nativeProcessNext(nativeHandle, mSamples, offset);
                    totalSamplesRead += samplesRead;
                    offset += samplesRead;
                    log(" [" + ii + "] jni samples read:" + samplesRead +
                        "  currentOffset:" + offset);
                }

                log(String.format(" samplesRead: %d, sampleOffset:%d", totalSamplesRead, offset));
                log("about to destroy...");
                break;
            case Constant.LOOPBACK_PLUG_AUDIO_THREAD_TEST_TYPE_BUFFER_PERIOD:
                setUpGlitchDetectionThread();
                long testDurationMs = mBufferTestDurationInSeconds * Constant.MILLIS_PER_SECOND;
                long elapsedTimeMs = System.currentTimeMillis() - startTimeMs;
                while (elapsedTimeMs < testDurationMs) {
                    if (mIsRequestStop) {
                        break;
                    } else {
                        int rank = nativeGetCaptureRank(nativeHandle);
                        if (rank > 0) {
                            //log("Late callback detected");
                            mCaptureHolder.captureState(rank);
                        }
                        try {
                            final int setUpTime = 100;
                            sleep(setUpTime); //just to let it start properly
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        elapsedTimeMs = System.currentTimeMillis() - startTimeMs;
                    }

                }
                break;


            }

            // collect buffer period data
            mRecorderBufferPeriod = nativeGetRecorderBufferPeriod(nativeHandle);
            mRecorderMaxBufferPeriod = nativeGetRecorderMaxBufferPeriod(nativeHandle);
            mRecorderStdDevBufferPeriod = Math.sqrt(nativeGetRecorderVarianceBufferPeriod(
                    nativeHandle));
            mPlayerBufferPeriod = nativeGetPlayerBufferPeriod(nativeHandle);
            mPlayerMaxBufferPeriod = nativeGetPlayerMaxBufferPeriod(nativeHandle);
            mPlayerStdDevBufferPeriod = Math.sqrt(nativeGetPlayerVarianceBufferPeriod(
                    nativeHandle));

            mPlayerCallbackTimes = nativeGetPlayerCallbackTimeStamps(nativeHandle);
            mRecorderCallbackTimes = nativeGetRecorderCallbackTimeStamps(nativeHandle);

            // get glitches data only for buffer test
            if (mTestType == Constant.LOOPBACK_PLUG_AUDIO_THREAD_TEST_TYPE_BUFFER_PERIOD) {
                mAllGlitches = mGlitchDetectionThread.getGlitches();
                mSamples = mGlitchDetectionThread.getWaveData();
                mGlitchingIntervalTooLong = mGlitchDetectionThread.getGlitchingIntervalTooLong();
                endDetecting();
            }

            if (mTestType == Constant.LOOPBACK_PLUG_AUDIO_THREAD_TEST_TYPE_LATENCY) {
                mCaptureHolder.captureState(0);
            }

            runDestroy(nativeHandle);

            final int maxTry = 20;
            int tryCount = 0;
            while (isDestroying) {
                try {
                    sleep(40);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                tryCount++;
                log("destroy try: " + tryCount);

                if (tryCount >= maxTry) {
                    hasDestroyingErrors = true;
                    log("WARNING: waited for max time to properly destroy JNI.");
                    break;
                }
            }
            log(String.format("after destroying. TotalSamplesRead = %d", totalSamplesRead));

            // for buffer test samples won't be read into here
            if (mTestType == Constant.LOOPBACK_PLUG_AUDIO_THREAD_TEST_TYPE_LATENCY
                && totalSamplesRead == 0) {
                //hasDestroyingErrors = true;
                log("Warning: Latency test reads no sample from native recorder!");
            }

            endTest();
        }
    }


    public void requestStopTest() {
        mIsRequestStop = true;
    }


    /** Set up parameters needed for GlitchDetectionThread, then create and run this thread. */
    private void setUpGlitchDetectionThread() {
        final int targetFFTMs = 20; // we want each FFT to cover 20ms of samples
        mFFTSamplingSize = targetFFTMs * mSamplingRate / Constant.MILLIS_PER_SECOND;
        // round to the nearest power of 2
        mFFTSamplingSize = (int) Math.pow(2, Math.round(Math.log(mFFTSamplingSize) / Math.log(2)));

        if (mFFTSamplingSize < 2) {
            mFFTSamplingSize = 2; // mFFTSamplingSize should be at least 2
        }
        mFFTOverlapSamples = mFFTSamplingSize / 2; // mFFTOverlapSamples is half of mFFTSamplingSize

        mGlitchDetectionThread = new GlitchDetectionThread(mFrequency1, mFrequency2, mSamplingRate,
            mFFTSamplingSize, mFFTOverlapSamples, mBufferTestDurationInSeconds,
            mBufferTestWavePlotDurationInSeconds, mPipeByteBuffer, mCaptureHolder);
        mGlitchDetectionThread.start();
    }


    public void endDetecting() {
        mPipeByteBuffer.flush();
        mPipeByteBuffer = null;
        mGlitchDetectionThread.requestStop();
        GlitchDetectionThread tempThread = mGlitchDetectionThread;
        mGlitchDetectionThread = null;
        try {
            tempThread.join(Constant.JOIN_WAIT_TIME_MS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }


    public void setMessageHandler(Handler messageHandler) {
        mMessageHandler = messageHandler;
    }


    private void runDestroy(final long localNativeHandle) {
        isDestroying = true;

        //start thread
        Thread thread = new Thread(new Runnable() {
            public void run() {
                isDestroying = true;
                log("**Start runnable destroy");

                int status = nativeDestroy(localNativeHandle);
                log(String.format("**End runnable destroy native delete status: %d", status));
                isDestroying = false;
            }
        });

        thread.start();
        log("end of runDestroy()");
    }


    /** not doing real work, just to keep consistency with LoopbackAudioThread. */
    public void runTest() {

    }


    /** not doing real work, just to keep consistency with LoopbackAudioThread. */
    public void runBufferTest() {

    }


    public void endTest() {
       log("--Ending capture test--");
       if (mMessageHandler != null) {
           Message msg = Message.obtain();
           if (hasDestroyingErrors) {
               switch (mTestType) {
                   case Constant.LOOPBACK_PLUG_AUDIO_THREAD_TEST_TYPE_LATENCY:
                       msg.what = LOOPBACK_NATIVE_AUDIO_THREAD_MESSAGE_LATENCY_REC_COMPLETE_ERRORS;
                       break;
                   case Constant.LOOPBACK_PLUG_AUDIO_THREAD_TEST_TYPE_BUFFER_PERIOD:
                       msg.what = LOOPBACK_NATIVE_AUDIO_THREAD_MESSAGE_BUFFER_REC_COMPLETE_ERRORS;
                       break;
               }
           } else if (mIsRequestStop) {
               switch (mTestType) {
                   case Constant.LOOPBACK_PLUG_AUDIO_THREAD_TEST_TYPE_LATENCY:
                       msg.what = LOOPBACK_NATIVE_AUDIO_THREAD_MESSAGE_LATENCY_REC_STOP;
                       break;
                   case Constant.LOOPBACK_PLUG_AUDIO_THREAD_TEST_TYPE_BUFFER_PERIOD:
                       msg.what = LOOPBACK_NATIVE_AUDIO_THREAD_MESSAGE_BUFFER_REC_STOP;
                       break;
               }
           } else {
               switch (mTestType) {
               case Constant.LOOPBACK_PLUG_AUDIO_THREAD_TEST_TYPE_LATENCY:
                   msg.what = LOOPBACK_NATIVE_AUDIO_THREAD_MESSAGE_LATENCY_REC_COMPLETE;
                   break;
               case Constant.LOOPBACK_PLUG_AUDIO_THREAD_TEST_TYPE_BUFFER_PERIOD:
                   msg.what = LOOPBACK_NATIVE_AUDIO_THREAD_MESSAGE_BUFFER_REC_COMPLETE;
                   break;
               }
           }

           mMessageHandler.sendMessage(msg);
       }
    }


    public void finish() {
        mIsRunning = false;
    }


    private static void log(String msg) {
        Log.v(TAG, msg);
    }


    double[] getWaveData() {
        return mSamples;
    }


    public int[] getRecorderBufferPeriod() {
        return mRecorderBufferPeriod;
    }

    public int getRecorderMaxBufferPeriod() {
        return mRecorderMaxBufferPeriod;
    }

    public double getRecorderStdDevBufferPeriod() {
        return mRecorderStdDevBufferPeriod;
    }

    public int[] getPlayerBufferPeriod() {
        return mPlayerBufferPeriod;
    }

    public int getPlayerMaxBufferPeriod() {
        return mPlayerMaxBufferPeriod;
    }

    public double getPlayerStdDevBufferPeriod() {
        return mPlayerStdDevBufferPeriod;
    }

    public int[] getNativeAllGlitches() {
        return mAllGlitches;
    }


    public boolean getGlitchingIntervalTooLong() {
        return mGlitchingIntervalTooLong;
    }


    public int getNativeFFTSamplingSize() {
        return mFFTSamplingSize;
    }


    public int getNativeFFTOverlapSamples() {
        return mFFTOverlapSamples;
    }


    public int getDurationInSeconds() {
        return mBufferTestDurationInSeconds;
    }

    public BufferCallbackTimes getPlayerCallbackTimes() {
        return mPlayerCallbackTimes;
    }

    public BufferCallbackTimes getRecorderCallbackTimes() {
        return mRecorderCallbackTimes;
    }
}