/*

 * Hedgewars for Android. An Android port of Hedgewars, a free turn based strategy game

 * Copyright (c) 2011-2012 Richard Deurwaarder <xeli@xelification.com>

 * Copyright (C) 2012 Simeon Maxein <smaxein@googlemail.com>

 * Copyright (c) 2004-2015 Andrey Korotaev <unC0Rr@gmail.com>

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

 */

package org.hedgewars.hedgeroid;

import java.io.IOException;

import java.io.UnsupportedEncodingException;

import java.net.ConnectException;

import javax.microedition.khronos.egl.EGL10;

import javax.microedition.khronos.egl.EGLConfig;

import javax.microedition.khronos.egl.EGLContext;

import javax.microedition.khronos.egl.EGLDisplay;

import javax.microedition.khronos.egl.EGLSurface;

import org.hedgewars.hedgeroid.Datastructures.GameConfig;

import org.hedgewars.hedgeroid.EngineProtocol.PascalExports;

import org.hedgewars.hedgeroid.netplay.Netplay;

import org.hedgewars.hedgeroid.util.FileUtils;

import android.app.Activity;

import android.content.Context;

import android.graphics.Canvas;

import android.graphics.PixelFormat;

import android.hardware.Sensor;

import android.hardware.SensorEvent;

import android.hardware.SensorEventListener;

import android.hardware.SensorManager;

import android.media.AudioFormat;

import android.media.AudioManager;

import android.media.AudioTrack;

import android.os.Bundle;

import android.util.Base64;

import android.util.DisplayMetrics;

import android.util.Log;

import android.view.KeyEvent;

import android.view.MotionEvent;

import android.view.SurfaceHolder;

import android.view.SurfaceView;

import android.view.View;

/**

    SDL Activity

 */

public class SDLActivity extends Activity {

    /**

     * Set startConfig to the desired config when starting this activity. This avoids having to parcel all

     * the config objects into the Intent. Not particularly elegant, but it's actually a recommended

     * way to do this (http://developer.android.com/guide/faq/framework.html#3)

     */

    public static volatile GameConfig startConfig;

    public static volatile boolean startNetgame;

    // Main components

    public static SDLActivity mSingleton;

    private static SDLSurface mSurface;

    private static Thread mSDLThread;

    // Audio

    private static Thread mAudioThread;

    private static AudioTrack mAudioTrack;

    // EGL private objects

    private static EGLContext  mEGLContext;

    private static EGLSurface  mEGLSurface;

    private static EGLDisplay  mEGLDisplay;

    private static EGLConfig   mEGLConfig;

    private static int mGLMajor, mGLMinor;

    // Load the .so

    static {

        System.loadLibrary("SDL");

        System.loadLibrary("main");

    }

    // Setup

    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        // So we can call stuff from static callbacks

        mSingleton = this;

        // Set up the surface

        mSurface = new SDLSurface(getApplication(), startConfig, startNetgame);

        startConfig = null;

        setContentView(mSurface);

    }

    // Events

    protected void onPause() {

        Log.v("SDL", "onPause()");

        super.onPause();

        if(mEGLDisplay != null && mEGLContext != null){

            EGL10 egl = (EGL10)EGLContext.getEGL();

            egl.eglDestroyContext(mEGLDisplay, mEGLContext);

            mEGLDisplay = null;

            mEGLContext = null;

        }

        SDLActivity.nativePause();

    }

    protected void onResume() {

        Log.v("SDL", "onResume()");

        super.onResume();

    }

    protected void onDestroy() {

        super.onDestroy();

        Log.v("SDL", "onDestroy()");

        // Send a quit message to the application

        SDLActivity.nativeQuit();

        // Now wait for the SDL thread to quit

        if (mSDLThread != null) {

            try {

                mSDLThread.join();

            } catch(Exception e) {

                Log.w("SDL", "Problem stopping thread: " + e);

            }

            mSDLThread = null;

        }

        mSingleton = null;

    }

    public static void synchronizedNativeInit(String...args) {

        synchronized(PascalExports.engineMutex) {

            nativeInit(args);

        }

    }

    // C functions we call

    private static native void nativeInit(String...args);

    public static native void nativeQuit();

    public static native void nativePause();

    public static native void nativeResume();

    public static native void onNativeResize(int x, int y, int format);

    public static native void onNativeKeyDown(int keycode);

    public static native void onNativeKeyUp(int keycode);

    public static native void onNativeTouch(int touchDevId, int pointerFingerId,

            int action, float x,

            float y, float p);

    public static native void onNativeAccel(float x, float y, float z);

    public static native void nativeRunAudioThread();

    // Java functions called from C

    public static boolean createGLContext(int majorVersion, int minorVersion) {

        return initEGL(majorVersion, minorVersion);

    }

    public static void flipBuffers() {

        flipEGL();

    }

    public static void setActivityTitle(final String title) {

        // Called from SDLMain() thread and can't directly affect the view

        mSingleton.runOnUiThread(new Runnable() {

            public void run() {

                mSingleton.setTitle(title);

            }

        });

    }

    public static Context getContext() {

        return mSingleton;

    }

    public static void startApp(final int width, final int height, GameConfig config, boolean netgame) {

        // Start up the C app thread

        if (mSDLThread == null) {

            mSDLThread = new Thread(new SDLMain(width, height, config, netgame));

            mSDLThread.start();

        } else {

            SDLActivity.nativeResume();

        }

    }

    // EGL functions

    public static boolean initEGL(int majorVersion, int minorVersion) {

        if (SDLActivity.mEGLDisplay == null) {

            try {

                EGL10 egl = (EGL10)EGLContext.getEGL();

                EGLDisplay dpy = egl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);

                int[] version = new int[2];

                egl.eglInitialize(dpy, version);

                int EGL_OPENGL_ES_BIT = 1;

                int EGL_OPENGL_ES2_BIT = 4;

                int renderableType = 0;

                if (majorVersion == 2) {

                    renderableType = EGL_OPENGL_ES2_BIT;

                } else if (majorVersion == 1) {

                    renderableType = EGL_OPENGL_ES_BIT;

                }

                int[] configSpec = {

                        EGL10.EGL_RENDERABLE_TYPE, renderableType,

                        EGL10.EGL_NONE

                };

                EGLConfig[] configs = new EGLConfig[1];

                int[] num_config = new int[1];

                if (!egl.eglChooseConfig(dpy, configSpec, configs, 1, num_config) || num_config[0] == 0) {

                    Log.e("SDL", "No EGL config available");

                    return false;

                }

                EGLConfig config = configs[0];

                SDLActivity.mEGLDisplay = dpy;

                SDLActivity.mEGLConfig = config;

                SDLActivity.mGLMajor = majorVersion;

                SDLActivity.mGLMinor = minorVersion;

                SDLActivity.createEGLSurface();

            } catch(Exception e) {

                Log.v("SDL", e + "");

                for (StackTraceElement s : e.getStackTrace()) {

                    Log.v("SDL", s.toString());

                }

            }

        }

        else SDLActivity.createEGLSurface();

        return true;

    }

    public static boolean createEGLContext() {

        EGL10 egl = (EGL10)EGLContext.getEGL();

        int EGL_CONTEXT_CLIENT_VERSION=0x3098;

        int contextAttrs[] = new int[] { EGL_CONTEXT_CLIENT_VERSION, SDLActivity.mGLMajor, EGL10.EGL_NONE };

        SDLActivity.mEGLContext = egl.eglCreateContext(SDLActivity.mEGLDisplay, SDLActivity.mEGLConfig, EGL10.EGL_NO_CONTEXT, contextAttrs);

        if (SDLActivity.mEGLContext == EGL10.EGL_NO_CONTEXT) {

            Log.e("SDL", "Couldn't create context");

            return false;

        }

        return true;

    }

    public static boolean createEGLSurface() {

        if (SDLActivity.mEGLDisplay != null && SDLActivity.mEGLConfig != null) {

            EGL10 egl = (EGL10)EGLContext.getEGL();

            if (SDLActivity.mEGLContext == null) createEGLContext();

            Log.v("SDL", "Creating new EGL Surface");

            EGLSurface surface = egl.eglCreateWindowSurface(SDLActivity.mEGLDisplay, SDLActivity.mEGLConfig, SDLActivity.mSurface, null);

            if (surface == EGL10.EGL_NO_SURFACE) {

                Log.e("SDL", "Couldn't create surface");

                return false;

            }

            if (!egl.eglMakeCurrent(SDLActivity.mEGLDisplay, surface, surface, SDLActivity.mEGLContext)) {

                Log.e("SDL", "Old EGL Context doesnt work, trying with a new one");

                createEGLContext();

                if (!egl.eglMakeCurrent(SDLActivity.mEGLDisplay, surface, surface, SDLActivity.mEGLContext)) {

                    Log.e("SDL", "Failed making EGL Context current");

                    return false;

                }

            }

            SDLActivity.mEGLSurface = surface;

            return true;

        }

        return false;

    }

    // EGL buffer flip

    public static void flipEGL() {

        try {

            EGL10 egl = (EGL10)EGLContext.getEGL();

            egl.eglWaitNative(EGL10.EGL_CORE_NATIVE_ENGINE, null);

            // drawing here

            egl.eglWaitGL();

            egl.eglSwapBuffers(SDLActivity.mEGLDisplay, SDLActivity.mEGLSurface);

        } catch(Exception e) {

            Log.v("SDL", "flipEGL(): " + e);

            for (StackTraceElement s : e.getStackTrace()) {

                Log.v("SDL", s.toString());

            }

        }

    }

    // Audio

    private static Object buf;

    public static Object audioInit(int sampleRate, boolean is16Bit, boolean isStereo, int desiredFrames) {

        int channelConfig = isStereo ? AudioFormat.CHANNEL_CONFIGURATION_STEREO : AudioFormat.CHANNEL_CONFIGURATION_MONO;

        int audioFormat = is16Bit ? AudioFormat.ENCODING_PCM_16BIT : AudioFormat.ENCODING_PCM_8BIT;

        int frameSize = (isStereo ? 2 : 1) * (is16Bit ? 2 : 1);

        Log.v("SDL", "SDL audio: wanted " + (isStereo ? "stereo" : "mono") + " " + (is16Bit ? "16-bit" : "8-bit") + " " + ((float)sampleRate / 1000f) + "kHz, " + desiredFrames + " frames buffer");

        // Let the user pick a larger buffer if they really want -- but ye

        // gods they probably shouldn't, the minimums are horrifyingly high

        // latency already

        desiredFrames = Math.max(desiredFrames, (AudioTrack.getMinBufferSize(sampleRate, channelConfig, audioFormat) + frameSize - 1) / frameSize);

        mAudioTrack = new AudioTrack(AudioManager.STREAM_MUSIC, sampleRate,

                channelConfig, audioFormat, desiredFrames * frameSize, AudioTrack.MODE_STREAM);

        audioStartThread();

        Log.v("SDL", "SDL audio: got " + ((mAudioTrack.getChannelCount() >= 2) ? "stereo" : "mono") + " " + ((mAudioTrack.getAudioFormat() == AudioFormat.ENCODING_PCM_16BIT) ? "16-bit" : "8-bit") + " " + ((float)mAudioTrack.getSampleRate() / 1000f) + "kHz, " + desiredFrames + " frames buffer");

        if (is16Bit) {

            buf = new short[desiredFrames * (isStereo ? 2 : 1)];

        } else {

            buf = new byte[desiredFrames * (isStereo ? 2 : 1)];

        }

        return buf;

    }

    public static void audioStartThread() {

        mAudioThread = new Thread(new Runnable() {

            public void run() {

                mAudioTrack.play();

                nativeRunAudioThread();

            }

        });

        // I'd take REALTIME if I could get it!

        mAudioThread.setPriority(Thread.MAX_PRIORITY);

        mAudioThread.start();

    }

    public static void audioWriteShortBuffer(short[] buffer) {

        for (int i = 0; i < buffer.length; ) {

            int result = mAudioTrack.write(buffer, i, buffer.length - i);

            if (result > 0) {

                i += result;

            } else if (result == 0) {

                try {

                    Thread.sleep(1);

                } catch(InterruptedException e) {

                    // Nom nom

                }

            } else {

                Log.w("SDL", "SDL audio: error return from write(short)");

                return;

            }

        }

    }

    public static void audioWriteByteBuffer(byte[] buffer) {

        for (int i = 0; i < buffer.length; ) {

            int result = mAudioTrack.write(buffer, i, buffer.length - i);

            if (result > 0) {

                i += result;

            } else if (result == 0) {

                try {

                    Thread.sleep(1);

                } catch(InterruptedException e) {

                    // Nom nom

                }

            } else {

                Log.w("SDL", "SDL audio: error return from write(short)");

                return;

            }

        }

    }

    public static void audioQuit() {

        if (mAudioThread != null) {

            try {

                mAudioThread.join();

            } catch(Exception e) {

                Log.v("SDL", "Problem stopping audio thread: " + e);

            }

            mAudioThread = null;

            //Log.v("SDL", "Finished waiting for audio thread");

        }

        if (mAudioTrack != null) {

            mAudioTrack.stop();

            mAudioTrack = null;

        }

    }

    public static int getDensity(){

        DisplayMetrics dm = SDLActivity.getContext().getResources().getDisplayMetrics();

        return dm.densityDpi;

    }

}

/**

    Simple nativeInit() runnable

 */

class SDLMain implements Runnable {

    public static final String TAG = "SDLMain";

    public static final int RQ_LOWRES            = 0x00000001; // use half land array

    public static final int RQ_BLURRY_LAND       = 0x00000002; // downscaled terrain

    public static final int RQ_NO_BACKGROUND     = 0x00000004; // don't draw background

    public static final int RQ_SIMPLE_ROPE       = 0x00000008; // avoid drawing rope

    public static final int RQ_2D_WATER          = 0x00000010; // disabe 3D water effect

    public static final int RQ_SIMPLE_EXPLOSIONS = 0x00000020; // no fancy explosion effects

    public static final int RQ_NO_FLAKES         = 0x00000040; // no flakes

    public static final int RQ_NO_MENU_ANIM      = 0x00000080; // ammomenu appears with no animation

    public static final int RQ_NO_DROPLETS       = 0x00000100; // no droplets

    public static final int RQ_NO_CLAMPING       = 0x00000200; // don't clamp textures

    public static final int RQ_NO_TOOLTIPS       = 0x00000400; // tooltips are not drawn

    public static final int RQ_NO_VSYNC          = 0x00000800; // don't sync on vblank

    private final int surfaceWidth, surfaceHeight;

    private final String playerName;

    private final GameConfig config;

    private final boolean netgame;

    public SDLMain(int width, int height, GameConfig config, boolean netgame) {

        surfaceWidth = width;

        surfaceHeight = height;

        if(netgame) {

            playerName = Netplay.getAppInstance(SDLActivity.getContext().getApplicationContext()).getPlayerName();

        } else {

            playerName = "Player";

        }

        this.config = config;

        this.netgame = netgame;

    }

    public void run() {

        //Set up the IPC socket server to communicate with the engine

        GameConnection gameConn;

        String path;

        try {

            if(netgame) {

                Netplay netplay = Netplay.getAppInstance(SDLActivity.mSingleton.getApplicationContext());

                gameConn = GameConnection.forNetgame(config, netplay);

            } else {

                gameConn = GameConnection.forLocalGame(config);

            }

            path = FileUtils.getDataPathFile(SDLActivity.mSingleton).getAbsolutePath();

            Log.d(TAG, "Starting engine");

            // Runs SDL_main() with added parameters

            try {

                String pPort = String.valueOf(gameConn.port);

                String pWidth = String.valueOf(surfaceWidth);

                String pHeight = String.valueOf(surfaceHeight);

                String pQuality = Integer.toString(RQ_NO_FLAKES|RQ_NO_DROPLETS|RQ_SIMPLE_EXPLOSIONS);

                String pPlayerName = Base64.encodeToString(playerName.getBytes("UTF-8"), 0);

                SDLActivity.synchronizedNativeInit(new String[] { pPort, pWidth, pHeight, pQuality, "en.txt", pPlayerName, "1", "1", "1", path, ""  });

            } catch (UnsupportedEncodingException e) {

                throw new AssertionError(e); // never happens

            }

            Log.d(TAG, "Engine stopped");

        } catch(ConnectException e) {

            Log.e(TAG, "Error starting IPC connection");

        } catch (IOException e) {

            Log.e(TAG, "Missing SDCard");

        }

        SDLActivity.mSingleton.runOnUiThread(new Runnable() { public void run() {

            if(SDLActivity.mSingleton != null) {

                SDLActivity.mSingleton.finish();

            }

        }});

    }

}

/**

    SDLSurface. This is what we draw on, so we need to know when it's created

    in order to do anything useful.