#pragma once
#include "rtt.h"
#include "shader.h"

NS_START

class Brush
{
public:
    int id;
    std::string m_name;
    uint16_t m_tex_id;
    glm::vec4 m_tip_color;
    float m_tip_size;
    float m_tip_spacing;
    float m_tip_flow;
    float m_tip_angle;
    float m_jitter_scale;
    float m_jitter_angle;
    float m_jitter_spread;
    float m_jitter_flow;
};

struct StrokeSample
{
    glm::vec2 pos;
    float size;
    float flow;
    float angle;
};

class BrushMesh
{
public:
    ui::Shader shader;
    GLuint buffers[3]{ 0 };
    struct vertex_t { glm::vec4 pos; glm::vec2 uvs; };
    struct instance_t { glm::mat4 mvp; float flow; };
    int loc_flow;
    int loc_mvp;
    
    bool create()
    {
        static GLushort idx[6] { 0, 1, 2, 0, 2, 3 };
        static vertex_t vertices[4]{
            { { -.5f, -.5f, 0, 1 }, { 0, 0 } }, // A       B----C
            { { -.5f,  .5f, 0, 1 }, { 0, 1 } }, // B  --\  |    |
            { {  .5f,  .5f, 0, 1 }, { 1, 1 } }, // C  --/  |    |
            { {  .5f, -.5f, 0, 1 }, { 1, 0 } }, // D       A----D
        };
        glGenBuffers(3, buffers);
        if (!buffers)
            return false;

        static instance_t inst{ glm::mat4(), .1f };
        glBindBuffer(GL_ARRAY_BUFFER, buffers[2]);
        glBufferData(GL_ARRAY_BUFFER, sizeof(instance_t), &inst, GL_STATIC_DRAW);

        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffers[1]);
        glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(idx), idx, GL_STATIC_DRAW);
        glBindBuffer(GL_ARRAY_BUFFER, buffers[0]);
        glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
        glBindBuffer(GL_ARRAY_BUFFER, 0);

        // STROKE - INSTANCED
        static const char* shader_stroke_inst_v =
            SHADER_VERSION
            "in vec4 pos;"
            "in vec2 uvs;"
            "in mat4 a_mvp;"
            "in float a_flow;"
            "out vec3 uv;"
            "out float alpha;"
            "void main(){"
            "   uv = vec3(uvs, pos.w);"
            "   alpha = a_flow;"
            "   gl_Position = a_mvp * vec4(pos.xyz, 1.0);"
            "}";
        static const char* shader_stroke_inst_f =
            SHADER_VERSION
            "uniform sampler2D tex;"
            "uniform vec4 col;"
            "in float alpha;"
            "in vec3 uv;"
            "out vec4 frag;"
            "void main(){"
            "   float a = (1.0 - texture(tex, uv.xy).r) * alpha;"
            "   frag = vec4(col.rgb, a);"
            "}";


        if (!shader.create(shader_stroke_inst_v, shader_stroke_inst_f))
            LOG("Failed to create shader Texture");

        loc_flow = shader.GetAttribLocation("a_flow");
        loc_mvp = shader.GetAttribLocation("a_mvp");
        
        return true;
    }
    void draw(const std::vector<StrokeSample>& samples, const glm::mat4& proj)
    {
         std::vector<instance_t> attributes;
         attributes.reserve(samples.size());
         for (const auto& s : samples)
         {
             auto mvp = proj *
                 glm::translate(glm::vec3(s.pos, 0)) *
                 glm::scale(glm::vec3(s.size, s.size, 1)) *
                 glm::eulerAngleZ(s.angle);
             attributes.emplace_back(instance_t{ mvp, s.flow });
         }
        glEnableVertexAttribArray(0);
        glEnableVertexAttribArray(1);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffers[1]);
        glBindBuffer(GL_ARRAY_BUFFER, buffers[0]);
        glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, sizeof(vertex_t), (GLvoid*)offsetof(vertex_t, pos));
        glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(vertex_t), (GLvoid*)offsetof(vertex_t, uvs));

        // Likewise, we can do the same with the model matrix. Note that a
        // matrix input to the vertex shader consumes N consecutive input
        // locations, where N is the number of columns in the matrix. So...
        // we have four vertex attributes to set up.
        glBindBuffer(GL_ARRAY_BUFFER, buffers[2]);
        glBufferData(GL_ARRAY_BUFFER, (int)(sizeof(instance_t) * attributes.size()), attributes.data(), GL_STATIC_DRAW);
        // Loop over each column of the matrix...
         for (int i = 0; i < 4; i++)
         {
             // Set up the vertex attribute
             glVertexAttribPointer(loc_mvp + i, 4, GL_FLOAT, GL_FALSE, sizeof(instance_t), 
                 (GLvoid*)(offsetof(instance_t, mvp) + sizeof(glm::vec4) * i));
             // Enable it
             glEnableVertexAttribArray(loc_mvp + i);
             // Make it instanced
             glVertexAttribDivisor(loc_mvp + i, 1);
         }
        glEnableVertexAttribArray(loc_flow);
        glVertexAttribPointer(loc_flow, 1, GL_FLOAT, GL_FALSE, sizeof(instance_t), 
            (GLvoid*)offsetof(instance_t, flow));
        glVertexAttribDivisor(loc_flow, 1);

        glDrawElementsInstanced(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0, (int)samples.size());
        //glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0);

        glDisableVertexAttribArray(0);
        glDisableVertexAttribArray(1);
        for (int i = 0; i < 4; i++)
            glDisableVertexAttribArray(loc_mvp + i);
        glDisableVertexAttribArray(loc_flow);

        glBindBuffer(GL_ARRAY_BUFFER, 0);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
    }
};

class Stroke
{
public:
    struct Keypoint
    {
        glm::vec2 pos;
        float pressure;
        float dist;
    };
    int m_layer;
    float m_dist;
    float m_step;
    ui::Brush m_brush;
    std::vector<Keypoint> m_keypoints;
    std::vector<StrokeSample> m_samples;
    int m_last_kp;
    std::minstd_rand prng;
    void start(glm::vec2 pos, float pressure, const ui::Brush& brush)
    {
        m_last_kp = 0;
        m_dist = 0.f;
        m_step = glm::max(brush.m_tip_spacing * brush.m_tip_size * 30, 0.1f);
        m_brush = brush;
        add_point(pos, pressure);
    }
    void add_point(glm::vec2 pos, float pressure)
    {
        float dist = m_keypoints.empty() ? 0.f : 
            m_keypoints.back().dist + glm::distance(m_keypoints.back().pos, pos);
        m_keypoints.emplace_back();
        m_keypoints.back().pos = pos;
        m_keypoints.back().pressure = pressure;
        m_keypoints.back().dist = dist;
    }
    bool has_sample()
    {
        return m_keypoints.empty() ? false :                // no keypoints
            (m_keypoints.back().dist > (m_dist + m_step));  // check if next kp is closer than spacing
    }
    std::vector<StrokeSample> compute_samples()
    {
        int nsamples = (int)glm::floor((m_keypoints.back().dist - m_dist) / m_step);
        std::vector<StrokeSample> samples;
        samples.reserve(nsamples); // preallocate the estimate number of samples
        while (m_keypoints.back().dist > (m_dist + m_step))
        {
            m_dist += m_step;
            while (m_dist > m_keypoints[m_last_kp + 1].dist)
                m_last_kp++;
            const auto& A = m_keypoints[m_last_kp];
            const auto& B = m_keypoints[m_last_kp + 1]; // NOTE: this should be true when while is true
            float t = (m_dist - A.dist) / (B.dist - A.dist); // NOTE: must be A != B
            auto pos = glm::lerp(A.pos, B.pos, t);
            float pressure = glm::lerp(A.pressure, B.pressure, t);
            auto s = randomize_sample(pos, pressure);
            samples.push_back(s);
        }
        return std::move(samples);
    }
    StrokeSample randomize_sample(const glm::vec2& pos, float pressure)
    {
        auto rnd_nor = [&] { return float((double)prng() / (double)prng.max()); };              // normalized [0, +1]
        auto rnd_neg = [&] { return float((double)prng() / (double)prng.max() * 2.0 - 1.0); };  // normalized [-1, +1]
        auto rnd_rad = [&] { return float((double)prng() / (double)prng.max() * M_PI * 2.0); }; // normalized [0, 2pi]
        auto rnd_vec = [&] { float rad = rnd_rad(); return glm::vec2(cosf(rad), sinf(rad)); };  // normalized direction vector

        StrokeSample s;
        s.angle = (m_brush.m_tip_angle + rnd_nor() * m_brush.m_jitter_angle) * (float)(M_PI * 2.0);
        s.pos = pos + (rnd_vec() * m_brush.m_jitter_spread * 100.f);
        s.size = 100.f * m_brush.m_tip_size * (1.f - rnd_nor() * m_brush.m_jitter_scale);
        s.flow = m_brush.m_tip_flow * (1.f - rnd_nor() * m_brush.m_jitter_flow);
        return s;
    }
};

class Layer
{
public:
    RTT m_rtt;
    bool m_visible = true;
    bool m_locked = false;
    float m_alpha = 1.f;
    std::string m_name;
    bool create(int width, int height, std::string name)
    {
        m_rtt.create(width, height);
        return true;
    }
};

NS_END