const std = @import("std");
const mach = @import("mach");
const gpu = @import("gpu");
const glfw = @import("glfw");
const zm = @import("zmath");

const Vertex = @import("cube_mesh.zig").Vertex;
const vertices = @import("cube_mesh.zig").vertices;
const Quad = @import("quad_mesh.zig").Quad;
const quad = @import("quad_mesh.zig").quad;

pub const App = @This();

const pixel_size = 8;

const UniformBufferObject = struct {
    mat: zm.Mat,
};
const PostUniformBufferObject = struct {
    width: u32,
    height: u32,
    pixel_size: u32 = pixel_size,
};

timer: mach.Timer = undefined,
queue: *gpu.Queue,

pipeline: *gpu.RenderPipeline,
normal_pipeline: *gpu.RenderPipeline,
vertex_buffer: *gpu.Buffer,
uniform_buffer: *gpu.Buffer,
bind_group: *gpu.BindGroup,

post_pipeline: *gpu.RenderPipeline,
post_vertex_buffer: *gpu.Buffer,
post_uniform_buffer: *gpu.Buffer,
post_bind_group: *gpu.BindGroup,

draw_texture_view: *gpu.TextureView,
depth_texture_view: *gpu.TextureView,
normal_texture_view: *gpu.TextureView,

pub fn init(app: *App, core: *mach.Core) !void {
    app.timer = try mach.Timer.start();

    app.create_render_textures(core);
    app.create_draw_pipeline(core);
    app.create_post_pipeline(core);
}

pub fn deinit(app: *App, _: *mach.Core) void {
    app.cleanup();
}

pub fn resize(app: *App, core: *mach.Core, _: u32, _: u32) !void {
    app.cleanup();
    app.create_render_textures(core);
    app.create_draw_pipeline(core);
    app.create_post_pipeline(core);
}

pub fn update(app: *App, core: *mach.Core) !void {
    while (core.pollEvent()) |event| {
        switch (event) {
            .key_press => |ev| {
                if (ev.key == .space)
                    core.setShouldClose(true);
            },
            else => {},
        }
    }

    const encoder = core.device.createCommandEncoder(null);
    encoder.writeBuffer(app.post_uniform_buffer, 0, &[_]PostUniformBufferObject{
        PostUniformBufferObject{
            .width = core.getWindowSize().width,
            .height = core.getWindowSize().height,
        },
    });

    {
        const time = app.timer.read() * 0.5;
        const model = zm.mul(zm.rotationX(time * (std.math.pi / 2.0)), zm.rotationZ(time * (std.math.pi / 2.0)));
        const view = zm.lookAtRh(
            zm.f32x4(0, 5, 2, 1),
            zm.f32x4(0, 0, 0, 1),
            zm.f32x4(0, 0, 1, 0),
        );
        const proj = zm.perspectiveFovRh(
            (std.math.pi / 4.0),
            @intToFloat(f32, core.current_desc.width) / @intToFloat(f32, core.current_desc.height),
            0.1,
            10,
        );
        const mvp = zm.mul(zm.mul(model, view), proj);
        const ubo = UniformBufferObject{
            .mat = zm.transpose(mvp),
        };
        encoder.writeBuffer(app.uniform_buffer, 0, &[_]UniformBufferObject{ubo});
    }

    {
        // render scene to downscaled texture
        const color_attachment = gpu.RenderPassColorAttachment{
            .view = app.draw_texture_view,
            .clear_value = std.mem.zeroes(gpu.Color),
            .load_op = .clear,
            .store_op = .store,
        };
        const render_pass_info = gpu.RenderPassDescriptor.init(.{
            .color_attachments = &.{color_attachment},
            .depth_stencil_attachment = &gpu.RenderPassDepthStencilAttachment{
                .view = app.depth_texture_view,
                .depth_load_op = .clear,
                .depth_store_op = .store,
                .depth_clear_value = 1.0,
            },
        });

        const pass = encoder.beginRenderPass(&render_pass_info);
        pass.setPipeline(app.pipeline);
        pass.setVertexBuffer(0, app.vertex_buffer, 0, @sizeOf(Vertex) * vertices.len);
        pass.setBindGroup(0, app.bind_group, &.{0});
        pass.draw(vertices.len, 1, 0, 0);
        pass.end();
        pass.release();
    }

    {
        // render scene normals to texture
        const normal_color_attachment = gpu.RenderPassColorAttachment{
            .view = app.normal_texture_view,
            .clear_value = .{ .r = 0.5, .b = 0.5, .g = 0.5, .a = 1.0 },
            .load_op = .clear,
            .store_op = .store,
        };
        const normal_render_pass_info = gpu.RenderPassDescriptor.init(.{
            .color_attachments = &.{normal_color_attachment},
        });

        const normal_pass = encoder.beginRenderPass(&normal_render_pass_info);
        normal_pass.setPipeline(app.normal_pipeline);
        normal_pass.setVertexBuffer(0, app.vertex_buffer, 0, @sizeOf(Vertex) * vertices.len);
        normal_pass.setBindGroup(0, app.bind_group, &.{0});
        normal_pass.draw(vertices.len, 1, 0, 0);
        normal_pass.end();
        normal_pass.release();
    }

    const back_buffer_view = core.swap_chain.?.getCurrentTextureView();
    {
        // render to swap_chain using previous passes
        const post_color_attachment = gpu.RenderPassColorAttachment{
            .view = back_buffer_view,
            .clear_value = std.mem.zeroes(gpu.Color),
            .load_op = .clear,
            .store_op = .store,
        };
        const post_render_pass_info = gpu.RenderPassDescriptor.init(.{
            .color_attachments = &.{post_color_attachment},
        });

        const draw_pass = encoder.beginRenderPass(&post_render_pass_info);
        draw_pass.setPipeline(app.post_pipeline);
        draw_pass.setVertexBuffer(0, app.post_vertex_buffer, 0, @sizeOf(Quad) * quad.len);
        draw_pass.setBindGroup(0, app.post_bind_group, &.{0});
        draw_pass.draw(quad.len, 1, 0, 0);
        draw_pass.end();
        draw_pass.release();
    }

    var command = encoder.finish(null);
    encoder.release();

    app.queue.submit(&.{command});
    command.release();
    core.swap_chain.?.present();
    back_buffer_view.release();
}

fn cleanup(app: *App) void {
    app.vertex_buffer.release();
    app.uniform_buffer.release();
    app.bind_group.release();

    app.post_vertex_buffer.release();
    app.post_uniform_buffer.release();
    app.post_bind_group.release();

    app.draw_texture_view.release();
    app.depth_texture_view.release();
    app.normal_texture_view.release();
}

fn create_render_textures(app: *App, core: *mach.Core) void {
    const draw_texture_desc = gpu.Texture.Descriptor.init(.{
        .size = .{ .width = core.getWindowSize().width / pixel_size, .height = core.getWindowSize().height / pixel_size },
        .format = .bgra8_unorm,
        .usage = .{ .texture_binding = true, .copy_dst = true, .render_attachment = true },
    });
    const draw_texture = core.device.createTexture(&draw_texture_desc);
    app.draw_texture_view = draw_texture.createView(null);

    const depth_texture_desc = gpu.Texture.Descriptor.init(.{
        .size = .{ .width = core.getWindowSize().width / pixel_size, .height = core.getWindowSize().height / pixel_size },
        .format = .depth32_float,
        .usage = .{ .texture_binding = true, .copy_dst = true, .render_attachment = true },
    });
    const depth_texture = core.device.createTexture(&depth_texture_desc);
    app.depth_texture_view = depth_texture.createView(null);

    const normal_texture_desc = gpu.Texture.Descriptor.init(.{
        .size = .{ .width = core.getWindowSize().width / pixel_size, .height = core.getWindowSize().height / pixel_size },
        .format = .bgra8_unorm,
        .usage = .{ .texture_binding = true, .copy_dst = true, .render_attachment = true },
    });
    const normal_texture = core.device.createTexture(&normal_texture_desc);
    app.normal_texture_view = normal_texture.createView(null);
}

fn create_draw_pipeline(app: *App, core: *mach.Core) void {
    const vs_module = core.device.createShaderModuleWGSL("vert.wgsl", @embedFile("vert.wgsl"));
    const vertex_attributes = [_]gpu.VertexAttribute{
        .{ .format = .float32x3, .offset = @offsetOf(Vertex, "pos"), .shader_location = 0 },
        .{ .format = .float32x3, .offset = @offsetOf(Vertex, "normal"), .shader_location = 1 },
        .{ .format = .float32x2, .offset = @offsetOf(Vertex, "uv"), .shader_location = 2 },
    };
    const vertex_buffer_layout = gpu.VertexBufferLayout.init(.{
        .array_stride = @sizeOf(Vertex),
        .step_mode = .vertex,
        .attributes = &vertex_attributes,
    });
    const vertex = gpu.VertexState.init(.{
        .module = vs_module,
        .entry_point = "main",
        .buffers = &.{vertex_buffer_layout},
    });

    const fs_module = core.device.createShaderModuleWGSL("frag.wgsl", @embedFile("frag.wgsl"));
    const blend = gpu.BlendState{};
    const color_target = gpu.ColorTargetState{
        .format = core.swap_chain_format,
        .blend = &blend,
        .write_mask = gpu.ColorWriteMaskFlags.all,
    };
    const fragment = gpu.FragmentState.init(.{
        .module = fs_module,
        .entry_point = "main",
        .targets = &.{color_target},
    });

    const bgle = gpu.BindGroupLayout.Entry.buffer(0, .{ .vertex = true }, .uniform, true, 0);
    const bgl = core.device.createBindGroupLayout(
        &gpu.BindGroupLayout.Descriptor.init(.{
            .entries = &.{bgle},
        }),
    );

    const bind_group_layouts = [_]*gpu.BindGroupLayout{bgl};
    const pipeline_layout = core.device.createPipelineLayout(
        &gpu.PipelineLayout.Descriptor.init(.{
            .bind_group_layouts = &bind_group_layouts,
        }),
    );

    const vertex_buffer = core.device.createBuffer(&.{
        .usage = .{ .vertex = true },
        .size = @sizeOf(Vertex) * vertices.len,
        .mapped_at_creation = true,
    });
    var vertex_mapped = vertex_buffer.getMappedRange(Vertex, 0, vertices.len);
    std.mem.copy(Vertex, vertex_mapped.?, vertices[0..]);
    vertex_buffer.unmap();

    const uniform_buffer = core.device.createBuffer(&.{
        .usage = .{ .copy_dst = true, .uniform = true },
        .size = @sizeOf(UniformBufferObject),
        .mapped_at_creation = false,
    });
    const bind_group = core.device.createBindGroup(
        &gpu.BindGroup.Descriptor.init(.{
            .layout = bgl,
            .entries = &.{
                gpu.BindGroup.Entry.buffer(0, uniform_buffer, 0, @sizeOf(UniformBufferObject)),
            },
        }),
    );

    const pipeline_descriptor = gpu.RenderPipeline.Descriptor{
        .fragment = &fragment,
        .layout = pipeline_layout,
        .vertex = vertex,
        .primitive = .{
            .cull_mode = .back,
        },
        .depth_stencil = &gpu.DepthStencilState{
            .format = .depth32_float,
            .depth_write_enabled = true,
            .depth_compare = .less,
        },
    };

    {
        // "same" pipeline, different fragment shader to create a texture with normal information
        const normal_fs_module = core.device.createShaderModuleWGSL("normal_frag.wgsl", @embedFile("normal_frag.wgsl"));
        const normal_fragment = gpu.FragmentState.init(.{
            .module = normal_fs_module,
            .entry_point = "main",
            .targets = &.{color_target},
        });
        const normal_pipeline_descriptor = gpu.RenderPipeline.Descriptor{
            .fragment = &normal_fragment,
            .layout = pipeline_layout,
            .vertex = vertex,
            .primitive = .{
                .cull_mode = .back,
            },
        };
        app.normal_pipeline = core.device.createRenderPipeline(&normal_pipeline_descriptor);

        normal_fs_module.release();
    }

    app.pipeline = core.device.createRenderPipeline(&pipeline_descriptor);
    app.queue = core.device.getQueue();
    app.vertex_buffer = vertex_buffer;
    app.uniform_buffer = uniform_buffer;
    app.bind_group = bind_group;

    vs_module.release();
    fs_module.release();
    pipeline_layout.release();
    bgl.release();
}

fn create_post_pipeline(app: *App, core: *mach.Core) void {
    const vs_module = core.device.createShaderModuleWGSL("pixel_vert.wgsl", @embedFile("pixel_vert.wgsl"));
    const vertex_attributes = [_]gpu.VertexAttribute{
        .{ .format = .float32x3, .offset = @offsetOf(Quad, "pos"), .shader_location = 0 },
        .{ .format = .float32x2, .offset = @offsetOf(Quad, "uv"), .shader_location = 1 },
    };
    const vertex_buffer_layout = gpu.VertexBufferLayout.init(.{
        .array_stride = @sizeOf(Quad),
        .step_mode = .vertex,
        .attributes = &vertex_attributes,
    });
    const vertex = gpu.VertexState.init(.{
        .module = vs_module,
        .entry_point = "main",
        .buffers = &.{vertex_buffer_layout},
    });

    const fs_module = core.device.createShaderModuleWGSL("pixel_frag.wgsl", @embedFile("pixel_frag.wgsl"));
    const blend = gpu.BlendState{};
    const color_target = gpu.ColorTargetState{
        .format = core.swap_chain_format,
        .blend = &blend,
        .write_mask = gpu.ColorWriteMaskFlags.all,
    };
    const fragment = gpu.FragmentState.init(.{
        .module = fs_module,
        .entry_point = "main",
        .targets = &.{color_target},
    });

    const bgl = core.device.createBindGroupLayout(
        &gpu.BindGroupLayout.Descriptor.init(.{
            .entries = &.{
                gpu.BindGroupLayout.Entry.texture(0, .{ .fragment = true }, .float, .dimension_2d, false),
                gpu.BindGroupLayout.Entry.sampler(1, .{ .fragment = true }, .filtering),
                gpu.BindGroupLayout.Entry.texture(2, .{ .fragment = true }, .depth, .dimension_2d, false),
                gpu.BindGroupLayout.Entry.sampler(3, .{ .fragment = true }, .filtering),
                gpu.BindGroupLayout.Entry.texture(4, .{ .fragment = true }, .float, .dimension_2d, false),
                gpu.BindGroupLayout.Entry.sampler(5, .{ .fragment = true }, .filtering),
                gpu.BindGroupLayout.Entry.buffer(6, .{ .fragment = true }, .uniform, true, 0),
            },
        }),
    );

    const bind_group_layouts = [_]*gpu.BindGroupLayout{bgl};
    const pipeline_layout = core.device.createPipelineLayout(&gpu.PipelineLayout.Descriptor.init(.{
        .bind_group_layouts = &bind_group_layouts,
    }));

    const vertex_buffer = core.device.createBuffer(&.{
        .usage = .{ .vertex = true },
        .size = @sizeOf(Quad) * quad.len,
        .mapped_at_creation = true,
    });
    var vertex_mapped = vertex_buffer.getMappedRange(Quad, 0, quad.len);
    std.mem.copy(Quad, vertex_mapped.?, quad[0..]);
    vertex_buffer.unmap();

    const draw_sampler = core.device.createSampler(null);
    const depth_sampler = core.device.createSampler(null);
    const normal_sampler = core.device.createSampler(null);
    const uniform_buffer = core.device.createBuffer(&.{
        .usage = .{ .copy_dst = true, .uniform = true },
        .size = @sizeOf(PostUniformBufferObject),
        .mapped_at_creation = false,
    });
    const bind_group = core.device.createBindGroup(
        &gpu.BindGroup.Descriptor.init(.{
            .layout = bgl,
            .entries = &[_]gpu.BindGroup.Entry{
                gpu.BindGroup.Entry.textureView(0, app.draw_texture_view),
                gpu.BindGroup.Entry.sampler(1, draw_sampler),
                gpu.BindGroup.Entry.textureView(2, app.depth_texture_view),
                gpu.BindGroup.Entry.sampler(3, depth_sampler),
                gpu.BindGroup.Entry.textureView(4, app.normal_texture_view),
                gpu.BindGroup.Entry.sampler(5, normal_sampler),
                gpu.BindGroup.Entry.buffer(6, uniform_buffer, 0, @sizeOf(PostUniformBufferObject)),
            },
        }),
    );

    const pipeline_descriptor = gpu.RenderPipeline.Descriptor{
        .fragment = &fragment,
        .layout = pipeline_layout,
        .vertex = vertex,
        .primitive = .{
            .cull_mode = .back,
        },
    };

    app.post_pipeline = core.device.createRenderPipeline(&pipeline_descriptor);
    app.post_vertex_buffer = vertex_buffer;
    app.post_uniform_buffer = uniform_buffer;
    app.post_bind_group = bind_group;

    vs_module.release();
    fs_module.release();
    pipeline_layout.release();
    bgl.release();
}