#include "renderer.hpp"
#include <cstddef>
#include <memory>
#include <array>
#include <tuple>
#include "math/vector.hpp"
#include "o3d/tri.hpp"
#include "o3d/tri_deriv.hpp"
#include "o3d/polygon.hpp"
#include "fb/chfb.hpp"
#include "fb/pixfb.hpp"

using namespace engine;
using
    engine::math::Vector2,
    engine::math::Vector3,
    engine::math::Vector4,
    engine::o3d::Triangle,
    engine::o3d::TriangleDerived,
    engine::o3d::VertexData,
    engine::o3d::DerivedVertex,
    engine::fb::CharacterFrameBuffer,
    engine::fb::PixelFrameBuffer;

template<typename FrameBuffer>
Renderer<FrameBuffer>::Renderer(FrameBuffer&& fb) : fb { std::forward<FrameBuffer>(fb) } {
    depth_buf.resize(this->fb.width() * this->fb.height());
}

template<typename FrameBuffer>
void Renderer<FrameBuffer>::resize(unsigned int w, unsigned int h) {
    fb.resize(w, h);
    depth_buf.resize(fb.width() * fb.height());
}

template<typename FrameBuffer>
void Renderer<FrameBuffer>::clear() {
    std::fill(depth_buf.begin(), depth_buf.end(), 1.f);
    fb.clear();
}

enum class TriangleSide { top, bottom };

template<typename FrameBuffer>
void Renderer<FrameBuffer>::draw_triangle(const Triangle& triangle) {
    const auto& polygon = engine::o3d::polygon::div_by_w(engine::o3d::polygon::from_triangle_derived(triangle.to_derived()).clip_z(0.f, 1.f));
    if (engine::o3d::polygon::signed_area_xy(polygon) >= 0) return;
    const auto& [final_triangles_count, final_triangles]
        = polygon.clip_xy(-1.f, -1.f, 1.f, 1.f)
                 .map_xy({ -1.f, -1.f }, { 1.f, 1.f }, { -.5f, -.5f }, { static_cast<float>(fb.width()) - .5f, static_cast<float>(fb.height()) - .5f })
                 .to_triangles();
    for (std::size_t i = 0; i < final_triangles_count; i++)
        _draw_cropped_triangle(triangle, final_triangles[i]);
}

// TODO: the renaming of w to z or the inverse is very confusing. The reason why it happens is
// because we use Vector3 to store x, y and w, which therefore gets renamed to w. We should find
// another way of doing this
template<typename FrameBuffer>
void Renderer<FrameBuffer>::_draw_cropped_triangle(const Triangle& root, const TriangleDerived<Vector3>& triangle) {
    std::array<const DerivedVertex<Vector3>*, 3> sorted_vs = { &triangle.derived_vertex1, &triangle.derived_vertex2, &triangle.derived_vertex3 };

    {
        const auto swap_if_gt = [&](auto x, auto y) {
            if (sorted_vs[x]->vertex.y > sorted_vs[y]->vertex.y) {
                auto temp = sorted_vs[x];
                sorted_vs[x] = sorted_vs[y];
                sorted_vs[y] = temp;
            }
        };

        swap_if_gt(0, 1);
        swap_if_gt(1, 2);
        swap_if_gt(0, 1);
    }

    auto middle_vl = *sorted_vs[1];
    const float fac = (sorted_vs[1]->vertex.y - sorted_vs[0]->vertex.y) / (sorted_vs[2]->vertex.y - sorted_vs[0]->vertex.y);
    const float middle_vr_vertex_w = 1.f / (1.f / sorted_vs[0]->vertex.z + fac * (1.f / sorted_vs[2]->vertex.z - 1.f / sorted_vs[0]->vertex.z));
    const float fac_b0 = middle_vr_vertex_w * (1.f - fac) / sorted_vs[0]->vertex.z;
    DerivedVertex<Vector3> middle_vr {
        {
            sorted_vs[0]->vertex.x + fac * (sorted_vs[2]->vertex.x - sorted_vs[0]->vertex.x),
            sorted_vs[1]->vertex.y,
            middle_vr_vertex_w
        },
        fac_b0 * sorted_vs[0]->b0 + (1.f - fac_b0) * sorted_vs[2]->b0,
        fac_b0 * sorted_vs[0]->b1 + (1.f - fac_b0) * sorted_vs[2]->b1
    };
    if (middle_vr.vertex.x < middle_vl.vertex.x) {
        auto temp = middle_vr;
        middle_vr = middle_vl;
        middle_vl = temp;
    }

    const auto _draw_cropped_triangle_side = [&]<TriangleSide side>() {
        const int vertex_end_index = ([&]() { if constexpr (side == TriangleSide::top) return 0; else return 2; })();
        const DerivedVertex<Vector3>& vertex_end = *sorted_vs[vertex_end_index];
        if (vertex_end.vertex.y == sorted_vs[1]->vertex.y)
            return;
        int top_y;
        int bottom_y;
        if constexpr (side == TriangleSide::top) {
            top_y = static_cast<int>(std::floor(vertex_end.vertex.y + 1.f));
            bottom_y = static_cast<int>(std::ceil(sorted_vs[1]->vertex.y - 1.f));
        } else {
            bottom_y = static_cast<int>(std::floor(vertex_end.vertex.y));
            top_y = static_cast<int>(std::ceil(sorted_vs[1]->vertex.y));
        }
        for (int y = top_y; y <= bottom_y; y++) {
            float s = (static_cast<float>(y) - vertex_end.vertex.y)
                / (sorted_vs[1]->vertex.y - vertex_end.vertex.y);
            float projected_relative_b0 = 1.f - s;
            float xl = vertex_end.vertex.x + s * (middle_vl.vertex.x - vertex_end.vertex.x);
            float xr = vertex_end.vertex.x + s * (middle_vr.vertex.x - vertex_end.vertex.x);
            int left_x = static_cast<int>(std::ceil(xl));
            int right_x = static_cast<int>(std::ceil(xr - 1.f));
            for (int x = left_x; x <= right_x; x++) {
                float t = (static_cast<float>(x) - xl)
                    / (xr - xl);
                float projected_relative_b1 = s * (1.f - t);
                float point_w = 1.f /
                    (
                        projected_relative_b0 / vertex_end.vertex.z
                        + projected_relative_b1 / middle_vl.vertex.z
                        + (1.f - projected_relative_b0 - projected_relative_b1) / middle_vr.vertex.z
                    );
                float relative_b0 = point_w * projected_relative_b0 / vertex_end.vertex.z;
                float relative_b1 = point_w * projected_relative_b1 / middle_vl.vertex.z;

                float b0 = relative_b0 * vertex_end.b0 + relative_b1 * middle_vl.b0 + (1.f - relative_b0 - relative_b1) * middle_vr.b0;
                float b1 = relative_b0 * vertex_end.b1 + relative_b1 * middle_vl.b1 + (1.f - relative_b0 - relative_b1) * middle_vr.b1;

                auto loc = Vector3::bilerp(root.vertex1.vertex.xyz(), root.vertex2.vertex.xyz(), root.vertex3.vertex.xyz(), b0, b1);
                loc.z /= point_w;

                if (loc.z >= depth_buf[x + y * fb.width()]) continue;

                depth_buf[x + y * fb.width()] = loc.z;

                fb.draw_point(x, y, loc,
                    Vector3   ::bilerp(root.vertex1.normal, root.vertex2.normal, root.vertex3.normal, b0, b1),
                    Vector2   ::bilerp(root.vertex1.uv,     root.vertex2.uv,     root.vertex3.uv,     b0, b1),
                    VertexData::bilerp(root.vertex1.data,   root.vertex2.data,   root.vertex3.data,   b0, b1));
            }
        }
    };
    _draw_cropped_triangle_side.template operator()<TriangleSide::top>();
    _draw_cropped_triangle_side.template operator()<TriangleSide::bottom>();
}

template class Renderer<CharacterFrameBuffer>;
template class Renderer<PixelFrameBuffer>;

<a id='n126' href='#n126'>126</a>
<a id='n127' href='#n127'>127</a>
<a id='n128' href='#n128'>128</a>
<a id='n129' href='#n129'>129</a>
<a id='n130' href='#n130'>130</a>
<a id='n131' href='#n131'>131</a>
<a id='n132' href='#n132'>132</a>
<a id='n133' href='#n133'>133</a>
<a id='n134' href='#n134'>134</a>
<a id='n135' href='#n135'>135</a>
<a id='n136' href='#n136'>136</a>
<a id='n137' href='#n137'>137</a>
<a id='n138' href='#n138'>138</a>
<a id='n139' href='#n139'>139</a>
<a id='n140' href='#n140'>140</a>
<a id='n141' href='#n141'>141</a>
<a id='n142' href='#n142'>142</a>
<a id='n143' href='#n143'>143</a>
</pre></td>
<td class='lines'><pre><code>