public abstract class Shader {
    private final int programID;
    private final int vsID;
    private final int fsID;

    public Shader(String name) {
        programID = glCreateProgram();
        vsID = loadShader(name+".vs", GL_VERTEX_SHADER);
        fsID = loadShader(name+".fs", GL_FRAGMENT_SHADER);
        glAttachShader(programID, vsID);
        glAttachShader(programID, fsID);
        bindAttributes();
        glLinkProgram(programID);
        glValidateProgram(programID);

        getAllUniformLocations();
    }

    protected abstract void bindAttributes();
    protected abstract void getAllUniformLocations();

    protected void bindAttribute(int attrib, String varName) {
        glBindAttribLocation(programID, attrib, varName);
    }

    protected int getUniformLocation(String varName) {
        return glGetUniformLocation(programID, varName);
    }

    public void loadMatrix(int loc, Matrix4f matrix) {
        FloatBuffer matrixBuffer = BufferUtils.createFloatBuffer(16);
        matrix.store(matrixBuffer);
        matrixBuffer.flip();
        glUniformMatrix4(loc, false, matrixBuffer);

        matrixBuffer = null;
    }

    public void loadLight(int loc1, int loc2, Light light) {
        loadVector(loc1, light.getPos());
        loadVector(loc2, light.getColor());
    }

    public void loadColor(int loc, float r, float g, float b) {
        loadVector(loc, new Vector3f(r,g,b));
    }

    public void loadShininess(int loc1, int loc2, float shineDamper, float refl) {
        loadFloat(loc1, shineDamper);
        loadFloat(loc2, refl);
    }

    protected void loadVector(int loc, Vector3f vec) {
        glUniform3f(loc, vec.x, vec.y,vec.z);
    }

    protected void loadFloat(int loc, float value) {
        glUniform1f(loc, value);
    }

    public void loadBoolean(int loc, boolean value) {
        if(value) {
            loadFloat(loc, 1);
        } else {
            loadFloat(loc, 0);
        }
    }

    public void start() {
        glUseProgram(programID);
    }

    public void stop() {
        glUseProgram(0);
    }

    private int loadShader(String name, int type) {
        StringBuilder shaderSource = new StringBuilder();
        try {
            BufferedReader reader = new BufferedReader(new FileReader(maindir+"/res/shader/"+name));
            String line;
            while((line = reader.readLine()) != null) {
                shaderSource.append(line).append("\n");
            }
        } catch (FileNotFoundException ex) {
            Logger.getLogger(Shader.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IOException ex) {
            Logger.getLogger(Shader.class.getName()).log(Level.SEVERE, null, ex);
        }

        int shaderID = glCreateShader(type);
        glShaderSource(shaderID, shaderSource);
        glCompileShader(shaderID);
        if(glGetShaderi(shaderID, GL_COMPILE_STATUS)==GL_FALSE) {
            System.out.println(glGetShaderInfoLog(shaderID));
            System.err.println("[SHADER] Could not compile shader");
            GameClass.exit(1);
        }

        return shaderID;
    }

    public int getProgramID() {
        return programID;
    }

    public void delete() {
        stop();
        glDetachShader(programID, vsID);
        glDetachShader(programID, fsID);
        glDeleteShader(vsID);
        glDeleteShader(fsID);
        glDeleteProgram(programID);
        System.out.println("[SHADER] Deleted shader # "+programID);
    }
}