import { Vec2 } from "./common.js"

function fullscreenCanvas(gfx: Graphics, id: string) {
    const canvas  = document.getElementById(id) as HTMLCanvasElement;
    canvas.width  = window.innerWidth;
    canvas.height = window.innerHeight;
    gfx.ctx.viewport(0, 0, canvas.width, canvas.height);
}

function createShader(ctx: WebGL2RenderingContext, type: GLenum, source: string): WebGLShader {
    var shader = ctx.createShader(type);
    if (!shader) {
        throw new Error("Couldn't create shader: " + type);
    }

    ctx.shaderSource(shader, source);
    ctx.compileShader(shader);

    var success = ctx.getShaderParameter(shader, ctx.COMPILE_STATUS);
    if (!success) {
        console.log(ctx.getShaderInfoLog(shader));
        ctx.deleteShader(shader);
        throw new Error("Couldn't compile shader: " + type);
    }

    return shader;
}

function createProgram(ctx: WebGL2RenderingContext, vertexShaderSource: string | null, fragmentShaderSource: string | null): WebGLProgram {
    var program = ctx.createProgram();

    if (vertexShaderSource !== null) {
        const vs = createShader(ctx, ctx.VERTEX_SHADER, vertexShaderSource);
        ctx.attachShader(program, vs);
    }

    if (fragmentShaderSource !== null) {
        const fs = createShader(ctx, ctx.FRAGMENT_SHADER, fragmentShaderSource);
        ctx.attachShader(program, fs);
    }

    ctx.linkProgram(program);

    var success = ctx.getProgramParameter(program, ctx.LINK_STATUS);
    if (!success) {
        console.log(ctx.getProgramInfoLog(program));
        ctx.deleteProgram(program);
        throw new Error("Failed to create program!");
    }

    return program;
}

class Graphics {
    ctx: WebGL2RenderingContext;
    program: WebGLProgram;
    attribs: Map<string, Attribute> = new Map();
    uniforms: Map<string, WebGLUniformLocation> = new Map();
    vao: WebGLVertexArrayObject;
    constructor(ctx: WebGL2RenderingContext, vs: string, fs: string) {
        this.ctx = ctx;
        this.program = createProgram(ctx, vs, fs);
        this.vao = ctx.createVertexArray();

        ctx.bindVertexArray(this.vao);
        ctx.viewport(0, 0, ctx.canvas.width, ctx.canvas.height);
        ctx.useProgram(this.program);
    }

    clear(r: number, g: number, b: number, a: number) {
        this.ctx.clearColor(r, g, b, a);
        this.ctx.clear(this.ctx.COLOR_BUFFER_BIT);
    }

    createAttribute(name: string): Attribute {
        const attrib = new Attribute(this.ctx, this.program, name);
        this.attribs.set(name, attrib);
        return attrib;
    }

    getAttribute(name: string): Attribute {
        const attrib = this.attribs.get(name);

        if (attrib === undefined)
            throw new Error("Tried to get uninitialized attribute: " + name);

        return attrib;
    }

    createUniform(name: string) {
        const loc = this.ctx.getUniformLocation(this.program, name);

        if (loc === null)
            throw new Error("Couldn't get location for uniform: " + name);

        this.uniforms.set(name, loc);
    }

    getUniform(name: string): WebGLUniformLocation {
        const loc = this.uniforms.get(name);

        if (loc === undefined)
            throw new Error("Tried to get uninitialized uniform: " + name);

        return loc;
    }
}

class Attribute {
    loc: GLint;
    buffer: WebGLBuffer;

    // TODO: maybe use undefined as default value?
    size: GLint = 0;
    type: GLenum = 0;
    normalized: GLboolean = false;
    stride: GLsizei = 0;
    offset: GLintptr = 0;

    constructor(ctx: WebGL2RenderingContext, program: WebGLProgram, name: string) {
        this.loc = ctx.getAttribLocation(program, name);
        this.buffer = ctx.createBuffer();

        ctx.enableVertexAttribArray(this.loc);
    }

    format(
        size: GLint,
        type: GLenum,
        normalized: GLboolean,
        stride: GLsizei,
        offset: GLintptr)
    {
        this.size = size;
        this.type = type;
        this.normalized = normalized;
        this.stride = stride;
        this.offset = offset;
    }

    data(ctx: WebGL2RenderingContext, data: Array<number>, usage: GLenum) {
        ctx.bindBuffer(ctx.ARRAY_BUFFER, this.buffer);
        ctx.bufferData(ctx.ARRAY_BUFFER, new Float32Array(data), usage);
        ctx.vertexAttribPointer(this.loc, this.size, this.type, this.normalized, this.stride, this.offset);
    }
}

export { fullscreenCanvas, Graphics, Attribute }