package org.hedgewars.hedgeroid;

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.EngineProtocol.PascalExports;

import org.hedgewars.hedgeroid.frontlib.Flib;

import org.hedgewars.hedgeroid.frontlib.Frontlib.GameSetupPtr;

import org.hedgewars.hedgeroid.frontlib.Frontlib.GameconnPtr;

import org.hedgewars.hedgeroid.netplay.TickHandler;

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.os.Handler;

import android.os.HandlerThread;

import android.os.Message;

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;

	// Main components

	public static SDLActivity mSingleton;

	private static SDLSurface mSurface;

	// This is what SDL runs in. It invokes SDL_main(), eventually

	private static Thread mSDLThread; // Guarded by SDLActivity.class

	// 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("SDL_image");

		//System.loadLibrary("SDL_mixer");

		//System.loadLibrary("SDL_ttf");

		System.loadLibrary("main");

	}

	// Setup

	protected void onCreate(Bundle savedInstanceState) {

		//Log.v("SDL", "onCreate()");

		super.onCreate(savedInstanceState);

		// So we can call stuff from static callbacks

		mSingleton = this;

		// Set up the surface

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

		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

		synchronized(SDLActivity.class) {

			if (mSDLThread != null) {

				try {

					mSDLThread.join();

				} catch(Exception e) {

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

				}

				mSDLThread = null;

			}

		}

	}

	// Messages from the SDLMain thread

	static int COMMAND_CHANGE_TITLE = 1;

	// Handler for the messages

	Handler commandHandler = new Handler() {

		public void handleMessage(Message msg) {

			if (msg.arg1 == COMMAND_CHANGE_TITLE) {

				setTitle((String)msg.obj);

			}

		}

	};

	// Send a message from the SDLMain thread

	void sendCommand(int command, Object data) {

		Message msg = commandHandler.obtainMessage();

		msg.arg1 = command;

		msg.obj = data;

		commandHandler.sendMessage(msg);

	}

	// C functions we call

	public 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(String title) {

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

		mSingleton.sendCommand(COMMAND_CHANGE_TITLE, title);

	}

	public static Context getContext() {

		return mSingleton;

	}

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

		synchronized(SDLActivity.class) {

			// Start up the C app thread

			if (mSDLThread == null) {

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

				mSDLThread.start();

			} else {

				SDLActivity.nativeResume();

			}

		}

	}

	// EGL functions

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

		if (SDLActivity.mEGLDisplay == null) {

			//Log.v("SDL", "Starting up OpenGL ES " + majorVersion + "." + minorVersion);

			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_DEPTH_SIZE,   16,

						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];

				/*int EGL_CONTEXT_CLIENT_VERSION=0x3098;

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

                EGLContext ctx = egl.eglCreateContext(dpy, config, EGL10.EGL_NO_CONTEXT, contextAttrs);

                if (ctx == EGL10.EGL_NO_CONTEXT) {

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

                    return false;

                }

                SDLActivity.mEGLContext = ctx;*/

				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 {

	private final int surfaceWidth, surfaceHeight;

	private final GameConfig config;

	public SDLMain(int width, int height, GameConfig _config) {

		config = _config;

		surfaceWidth = width;

		surfaceHeight = height;

	}

	public void run() {

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

		final GameconnPtr conn = Flib.INSTANCE.flib_gameconn_create("Xeli", GameSetupPtr.createJavaOwned(config), false);

		if(conn == null) {

			throw new AssertionError();

		}

		int port = Flib.INSTANCE.flib_gameconn_getport(conn);

		String path = Utils.getDataPath(SDLActivity.mSingleton);//This represents the data directory

		path = path.substring(0, path.length()-1);//remove the trailing '/'

		// Runs SDL_main() with added parameters

		SDLActivity.nativeInit(new String[] { String.valueOf(port),

				String.valueOf(surfaceWidth), String.valueOf(surfaceHeight),

				"0", "en.txt", "xeli", "1", "1", "1", path, ""  });

		try {

			thread.join();

		} catch (InterruptedException e) {

			throw new AssertionError();

		}

		Flib.INSTANCE.flib_gameconn_destroy(conn);

	}

}

/**

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

    in order to do anything useful.