#ifndef TETRIS_CUSTOM_CLASSES_H
#define TETRIS_CUSTOM_CLASSES_H

#include "../sdlpp.hpp"
#include "config.hpp"

class TetrisBlock : public SDLPP::RectangleRender {
public:
    TetrisBlock() = delete;
    TetrisBlock( double x, double y, double w, double h,
                 const std::shared_ptr< SDLPP::Renderer > &r,
                 const std::string &img_or_color, bool is_polygon,
                 int index, std::shared_ptr<SDLPP::Scene> scene, std::vector<int> &bag )
            : RectangleRender( x, y, w, h, r, img_or_color, is_polygon ), pieces_bag(bag) {
        _index = index;
        pieces_bag[_index]--;
        _scene = scene;
    }
    TetrisBlock( const TetrisBlock &other ) : TetrisBlock(other.getDoubleRect().first.first,other.getDoubleRect().first.second,other.getDoubleRect().second.first,other.getDoubleRect().second.second,other.getRenderer(), other.getColor(), true, other._index, other._scene, other.pieces_bag) {}
    ~TetrisBlock() {
        pieces_bag[_index]++;
    }
    virtual std::shared_ptr<RenderObject> copySelf() override {
        return std::make_shared<TetrisBlock>(*this);
    }
    std::shared_ptr<TetrisBlock> copyInScene() {
        auto ret = std::shared_ptr<TetrisBlock>(new TetrisBlock(*this));
        _scene->addObject(ret);
        return ret;
    }
    bool isSamePos(const SDLPP::RenderObject &other) const {
        auto mypos = getPos();
        auto otherpos = other.getPos();
        auto diff1 = mypos.first - otherpos.first;
        diff1 = (diff1 < 0) * (-1) * diff1 + (diff1 > 0) * diff1;
        auto diff2 = mypos.second - otherpos.second;
        diff2 = (diff2 < 0) * (-1) * diff2 + (diff2 > 0) * diff2;
        return diff1 < 0.0001 && diff2 < 0.0001;
    }
    virtual void specialAction( int code ) override {
        switch(code) {
            case PIECE_ACTION_UPDATE_COLOR: {
                auto piece_name = getPieceName();
                setColor(colors[piece_name]);
                setOutlineColor(colors[piece_name + "_out"]);
                }
            default:
                break;
        }
    }

private:
    std::string getPieceName() {
        switch(_index) {
            case PIECE_BRICK:
                return "piece_brick";
            case PIECE_T:
                return "piece_T";
            case PIECE_L_RIGHT:
                return "piece_L_right";
            case PIECE_Z_RIGHT:
                return "piece_Z_right";
            case PIECE_LINE:
                return "piece_line";
            case PIECE_L_LEFT:
                return "piece_L_left";
            case PIECE_Z_LEFT:
                return "piece_Z_left";
            default:
                break;
        }
        return "";
    }
    int _index = 0;
    std::shared_ptr<SDLPP::Scene> _scene;
    std::vector<int> &pieces_bag;
};

class TetrisPiece {
public:
    TetrisPiece() {
        original_pos.reserve( 4 );
    }
    void addPiece( std::shared_ptr< TetrisBlock > piece, int x,
                   int y ) {
        pieces.push_back( piece );
        pieces_rel_position.push_back( { 0, 0, 0, 0 } );
        // done this way for SPEEEEEEED
        // left
        pieces_rel_position.back()[0] = ( x < 0 ) * ( -1 ) * x;
        // right
        pieces_rel_position.back()[1] = ( x > 0 ) * x;
        // top
        pieces_rel_position.back()[2] = ( y < 0 ) * ( -1 ) * y;
        // bottom
        pieces_rel_position.back()[3] = ( y > 0 ) * y;
    }
    void rotate() {
        if(!rotate_allowed)
            return;
        for ( unsigned long i = 0; i < pieces.size(); i++ ) {
            auto &piece = pieces[i];
            auto &positions = pieces_rel_position[i];
            auto position = piece->getPos();
            original_pos[i] = position;
            position.first += positions[0] * BLOCK_SIZE;
            position.first -= positions[1] * BLOCK_SIZE;
            position.second += positions[2] * BLOCK_SIZE;
            position.second -= positions[3] * BLOCK_SIZE;
            auto bottom = positions[3];
            auto top = positions[2];
            positions[3] = positions[1];
            positions[2] = positions[0];
            positions[1] = top;
            positions[0] = bottom;
            position.first -= positions[0] * BLOCK_SIZE;
            position.first += positions[1] * BLOCK_SIZE;
            position.second -= positions[2] * BLOCK_SIZE;
            position.second += positions[3] * BLOCK_SIZE;
            piece->setPos( position.first, position.second );
        }
    }
    void revert() {
        for ( unsigned long i = 0; i < pieces.size(); i++ ) {
            auto &piece = pieces[i];
            auto &positions = pieces_rel_position[i];
            piece->setPos( original_pos[i].first, original_pos[i].second );
            auto top = positions[1];
            auto bottom = positions[0];
            positions[1] = positions[3];
            positions[0] = positions[2];
            positions[2] = top;
            positions[3] = bottom;
        }
    }
    std::vector< std::shared_ptr< TetrisBlock > > &getObjects() {
        return pieces;
    }
    void setPos( double x, double y ) {
        for ( unsigned long i = 0; i < pieces.size(); i++ ) {
            auto &piece = pieces[i];
            auto &positions = pieces_rel_position[i];
            std::pair<double, double> pos = {x, y};
            pos.first -= positions[0] * BLOCK_SIZE;
            pos.first += positions[1] * BLOCK_SIZE;
            pos.second -= positions[2] * BLOCK_SIZE;
            pos.second += positions[3] * BLOCK_SIZE;
            piece->setPos( pos.first, pos.second );
        }
    }
    void setPos(const std::pair<double,double> &pos) {
        setPos(pos.first, pos.second);
    }
    std::pair<double, double> getPos() {
        auto &piece = pieces[0];
        auto &relpositions = pieces_rel_position[0];
        auto pos = piece->getPos();
        pos.first += relpositions[0] * BLOCK_SIZE;
        pos.first -= relpositions[1] * BLOCK_SIZE;
        pos.second += relpositions[2] * BLOCK_SIZE;
        pos.second -= relpositions[3] * BLOCK_SIZE;
        return pos;
    }
    void clear() {
        pieces.clear();
        pieces_rel_position.clear();
    }
    void startDescend() {
        descend = true;
    }
    void stopDescend() {
        descend = false;
    }
    void startMovement() {
        userMovement += 1;
    }
    void stopMovement() {
        userMovement -= 1;
    }
    bool isDescending() {
        return descend;
    }
    bool isMoving() {
        return userMovement > 0;
    }
    bool isLeft(const SDLPP::RenderObject &block) const {
        return isPosition(block, 0);
    }
    bool isRight(const SDLPP::RenderObject &block) const {
        return isPosition(block, 1);
    }
    void movePiece(double x, double y) {
        for ( auto &block : getObjects() ) {
            auto pos = block->getPos();
            block->setPos( pos.first + x, pos.second + y );
        }
    }
    void disableRotation() {
        rotate_allowed = false;
    }

    void turnIntoShadow() {
        for(auto &block : getObjects() ) {
            block->setId(SHADOW_ID);
            block->setColor(colors["shadow"]);
        }
        setHidden(!g_show_shadow);
    }
    std::shared_ptr<TetrisPiece> copySelf() {
        auto ret = std::make_shared<TetrisPiece>();
        for(int i = 0; i < 4; i++) {
            auto block = pieces[i]->copyInScene();
            block->centerX();
            ret->addBlockInPos(block, pieces_rel_position[i]);
        }
        return ret;
    }
    void destroy() {
        for(auto &x : getObjects()) {
            x->destroy();
        }
    }
    void addMovement(int x, int y) {
        movement.first += x;
        movement.second += y;
    }
    std::pair<int,int> getMovement() const {
        return movement;
    }
    void setHidden(bool hidden) {
        _hidden = hidden;
        for(auto &x : getObjects()) {
            x->setHidden(hidden);
        }
    }
    bool getHidden() {
        return _hidden;
    }

private:
    bool isPosition(const SDLPP::RenderObject &block, int pos) const {
        for(int i = 0; i < 4; i++) {
            if(pieces[i]->isSamePos(block)) {
                return pieces_rel_position[i][pos] != 0;
            }
        }
        return false;
    }
    void resetBlock(int index, std::shared_ptr< TetrisBlock > piece) {
        piece->setPos(pieces[index]->getPos());
        pieces[index] = piece;
    }
    void addBlockInPos(std::shared_ptr<TetrisBlock> piece, const std::vector<int> &relpos) {
        pieces.push_back( piece );
        pieces_rel_position.push_back(relpos);
    }
    std::vector< std::vector< int > > pieces_rel_position;
    std::vector< std::shared_ptr< TetrisBlock > > pieces;
    std::vector< std::pair< double, double > > original_pos;
    bool descend = false;
    int userMovement = 0;
    bool rotate_allowed = true;
    std::pair<int,int> movement = {0,0};
    bool _hidden = false;
};

#endif