#include "mare.h"

namespace Render {

    Drawable::Drawable(const size_t id, Drawable* parent, Mare* engine):
    _id(id),
    _parent(parent),
    _engine(engine),
    _origin({0,0}),
    _bbox({0,0,0,0}),
    _blendMode(Render::BlendMode::Add),
    _dirty(false)
    {
    }

    Drawable::~Drawable() {

    }

    //--------+--------+--------+--------+--------+--------+--------+--------+--------+--------//
    //Point
    DrawablePoint::DrawablePoint(const size_t id, Drawable* parent, Mare* engine, dim_t size):
        Drawable(id, parent,engine),
        _size(size)
    {

    }

    DrawablePoint::~DrawablePoint() {

    }

    void DrawablePoint::render() {
        uint8_t *buf;
        pos_t o = getOrigin();
        if (isDirty()){
            buf = getBuffer();
            //TODO: implement screen rotation and margin check
            auto dx = engine()->getSize().x;
            auto dy = engine()->getSize().y;
            for (uint16_t xx(0); xx< _size.x; xx++){
                for (uint16_t yy(0); yy < _size.y; yy++)
                {
                    engine()->setPixel(buf,o.x+xx,o.y+yy,getBlendMode());
                }  
            }
            resetDirty();
        }
    }


    //--------+--------+--------+--------+--------+--------+--------+--------+--------+--------//
    //Line
    DrawableLine::DrawableLine(const size_t id, Drawable* parent, Mare* engine):
        Drawable(id, parent,engine),
        _thickness(1),
        _length(0),
        _rotation(0)
    {
        setThickness(_thickness); // only to calc offset
    }

    DrawableLine::~DrawableLine()
    {

    }

    void DrawableLine::render(){
        uint8_t* buf = getBuffer();
        auto tt = _thickness;
        auto e = engine();
        if (isDirty()) {
            _rotation = _rotation % 360;
            pos_t o = getOrigin();
            pos_t res = {0,0};
            for (uint16_t t(0); t < _thickness; ++t) {
                for (uint16_t xx(0); xx < _length; ++xx) {
                    if (_rotation == 0 || _rotation == 180){
                        res.x = _rotation == 0 ? xx : (_length-xx);
                        res.y = t-(_thickness>>1);
                    } else if (_rotation == 90 || _rotation == 270){
                        res.x = t-(_thickness>>1);
                        res.y = _rotation == 90 ? xx : _length-xx;
                    } else {
                        res = e->rotateXY(xx,t-_ofst,_rotation/180.0f*M_PI);
                    }
                    e->setPixel(buf,res.x+o.x,res.y+o.y,getBlendMode());
                    
                }
            }
            resetDirty();
        }
    }

    //--------+--------+--------+--------+--------+--------+--------+--------+--------+--------//
    //Rectangle

    DrawableRectangle::DrawableRectangle(const size_t id, Drawable* parent, Mare* engine):
        Drawable(id, parent,engine),
        _thickness(1),
        _rotation(0),
        _dim({8,8}),
        _outline(false)
    {

    }

    DrawableRectangle::~DrawableRectangle()
    {

    }

    void DrawableRectangle::createOutline(){
        auto e = engine();
        pos_t o = getOrigin();
        auto rf = (_rotation % 360)/180.0f*M_PI;
    
        if (l1 == nullptr) l1 = e->addDrawable<DrawableLine>();
        if (l2 == nullptr) l2 = e->addDrawable<DrawableLine>();
        if (l3 == nullptr) l3 = e->addDrawable<DrawableLine>();
        if (l4 == nullptr) l4 = e->addDrawable<DrawableLine>();

        l1->setRotation(_rotation);
        l1->setLength(_dim.x);
        l1->setThickness(_thickness);
        l2->setRotation(_rotation+90);
        l2->setLength(_dim.y);
        l2->setThickness(_thickness);
        l3->setRotation(_rotation);
        l3->setLength(_dim.x);
        l3->setThickness(_thickness);
        l4->setRotation(_rotation+90);
        l4->setLength(_dim.y);
        l4->setThickness(_thickness);

        uint8_t of = l2->_ofst;
        pos_t res = {0,0};
        l1->setOrigin(o);

        res = e->rotateXY((_dim.x-of),0,rf);
        l2->setOrigin({(p_t)(o.x+res.x), (p_t)(o.y+res.y)});

        res = e->rotateXY(0,(_dim.y-of),rf);
        l3->setOrigin({(p_t)(o.x+res.x), (p_t)(o.y+res.y)});

        res = e->rotateXY(of,-of,rf);
        l4->setOrigin({(p_t)(o.x+res.x), (p_t)(o.y+res.y)});

        l1->setDirty();
        l2->setDirty();
        l3->setDirty();
        l4->setDirty();
    }

    void DrawableRectangle::render() 
    {
        uint8_t* buf = getBuffer();
        auto tt = _thickness;
        auto e = engine();
        if (isDirty()) {
            if (_outline) {
                createOutline();
                l1->render();
                l2->render();
                l3->render();
                l4->render();
            }
            resetDirty();
        }
    }

    //--------+--------+--------+--------+--------+--------+--------+--------+--------+--------//
    //Circle

    //--------+--------+--------+--------+--------+--------+--------+--------+--------+--------//
    //Character

    //--------+--------+--------+--------+--------+--------+--------+--------+--------+--------//
    //String
    
    //--------+--------+--------+--------+--------+--------+--------+--------+--------+--------//
    //Custom
    
}