// This file is part of ZiRC
//
// Copyright (C) 2021, tslil clingman
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.

const std = @import("std");

const RenderWindow = @import("sfml").graphics.RenderWindow;
const Sprite = @import("sfml").graphics.Sprite;
const Texture = @import("sfml").graphics.Texture;
const Image = @import("sfml").graphics.Image;
const Colour = @import("sfml").graphics.Color;

const level = @import("level.zig");
const constants = @import("constants.zig");

fn playerDistComp(pos: [2]f32, lhs: level.Object, rhs: level.Object) bool {
    const lx = lhs.pos_x - pos[0];
    const ly = lhs.pos_y - pos[1];
    const rx = rhs.pos_x - pos[0];
    const ry = rhs.pos_y - pos[1];

    return (lx * lx + ly * ly > rx * rx + ry * ry);
}

fn fasterColourBlend(onto: Colour, from: Colour) Colour {
    const af: u16 = from.a;
    const of: u16 = onto.a;

    const na: u16 = af + @divTrunc(of * (255 - af), 255);
    if (na == 0) return Colour.Black;

    const rf: i32 = from.r;
    const ro: i32 = onto.r;
    const gf: i32 = from.g;
    const go: i32 = onto.g;
    const bf: i32 = from.b;
    const bo: i32 = onto.b;

    // The most accurate i've found is
    const nr = @divTrunc(ro * na + (rf - ro) * af, na);
    const ng = @divTrunc(go * na + (gf - go) * af, na);
    const nb = @divTrunc(bo * na + (bf - bo) * af, na);

    // Note: there are other versions which don't require using intermediate
    // i32 division, and instead work on plain u16.

    // These computations are more expensive and less accurate
    // const nr = @divTrunc(af * rf, na) + ro - @divTrunc(af * ro, na);
    // const ng = @divTrunc(af * gf, na) + go - @divTrunc(af * go, na);
    // const nb = @divTrunc(af * bf, na) + bo - @divTrunc(af * bo, na);

    // These computations are incorrect, but fast
    // const nr = (af * rf + (255 - af) * ro) / 255;
    // const ng = (af * gf + (255 - af) * go) / 255;
    // const nb = (af * bf + (255 - af) * bo) / 255;

    return Colour{
        .a = @intCast(u8, na),
        .r = @intCast(u8, nr),
        .g = @intCast(u8, ng),
        .b = @intCast(u8, nb),
    };
}

pub fn Player(PlaneWidth: f32, PlaneHeight: f32) type {
    const FOV: f32 = std.math.pi / 3.0;
    const PlanePixels = PlaneWidth * PlaneHeight;
    // given the desired width of the image, how far away must
    // the projection plane be from the camera?
    const FOV_SCALE = 2 * std.math.tan(FOV / 2);
    const PlaneDist = PlaneWidth / FOV_SCALE;

    return struct {
        pos_x: f32,
        pos_y: f32,
        ang: f32,
        vel_x: f32 = 0,
        vel_y: f32 = 0,
        acc_x: f32 = 0,
        acc_y: f32 = 0,
        height: f32 = 2.0 * (1.8 / 2.5), // TODO
        z_buffer: std.BoundedArray(f32, PlanePixels),

        anim_step: f32 = 0,

        // standing still at the given location, looking in direction ang
        pub fn new(pos_x: f32, pos_y: f32, ang: f32) !@This() {
            const infs = [_]f32{std.math.inf(f32)} ** PlanePixels;
            return Player(PlaneWidth, PlaneHeight){
                .pos_x = pos_x,
                .pos_y = pos_y,
                .ang = ang,
                // TODO: is there some clever way to avoid this long name?
                .z_buffer = try std.BoundedArray(f32, PlanePixels).fromSlice(&infs),
            };
        }

        pub fn tick(self: *@This(), map: level.Map) void {
            const dt = 1 / 30.0;
            const v_min = 0.8;
            const v_decay = 1 / 1.25;

            var next_x = self.pos_x + self.vel_x * dt;
            var next_y = self.pos_y + self.vel_y * dt;

            // Collision detection
            const min_dist: f32 = 0.1;
            const fx = std.math.floor(self.pos_x);
            const fy = std.math.floor(self.pos_y);
            const ix = @floatToInt(i32, fx);
            const iy = @floatToInt(i32, fy);
            const nix = @floatToInt(i32, std.math.floor(next_x + if (self.vel_x > 0) min_dist else -min_dist));
            const niy = @floatToInt(i32, std.math.floor(next_y + if (self.vel_y > 0) min_dist else -min_dist));

            if (!map.inBounds(nix, iy) or map.lookup(nix, iy).height > 0) {
                next_x = fx + if (self.vel_x > 0) 1 - min_dist else min_dist;
                self.vel_x = 0;
                self.acc_x = 0;
            }

            if (!map.inBounds(ix, niy) or map.lookup(ix, niy).height > 0) {
                next_y = fy + if (self.vel_y > 0) 1 - min_dist else min_dist;
                self.vel_y = 0;
                self.acc_y = 0;
            }

            // Update position
            self.pos_x = next_x;
            self.pos_y = next_y;

            // Update velocity
            self.vel_x += self.acc_x * dt;
            self.vel_y += self.acc_y * dt;

            const vd = v_decay * std.math.sqrt(self.vel_x * self.vel_x + self.vel_y * self.vel_y);
            if (vd < v_min) {
                self.vel_x = 0;
                self.vel_y = 0;
            } else {
                // If we're moving update our animation state
                self.anim_step += 1;
                self.height -= std.math.sin(self.anim_step / 10 * std.math.pi) * 0.015;

                self.vel_x *= v_decay;
                self.vel_y *= v_decay;
            }
        }

        pub fn renderWorld(
            self: *@This(),
            window: RenderWindow,
            objects_image: Image,
            walls_image: Image,
            surfaces_image: Image,
            rendered_surfaces_texture: Texture,
            rendered_surfaces_sprite: Sprite,
            map: level.Map,
        ) !void {
            // Fist reset the z_buffer
            var i: usize = 0;
            while (i < self.z_buffer.len) : (i += 1) {
                self.z_buffer.set(i, std.math.inf(f32));
            }

            var pixels = [_]Colour{Colour.Transparent} ** (PlaneWidth * PlaneHeight);

            // then draw all the walls and populate the z_buffer, while also
            // rendering the surfaces below the horizon to the pixel array
            self.renderCells(walls_image, surfaces_image, map, &pixels);

            // then render the ceilings to our pixel array
            self.renderCeilingsToTexture(surfaces_image, map, &pixels);

            // use the z_buffer to render sprites
            self.renderObjects(objects_image, map, &pixels);

            try rendered_surfaces_texture.updateFromPixels(&pixels, null);
            window.draw(rendered_surfaces_sprite, null);
        }

        fn renderObjects(
            self: @This(),
            objects_image: Image,
            map: level.Map,
            pixels: []Colour,
        ) void {
            std.sort.sort(level.Object, map.objects.items,
            // Wow, context with an arbitrary type! No macros, just
            // Zig all the way down!
            [2]f32{ self.pos_x, self.pos_y }, playerDistComp);

            const self_cos = std.math.cos(self.ang);
            const self_sin = std.math.sin(self.ang);

            for (map.objects.items) |obj| {
                const ox = obj.pos_x - self.pos_x;
                const oy = obj.pos_y - self.pos_y;

                // We compute the two coordinates of rotating by -self.ang, the
                // first of which gives the perpendicular distance to the plane
                // of projection, and the second of which gives the
                // (unprojected) centre of the object.
                const perp_distance = self_cos * ox + self_sin * oy;
                const centre = self_sin * ox - self_cos * oy;

                // NOTE: in the below we have applied the magic scaling factor
                // of FOV_SCALE. I don't understand how this compensates for the
                // linear interpolation incorrectness we do elsewhere, but
                // somehow it scales the *correct* values we compute above into
                // whatever agrees with the wall and floor rendering voodoo.

                // This quantity is independent of FOV_SCALE because it enters
                // both via centre and perp_distance
                const proj_centre = PlaneWidth / 2 + PlaneDist * centre / perp_distance;

                // Here's the magic adjustment
                const scaled_perp_distance = FOV_SCALE * perp_distance;
                const width = PlaneDist * obj.width / scaled_perp_distance;
                const left = proj_centre - width / 2;

                // TODO: prune before this?
                if (left + width < 0 or left >= PlaneWidth) continue;

                const height = PlaneDist * obj.height / scaled_perp_distance;
                const top = PlaneHeight / 2 + PlaneDist * (obj.height - self.height + obj.pos_z) / scaled_perp_distance;

                // TODO: likewise?
                if (top < 0 or top - height >= PlaneHeight) continue;

                // Something is on the screen, let's draw it!
                const start = std.math.max(0, left);
                const end = @floatToInt(usize, std.math.min(left + width, PlaneWidth - 1));

                const inv_height = 1 / height;

                var tex_frac: f32 = std.math.clamp((start - left) / width, 0, 1);
                var col: usize = @floatToInt(usize, start);
                const tex_frac_step = 1 / width;
                while (col < end) : ({
                    col += 1;
                    tex_frac += tex_frac_step;
                }) {
                    var bottom = std.math.min(top, PlaneHeight);
                    var pix_y = @floatToInt(usize, std.math.ceil(std.math.max(PlaneHeight - bottom, 0)));
                    var texel_y = (top - bottom) / height;
                    while (pix_y < PlaneHeight and bottom >= top - height) : ({
                        bottom -= 1;
                        pix_y += 1;
                        texel_y += inv_height;
                    }) {
                        const index = col * @floatToInt(usize, PlaneHeight) + @floatToInt(usize, bottom);
                        if (self.z_buffer.get(index) < scaled_perp_distance) {
                            break;
                        } else {
                            const tx = @floatToInt(c_uint, tex_frac * constants.TextureDim);
                            const toff = obj.texture * @floatToInt(c_uint, constants.TextureDim);
                            const ty = @floatToInt(c_uint, texel_y * constants.TextureDim);
                            const texel = objects_image.getPixel(.{ .x = toff + tx, .y = ty });
                            const pix_index = @floatToInt(usize, PlaneWidth) * pix_y + col;
                            // TODO: Decide whether being accurate is as important as being fast
                            pixels[pix_index] = fasterColourBlend(pixels[pix_index], texel);
                        }
                    }
                }
            }
        }

        fn renderCells(
            self: *@This(),
            walls_image: Image,
            surfaces_image: Image,
            map: level.Map,
            pixels: []Colour,
        ) void {
            // This is a TERRIBLE hack: for whatever reason *linearly*
            // interpolating on the direction vectors gives
            // perspective-correct-seeming walls!
            const cos_first = std.math.cos(self.ang + 0.5 * FOV);
            const cos_last = std.math.cos(self.ang - 0.5 * FOV);
            const sin_first = std.math.sin(self.ang + 0.5 * FOV);
            const sin_last = std.math.sin(self.ang - 0.5 * FOV);

            const cos_step = (cos_last - cos_first) / PlaneWidth;
            const sin_step = (sin_last - sin_first) / PlaneWidth;

            var col: u16 = 0;
            var cosra = cos_first;
            var sinra = sin_first;
            while (col < PlaneWidth) : ({
                col += 1;
                cosra += cos_step;
                sinra += sin_step;
            }) {
                // Observe that sqrt(1+tan^2) = abs(1/cos) sqrt(cos^2+sin^2) =
                // abs(1/cos). Similarly so for cot, hence we obtain the
                // following lengths for the hypotenuses assuming that x
                // (respectively y) are unit length and the angle is ra. This
                // for whatever reasons still works when we linearly interpolate
                // on cos and sin!
                const dy_for_x_step = std.math.fabs(1 / cosra);
                const dx_for_y_step = std.math.fabs(1 / sinra);

                var step_x: i32 = -1;
                var step_y: i32 = -1;

                var dist_x: f32 = undefined;
                var dist_y: f32 = undefined;

                var ipos_x: i32 = @floatToInt(i32, std.math.floor(self.pos_x));
                var ipos_y: i32 = @floatToInt(i32, std.math.floor(self.pos_y));

                // looking right
                if (cosra >= 0) {
                    step_x = 1;
                    // assuming unit size grid cells
                    dist_y = (@intToFloat(f32, ipos_x) + 1 - self.pos_x) * dy_for_x_step;
                } else {
                    dist_y = (self.pos_x - @intToFloat(f32, ipos_x)) * dy_for_x_step;
                }

                if (sinra >= 0) {
                    step_y = 1;
                    dist_x = (@intToFloat(f32, ipos_y) + 1 - self.pos_y) * dx_for_y_step;
                } else {
                    dist_x = (self.pos_y - @intToFloat(f32, ipos_y)) * dx_for_y_step;
                }

                var top: f32 = undefined;
                var distance: f32 = 0;
                var still_drawing = true;
                var highest_point: f32 = 0;
                var horizontal_hit: bool = undefined;
                while (still_drawing and map.inBounds(ipos_x, ipos_y)) : ({
                    // Find the next cell on our path
                    if (dist_y < dist_x) {
                        horizontal_hit = false;
                        distance = dist_y;
                        dist_y += dy_for_x_step;
                        ipos_x += step_x;
                    } else {
                        horizontal_hit = true;
                        distance = dist_x;
                        dist_x += dx_for_y_step;
                        ipos_y += step_y;
                    }
                }) {
                    const cell = map.lookup(ipos_x, ipos_y);

                    // Is there a wall?
                    if (cell.height > 0) {
                        // project the top of the wall
                        top = PlaneHeight / 2 + PlaneDist * (cell.height - self.height) / distance;

                        // Does the wall extend above what we've draw?
                        if (top > highest_point) {

                            // If we reach the top we have to stop!
                            if (top > PlaneHeight) {
                                still_drawing = false;
                            }

                            // we need the distance to calculate the fractional
                            // part of the relevant coordinate for texture
                            // mapping of the walls
                            const hit_coordinate = if (horizontal_hit) distance * cosra + self.pos_x else distance * sinra + self.pos_y;
                            var texfrac = std.math.modf(hit_coordinate).fpart;

                            // we also want to be sure that we're consistently orienting
                            // textures, in this case clockwise
                            if ((horizontal_hit and sinra < 0) or (!horizontal_hit and cosra > 0)) texfrac = 1 - texfrac;
                            if (texfrac == 1) texfrac = 0.9999; // i think this caused a crash at one point
                            const texstrip = @floatToInt(c_uint, constants.TextureDim * texfrac);

                            // which texture index?
                            const toff = cell.wall_texture * @floatToInt(c_uint, constants.TextureDim);

                            // height of a unit-height wall at this distance
                            const nominal_length = PlaneDist / distance;
                            const inv_nom_len = distance / PlaneDist;

                            // now we have what we need to draw the wall, and
                            // update the z-buffer
                            const constrained_top = std.math.min(top, PlaneHeight - 1);
                            var zb_y = @floatToInt(i32, constrained_top);
                            var pix_y = @floatToInt(usize, std.math.ceil(std.math.max(PlaneHeight - top, 0)));
                            var texel_y = (top - constrained_top) / nominal_length;
                            while (zb_y > @floatToInt(i32, highest_point)) : ({
                                zb_y -= 1;
                                pix_y += 1;
                                texel_y += inv_nom_len;
                            }) {
                                const ty = @floatToInt(c_uint, std.math.modf(texel_y).fpart * constants.TextureDim);
                                const texel = walls_image.getPixel(.{ .x = toff + texstrip, .y = ty });

                                const pix_index = pix_y * @floatToInt(usize, PlaneWidth) + col;
                                pixels[pix_index] = texel;

                                const index = @intCast(usize, col * @floatToInt(i32, PlaneHeight) + zb_y);
                                self.z_buffer.set(index, distance);
                            }
                            highest_point = top;
                        }
                    }

                    // do we potentially draw the top of this cell?
                    if (highest_point < PlaneHeight / 2) {
                        if (dist_y < dist_x) {
                            distance = dist_y;
                        } else {
                            distance = dist_x;
                        }

                        // Note: next_top can never exceed PlaneHeight / 2
                        // in the body of the next block. If the wall is
                        // taller than us the back edge is lower than the
                        // front one so this check will fail as we just drew
                        // it (or higher than it). If the wall is shorter
                        // then the back edge is at most the horizon.
                        const next_top = PlaneHeight / 2 + PlaneDist * (cell.height - self.height) / distance;

                        // only if we can see some part of it
                        if (next_top > highest_point) {
                            top = highest_point;
                            while (top <= next_top and top < PlaneHeight / 2) : (top += 1) {
                                const row_dist = (self.height - cell.height) * PlaneDist / (PlaneHeight / 2 - top);
                                const ptop = @floatToInt(usize, top + 1);
                                const itop = @floatToInt(usize, PlaneHeight) - ptop;

                                // draw the correct pixel
                                const sx = std.math.modf(self.pos_x + row_dist * cosra);
                                const sy = std.math.modf(self.pos_y + row_dist * sinra);
                                const toff = cell.floor_texture * @floatToInt(c_uint, constants.TextureDim);
                                const px = @floatToInt(c_uint, constants.TextureDim * std.math.fabs(sx.fpart));
                                const py = @floatToInt(c_uint, constants.TextureDim * std.math.fabs(sy.fpart));
                                const val = surfaces_image.getPixel(.{ .x = toff + px, .y = py });
                                pixels[itop * @floatToInt(usize, PlaneWidth) + col] = val;

                                // record in the z_buffer only if we're above the floor!
                                if (cell.height > 0) {
                                    const index = col * @floatToInt(usize, PlaneHeight) + ptop;
                                    self.z_buffer.set(index, row_dist);
                                }
                            }
                            highest_point = next_top;
                        }
                    }
                }
            }
        }

        fn renderCeilingsToTexture(
            self: @This(),
            surfaces_image: Image,
            map: level.Map,
            pixels: []Colour,
        ) void {
            // Again, another TERRIBLE hack: we do the same nasty linear
            // interpolation trick and for whatever reason the floors look fine.
            const cos_first = std.math.cos(self.ang + 0.5 * FOV);
            const sin_first = std.math.sin(self.ang + 0.5 * FOV);
            const cos_last = std.math.cos(self.ang - 0.5 * FOV);
            const sin_last = std.math.sin(self.ang - 0.5 * FOV);

            var row: usize = 0;
            while (row < PlaneHeight / 2) : (row += 1) {
                const frow = (PlaneHeight / 2 - @intToFloat(f32, row));
                const row_dist = (constants.MAX_HEIGHT - self.height) * PlaneDist / frow;

                const dx_step = row_dist * (cos_last - cos_first) / PlaneWidth;
                const dy_step = row_dist * (sin_last - sin_first) / PlaneWidth;

                var col: usize = 0;
                var dx = row_dist * cos_first;
                var dy = row_dist * sin_first;

                while (col < PlaneWidth) : ({
                    col += 1;
                    dx += dx_step;
                    dy += dy_step;
                }) {
                    const x = self.pos_x + dx;
                    const y = self.pos_y + dy;

                    const sx = std.math.modf(x);
                    const sy = std.math.modf(y);

                    const ix = @floatToInt(i32, sx.ipart);
                    const iy = @floatToInt(i32, sy.ipart);

                    const index = col * @floatToInt(usize, PlaneHeight) + @floatToInt(usize, PlaneHeight - 1) - row;
                    if (map.inBounds(ix, iy) and row_dist < self.z_buffer.get(index)) {
                        const cell = map.lookup(ix, iy);
                        const toff = cell.ceiling_texture * @floatToInt(c_uint, constants.TextureDim);
                        const px = @floatToInt(c_uint, constants.TextureDim * std.math.fabs(sx.fpart));
                        const py = @floatToInt(c_uint, constants.TextureDim * std.math.fabs(sy.fpart));

                        const val = surfaces_image.getPixel(.{ .x = toff + px, .y = py });

                        pixels[row * @floatToInt(usize, PlaneWidth) + col] = val;
                    }
                }
            }
        }
    };
}