/* Copyright (c) 2012 Sundog Software LLC. All rights reserved worldwide. */

// Most of the SilverLining integration code is in the Renderer inner class toward the end of this file.

package com.sundogsoftware;

import android.content.Context;
import android.graphics.PixelFormat;
import android.opengl.GLSurfaceView;
import android.util.AttributeSet;
import android.util.Log;
import android.view.MotionEvent;
import android.opengl.Matrix;
import android.util.FloatMath;

import android.content.res.AssetManager;

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.opengles.GL10;

import com.sundogsoftware.silverlining.*;

class SilverLiningDemoView extends GLSurfaceView {
    private static String TAG = "SilverLiningAndroidDemo";
    private static final boolean DEBUG = false;

	private float startX = 0, startY = 0;
	private float curX = 0, curY = 0;
	private float startPitch = 0, startYaw = 0;
	private boolean touchDown = false;
	private Renderer renderer;

    public SilverLiningDemoView(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

	public void initialize(AssetManager assets) {
		init(false, 16, 0, assets);
	}

	@Override
	public boolean onTouchEvent(MotionEvent event) {
		if (event.getAction() == MotionEvent.ACTION_DOWN && renderer != null) {
			touchDown = true;
			startX = event.getX();
			startY = event.getY();
			startPitch = renderer.getPitch();
			startYaw = renderer.getYaw();
		} else if (event.getAction() == MotionEvent.ACTION_UP) {
			touchDown = false;
		}

		curX = event.getX();
		curY = event.getY();

		if (touchDown && renderer != null) {
			float perX = (curX - startX) / (float)renderer.getWidth();
			float perY = (curY - startY) / (float)renderer.getHeight();
			final float maxYaw = 90.0f;
			final float maxPitch = 90.0f;
			float dPitch = perY * maxPitch;
			float dYaw = perX * maxYaw;
			renderer.setCameraOrientation( startYaw + dYaw, startPitch + dPitch);

			return true;
		}

		return super.onTouchEvent(event);
	}

    private void init(boolean translucent, int depth, int stencil, AssetManager assets) {

        /* By default, GLSurfaceView() creates a RGB_565 opaque surface.
         * If we want a translucent one, we should change the surface's
         * format here, using PixelFormat.TRANSLUCENT for GL Surfaces
         * is interpreted as any 32-bit surface with alpha by SurfaceFlinger.
         */
        if (translucent) {
            this.getHolder().setFormat(PixelFormat.TRANSLUCENT);
        }

        /* Setup the context factory for 2.0 rendering.
         * See ContextFactory class definition below
         */
        setEGLContextFactory(new ContextFactory());

        /* We need to choose an EGLConfig that matches the format of
         * our surface exactly. This is going to be done in our
         * custom config chooser. See ConfigChooser class definition
         * below.
         */
        setEGLConfigChooser( new ConfigChooser(8, 8, 8, 8, depth, stencil));

        /* Set the renderer responsible for frame rendering */
		renderer = new Renderer(assets);
        setRenderer(renderer);
    }
    
    public void setTime(int hour, int minute) {
    	if (renderer != null) {
    		renderer.setTime(hour, minute);
    	}
    }
    
    public LocalTime getDateTime() {
    	if (renderer != null) {
    		return renderer.getDateTime();
    	} else {
    		return null;
    	}
    }
    
    public void enableCumulus(boolean enable) {
    	if (renderer != null) {
    		renderer.enableCumulus(enable);
    	}
    }

    public void enableCirrus(boolean enable) {
    	if (renderer != null) {
    		renderer.enableCirrus(enable);
    	}
    }
    
    public void enableStratus(boolean enable) {
    	if (renderer != null) {
    		renderer.enableStratus(enable);
    	}
    }
    
    private static class ContextFactory implements GLSurfaceView.EGLContextFactory {
        private static int EGL_CONTEXT_CLIENT_VERSION = 0x3098;
        public EGLContext createContext(EGL10 egl, EGLDisplay display, EGLConfig eglConfig) {
            Log.w(TAG, "creating OpenGL ES 2.0 context");
            checkEglError("Before eglCreateContext", egl);
            int[] attrib_list = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL10.EGL_NONE };
            EGLContext context = egl.eglCreateContext(display, eglConfig, EGL10.EGL_NO_CONTEXT, attrib_list);
            checkEglError("After eglCreateContext", egl);
            return context;
        }

        public void destroyContext(EGL10 egl, EGLDisplay display, EGLContext context) {
            egl.eglDestroyContext(display, context);
        }
    }

    private static void checkEglError(String prompt, EGL10 egl) {
        int error;
        while ((error = egl.eglGetError()) != EGL10.EGL_SUCCESS) {
            Log.e(TAG, String.format("%s: EGL error: 0x%x", prompt, error));
        }
    }

    private static class ConfigChooser implements GLSurfaceView.EGLConfigChooser {

        public ConfigChooser(int r, int g, int b, int a, int depth, int stencil) {
            mRedSize = r;
            mGreenSize = g;
            mBlueSize = b;
            mAlphaSize = a;
            mDepthSize = depth;
            mStencilSize = stencil;
        }

        /* This EGL config specification is used to specify 2.0 rendering.
         * We use a minimum size of 4 bits for red/green/blue, but will
         * perform actual matching in chooseConfig() below.
         */
        private static int EGL_OPENGL_ES2_BIT = 4;
        private static int[] s_configAttribs2 =
        {
            EGL10.EGL_RED_SIZE, 4,
            EGL10.EGL_GREEN_SIZE, 4,
            EGL10.EGL_BLUE_SIZE, 4,
            EGL10.EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
            EGL10.EGL_NONE
        };

        public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display) {

            /* Get the number of minimally matching EGL configurations
             */
            int[] num_config = new int[1];
            egl.eglChooseConfig(display, s_configAttribs2, null, 0, num_config);

            int numConfigs = num_config[0];

            if (numConfigs <= 0) {
                throw new IllegalArgumentException("No configs match configSpec");
            }

            /* Allocate then read the array of minimally matching EGL configs
             */
            EGLConfig[] configs = new EGLConfig[numConfigs];
            egl.eglChooseConfig(display, s_configAttribs2, configs, numConfigs, num_config);

            if (DEBUG) {
                 printConfigs(egl, display, configs);
            }
            /* Now return the "best" one
             */
            return chooseConfig(egl, display, configs);
        }

        public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display,
                EGLConfig[] configs) {
            for(EGLConfig config : configs) {
                int d = findConfigAttrib(egl, display, config,
                        EGL10.EGL_DEPTH_SIZE, 0);
                int s = findConfigAttrib(egl, display, config,
                        EGL10.EGL_STENCIL_SIZE, 0);

                // We need at least mDepthSize and mStencilSize bits
                if (d < mDepthSize || s < mStencilSize)
                    continue;

                // We want an *exact* match for red/green/blue/alpha
                int r = findConfigAttrib(egl, display, config,
                        EGL10.EGL_RED_SIZE, 0);
                int g = findConfigAttrib(egl, display, config,
                            EGL10.EGL_GREEN_SIZE, 0);
                int b = findConfigAttrib(egl, display, config,
                            EGL10.EGL_BLUE_SIZE, 0);
                int a = findConfigAttrib(egl, display, config,
                        EGL10.EGL_ALPHA_SIZE, 0);

                if (r == mRedSize && g == mGreenSize && b == mBlueSize && a == mAlphaSize)
                    return config;
            }
            return null;
        }

        private int findConfigAttrib(EGL10 egl, EGLDisplay display,
                EGLConfig config, int attribute, int defaultValue) {

            if (egl.eglGetConfigAttrib(display, config, attribute, mValue)) {
                return mValue[0];
            }
            return defaultValue;
        }

        private void printConfigs(EGL10 egl, EGLDisplay display,
            EGLConfig[] configs) {
            int numConfigs = configs.length;
            Log.w(TAG, String.format("%d configurations", numConfigs));
            for (int i = 0; i < numConfigs; i++) {
                Log.w(TAG, String.format("Configuration %d:\n", i));
                printConfig(egl, display, configs[i]);
            }
        }

        private void printConfig(EGL10 egl, EGLDisplay display,
                EGLConfig config) {
            int[] attributes = {
                    EGL10.EGL_BUFFER_SIZE,
                    EGL10.EGL_ALPHA_SIZE,
                    EGL10.EGL_BLUE_SIZE,
                    EGL10.EGL_GREEN_SIZE,
                    EGL10.EGL_RED_SIZE,
                    EGL10.EGL_DEPTH_SIZE,
                    EGL10.EGL_STENCIL_SIZE,
                    EGL10.EGL_CONFIG_CAVEAT,
                    EGL10.EGL_CONFIG_ID,
                    EGL10.EGL_LEVEL,
                    EGL10.EGL_MAX_PBUFFER_HEIGHT,
                    EGL10.EGL_MAX_PBUFFER_PIXELS,
                    EGL10.EGL_MAX_PBUFFER_WIDTH,
                    EGL10.EGL_NATIVE_RENDERABLE,
                    EGL10.EGL_NATIVE_VISUAL_ID,
                    EGL10.EGL_NATIVE_VISUAL_TYPE,
                    0x3030, // EGL10.EGL_PRESERVED_RESOURCES,
                    EGL10.EGL_SAMPLES,
                    EGL10.EGL_SAMPLE_BUFFERS,
                    EGL10.EGL_SURFACE_TYPE,
                    EGL10.EGL_TRANSPARENT_TYPE,
                    EGL10.EGL_TRANSPARENT_RED_VALUE,
                    EGL10.EGL_TRANSPARENT_GREEN_VALUE,
                    EGL10.EGL_TRANSPARENT_BLUE_VALUE,
                    0x3039, // EGL10.EGL_BIND_TO_TEXTURE_RGB,
                    0x303A, // EGL10.EGL_BIND_TO_TEXTURE_RGBA,
                    0x303B, // EGL10.EGL_MIN_SWAP_INTERVAL,
                    0x303C, // EGL10.EGL_MAX_SWAP_INTERVAL,
                    EGL10.EGL_LUMINANCE_SIZE,
                    EGL10.EGL_ALPHA_MASK_SIZE,
                    EGL10.EGL_COLOR_BUFFER_TYPE,
                    EGL10.EGL_RENDERABLE_TYPE,
                    0x3042 // EGL10.EGL_CONFORMANT
            };
            String[] names = {
                    "EGL_BUFFER_SIZE",
                    "EGL_ALPHA_SIZE",
                    "EGL_BLUE_SIZE",
                    "EGL_GREEN_SIZE",
                    "EGL_RED_SIZE",
                    "EGL_DEPTH_SIZE",
                    "EGL_STENCIL_SIZE",
                    "EGL_CONFIG_CAVEAT",
                    "EGL_CONFIG_ID",
                    "EGL_LEVEL",
                    "EGL_MAX_PBUFFER_HEIGHT",
                    "EGL_MAX_PBUFFER_PIXELS",
                    "EGL_MAX_PBUFFER_WIDTH",
                    "EGL_NATIVE_RENDERABLE",
                    "EGL_NATIVE_VISUAL_ID",
                    "EGL_NATIVE_VISUAL_TYPE",
                    "EGL_PRESERVED_RESOURCES",
                    "EGL_SAMPLES",
                    "EGL_SAMPLE_BUFFERS",
                    "EGL_SURFACE_TYPE",
                    "EGL_TRANSPARENT_TYPE",
                    "EGL_TRANSPARENT_RED_VALUE",
                    "EGL_TRANSPARENT_GREEN_VALUE",
                    "EGL_TRANSPARENT_BLUE_VALUE",
                    "EGL_BIND_TO_TEXTURE_RGB",
                    "EGL_BIND_TO_TEXTURE_RGBA",
                    "EGL_MIN_SWAP_INTERVAL",
                    "EGL_MAX_SWAP_INTERVAL",
                    "EGL_LUMINANCE_SIZE",
                    "EGL_ALPHA_MASK_SIZE",
                    "EGL_COLOR_BUFFER_TYPE",
                    "EGL_RENDERABLE_TYPE",
                    "EGL_CONFORMANT"
            };
            int[] value = new int[1];
            for (int i = 0; i < attributes.length; i++) {
                int attribute = attributes[i];
                String name = names[i];
                if ( egl.eglGetConfigAttrib(display, config, attribute, value)) {
                    Log.w(TAG, String.format("  %s: %d\n", name, value[0]));
                } else {
                    // Log.w(TAG, String.format("  %s: failed\n", name));
                    while (egl.eglGetError() != EGL10.EGL_SUCCESS);
                }
            }
        }

        // Subclasses can adjust these values:
        protected int mRedSize;
        protected int mGreenSize;
        protected int mBlueSize;
        protected int mAlphaSize;
        protected int mDepthSize;
        protected int mStencilSize;
        private int[] mValue = new int[1];
    }

    /** The Renderer class contains most of the actual integration code for SilverLining. */
    private static class Renderer implements GLSurfaceView.Renderer {

    	// Set up some members for the SilverLining Java interface, and some cloud layers:
		SilverLining mSilverLining;
		CloudLayer cirrusLayer, cumulusLayer, stratusLayer;
		
		float mAspect;
		float[] mModelview;
		float[] mProjection;
		AssetManager mAssets;
		float mPitch = -15.0f;
		float mYaw = 0.0f;
		int mWidth, mHeight;

		public Renderer(AssetManager assets) {
			super();
			mAssets = assets;
		}

		public void setCameraOrientation(float yaw, float pitch) {
			mYaw = yaw;
			mPitch = pitch;
			SetMatrices();
		}

		public float getYaw() {return mYaw;}
		public float getPitch() {return mPitch;}
		public int getWidth() {return mWidth;}
		public int getHeight() {return mHeight;}

        public void onDrawFrame(GL10 gl) {
        	// Each frame, inform SilverLining of your view and projection matrices
			if (mSilverLining != null) {
				mSilverLining.SetMatrices(mModelview, mProjection);

				// Tell SilverLining to draw the sky box as the first thing in your scene:
				mSilverLining.DrawSky();

				// Draw your own objects here...
				
				// Then, draw SilverLining's clouds and translucent effects last:
				mSilverLining.DrawClouds();
			}
       }

        public void onSurfaceChanged(GL10 gl, int width, int height) {
			gl.glViewport(0, 0, width, height);
			mAspect = (float)width / (float)height;
			mWidth = width;
			mHeight = height;
			SetMatrices();
        }

        public void onSurfaceCreated(GL10 gl, EGLConfig config) {
        	
        	// Instantiate SilverLining and tie it to our asset manager. Make sure
        	// you've included SilverLining's assets/Resources directory in your own
        	// app, or initialization will fail!
			mSilverLining = new SilverLining();
			
			// If you have a license code, pass it in here. Without a real license name
			// and code, SilverLining will only run for five minutes at a time and then
			// terminate your app. Visit www.sundog-soft.com for license info or contact
			// sales@sundog-soft.com
			if (!mSilverLining.Initialize("User name", "License code", mAssets)) {
				Log.e(TAG, "Error initializing SilverLining.");
				return;
			}

			// Add some cloud layers...
			cirrusLayer = mSilverLining.AddCirrusLayer(8000.0f, 80000.0f);
			//mSilverLining.AddCirroCumulusLayer(8000.0f, 80000.0f);
			cumulusLayer = mSilverLining.AddCumulusCongestusLayer(3000.0f, 40000.0f, 0.5f);
			//mSilverLining.AddCumulusMediocrisLayer(3000.0f, 40000.0f, 0.2f);
			//mSilverLining.AddCumulonimbusCloud(1000.0f, 0.0f, -10000.0f, 4000.0f); 
			stratusLayer = mSilverLining.AddStratusLayer(1000.0f, 0.8f, 500.0f);
			stratusLayer.SetEnabled(false);
			//mSilverLining.SetSnow(10.0f, true);

			// Set a simulated location and time. Make sure the time zone offset and location
			// are consistent, or just use GMT time with a time zone offset of 0.
			mSilverLining.SetLocation(47.6097f, -122.3331f, 100.0f);
			mSilverLining.SetDate(2012, 7, 1);
			mSilverLining.SetTime(20, 0, 0, -8.0f, true);

			// Add a little wind to blow the clouds around.
			mSilverLining.SetWind(40.0f, 90.0f);
        }
        
        public void setTime(int hour, int minute) {
        	if (mSilverLining != null) {
        		mSilverLining.SetTime(hour, minute, 0, -8.0f, true);
        	}
        }
        
        public LocalTime getDateTime() {
        	if (mSilverLining != null) {
        		return mSilverLining.GetDateTime();
        	} else {
        		return null;
        	}
        }
        
        public void enableCumulus(boolean enable)
        {
        	if (cumulusLayer != null) {
        		cumulusLayer.SetEnabled(enable);
        	}
        }
        
        public void enableCirrus(boolean enable)
        {
        	if (cirrusLayer != null) {
        		cirrusLayer.SetEnabled(enable);
        	}
        }
        
        public void enableStratus(boolean enable)
        {
        	if (stratusLayer != null) {
        		stratusLayer.SetEnabled(enable);
        	}
        }
        
		private void SetMatrices() {
			mProjection = new float[16];
			mModelview = new float[16];
			perspectiveM(mProjection, 30.0f, mAspect, 10.0f, 100000.0f);
			Matrix.setIdentityM(mModelview, 0);
			Matrix.rotateM(mModelview, 0, mPitch, 1, 0, 0);
			Matrix.rotateM(mModelview, 0, mYaw, 0, 1, 0);
		}

		private static void perspectiveM(float[] m, float fovy, float aspect, float zNear, float zFar) {

			float sine, cotangent, deltaZ;
			float radians = (fovy / 2.0f) * (3.14159265f / 180.0f);

			deltaZ = zFar - zNear;
			sine = FloatMath.sin(radians);
			if ((deltaZ == 0) || (sine == 0) || (aspect == 0))
			{
				return;
			}
			cotangent = FloatMath.cos(radians) / sine;

			float p[];
			p = new float[16];
			Matrix.setIdentityM(p, 0);

			p[0] = cotangent / aspect;
			p[5] = cotangent;
			p[10] = -(zFar + zNear) / deltaZ;
			p[14] = -1;
			p[11] = -2 * zNear * zFar / deltaZ;
			p[15] = 0;

			Matrix.transposeM(m, 0, p, 0);
		}
    }
}
