#include "map/node.h"

#include "tiles/dirt.h"
#include "tiles/grass.h"
#include "tiles/stone.h"
#include "tiles/rainbow.h"

Node::Node(const Node &other) {
    if(other.m_tile) {
        m_tile = other.m_tile->clone();
        m_tile->set_node(this);
    }

    if(other.m_entity) {
        m_entity = other.m_entity->clone();
        m_entity->set_node(this);
    }

    m_pos = other.m_pos;
    m_size = other.m_size;
}

Node::~Node() {
    if(m_tile) delete m_tile;
    if(m_entity) delete m_entity;
}

void Node::set_tile(Tile *tile) {
    if(!tile) {
        std::cout << "Tried to set null tile!" << std::endl;
        return;
    }
    if(m_tile) {
        delete m_tile;
        m_tile = nullptr;
    }
    if(m_entity) {
        delete m_entity;
        m_entity = nullptr;
    }

    m_tile = tile;
    m_tile->set_node(this);

    set_entity(m_tile->create_entity());
}

void Node::set_entity(Entity *entity) {
    if(!entity)
        return;

    if(m_entity) {
        delete m_entity;
        m_entity = nullptr;
    }

    m_entity = entity;
    m_entity->set_node(this);
}

void Node::update(double dt) {
    if(m_entity)
        m_entity->update(dt);
}

void Node::render(Render r) {
    if(m_tile)
        m_tile->render(r);
}

std::ostream &operator<<(std::ostream &os, const Node &node) {
    os.write(reinterpret_cast<const char *>(&node.m_size), sizeof(node.m_size));

    if(node.m_tile) {
        os << '\x01';
        os << *node.m_tile;
    } else {
        os << '\x00';
    }

    return os;
}

std::istream &operator>>(std::istream &is, Node &node) {
    is.read(reinterpret_cast<char *>(&node.m_size), sizeof(node.m_size));

    uint8_t has_tile = 0;
    is.read(reinterpret_cast<char *>(&has_tile), sizeof(has_tile));
    if(has_tile) {
        int id = 0;
        // TODO: Move / figure this shit out
        is.read(reinterpret_cast<char *>(&id), sizeof(id));
        Tile *tile = nullptr;
        switch(id) {
            case -1:
                tile = new Tile();
                break;
            case 1:
                tile = new Dirt();
                break;
            case 2:
                tile = new Grass();
                break;
            case 3:
                tile = new Stone();
                break;
            case 4:
                tile = new Rainbow();
                break;
            default:
                std::cout << "Invalid tile" << std::endl;
                break;
        }
        if(tile) node.set_tile(tile);
        is >> *node.m_tile;
    }

    return is;
}