package southgrove.droidgl;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.StringWriter;
import java.io.UnsupportedEncodingException;
import java.io.Writer;
import java.util.HashMap;

import android.content.Context;
import android.opengl.GLES20;
import android.util.Log;

public class Shaders
{

    private static HashMap<String, Integer> programMap;
    private static String[]                 names;
    private static int[]                    programIds;

    @SuppressWarnings("unused")
    private static Boolean                  initialized = initialize();

    private static Boolean initialize()
    {
        programMap = new HashMap<String, Integer>();
        programIds = new int[0];
        names = new String[0];

        return true;
    }

    private static String loadSource(Context context, int resourceId)
    {
        InputStream inputStream = context.getResources().openRawResource(resourceId);

        if (inputStream == null)
            throw new RuntimeException("Could not get resource.");

        char[] buffer = new char[1024];
        Writer writer = new StringWriter();

        try
        {
            Reader reader = new BufferedReader(new InputStreamReader(inputStream, "UTF-8"));
            try
            {
                int n;
                while ((n = reader.read(buffer)) != -1)
                    writer.write(buffer, 0, n);
            } catch (IOException e)
            {
                Log.e("SHADER", "IO Error", e);
            }
        } catch (UnsupportedEncodingException e)
        {
            Log.e("SHADER", "Encoding Error", e);
        }

        try
        {
            inputStream.close();
        } catch (IOException e)
        {
            Log.e("SHADER", "IO Error", e);
        }

        // Log.v("SHADER", "Shader source:");
        // Log.v("SHADER", writer.toString());
        // Log.v("SHADER", "---- end of shader source ----");

        return writer.toString();
    }

    private static int compileShader(int shaderType, String source)
    {
        int shader = GLES20.glCreateShader(shaderType);
        if (shader != 0)
        {
            GLES20.glShaderSource(shader, source);
            GLES20.glCompileShader(shader);

            int[] compileStatus = new int[1];
            GLES20.glGetShaderiv(shader, GLES20.GL_COMPILE_STATUS, compileStatus, 0);
            if (compileStatus[0] == 0)
            {
                Log.e("SHADER", "Shader compilation failed. " + shaderType + ':');
                Log.e("SHADER", GLES20.glGetShaderInfoLog(shader));
                GLES20.glDeleteShader(shader);
                shader = 0;
            }
        }
        return shader;
    }

    private static void checkGLError(String op)
    {
        int error;
        if ((error = GLES20.glGetError()) != GLES20.GL_NO_ERROR)
        {
            Log.e("SHADER", op + ": glError " + error);
            throw new RuntimeException(op + ": glError " + error);
        }
    }

    private static void addNameProgramPair(String name, int programId)
    {
        // add new texture id
        String[] newNames = new String[names.length + 1];
        for (int i = 0; i < names.length; i++)
            newNames[i] = names[i];
        newNames[names.length] = name;
        names = newNames;

        // add new resource id
        int[] newProgramIds = new int[programIds.length + 1];
        for (int i = 0; i < programIds.length; i++)
            newProgramIds[i] = programIds[i];
        newProgramIds[programIds.length] = programId;
        programIds = newProgramIds;

        programMap.put(name, programId);
    }

    public static void createProgram(Context context, String name, int vertexShaderResourceId, int fragmentShaderResourceId)
    {
        String vertexShaderSource = loadSource(context, vertexShaderResourceId);
        String fragmentShaderSource = loadSource(context, fragmentShaderResourceId);

        int vertexShader = compileShader(GLES20.GL_VERTEX_SHADER, vertexShaderSource);
        int fragmentShader = compileShader(GLES20.GL_FRAGMENT_SHADER, fragmentShaderSource);

        if (vertexShader == 0 || fragmentShader == 0)
            throw new RuntimeException("Could not compile shaders.");

        int program = GLES20.glCreateProgram();
        if (program != 0)
        {
            GLES20.glAttachShader(program, vertexShader);
            checkGLError("glAttachShader");

            GLES20.glAttachShader(program, fragmentShader);
            checkGLError("glAttachShader");

            GLES20.glLinkProgram(program);

            int[] linkStatus = new int[1];
            GLES20.glGetProgramiv(program, GLES20.GL_LINK_STATUS, linkStatus, 0);
            if (linkStatus[0] != GLES20.GL_TRUE)
            {
                Log.e("SHADER", "Could not link program:");
                Log.e("SHADER", GLES20.glGetProgramInfoLog(program));
                GLES20.glDeleteProgram(program);
                program = 0;
            }
        }

        if (program == 0)
            throw new RuntimeException("Could not link shader program.");

        addNameProgramPair(name, program);

        Log.v("SHADER", "Added program \"" + name + "\" with handle " + Integer.toString(program));
    }

    public static int getProgram(String name)
    {
        return programMap.get(name);
    }

}