namespace Chess {
namespace Elements {
class Board;

template <class>
struct Piece;

class King_impl;
class Queen_impl;
class Rook_impl;
class Bishop_impl;
class Knight_impl;
class Pawn_impl;

using King = Piece<King_impl>;
using Queen = Piece<Queen_impl>;
using Rook = Piece<Rook_impl>;
using Bishop = Piece<Bishop_impl>;
using Knight = Piece<Knight_impl>;
using Pawn = Piece<Pawn_impl>;

using Any_piece = boost::variant<King,
                                 Queen,
                                 Rook,
                                 Bishop,
                                 Knight,
                                 Pawn>;

enum class Team : bool { black, white };

struct Piece_position {
    Sdl::Point value{};
    bool changed{false};
};

template <class Piece_impl>
struct Piece {
    Piece_impl impl{};
    Team team{};
    Piece_position position{};
};

class King_impl {
public:
    bool can_jump(Sdl::Point, const Board&) const noexcept;
    std::string name() const;
};

class Queen_impl {
public:
    bool can_jump(Sdl::Point, const Board&) const noexcept;
    std::string name() const;
};

class Rook_impl {
public:
    bool can_jump(Sdl::Point, const Board&) const noexcept;
    std::string name() const;
};

class Bishop_impl {
public:
    bool can_jump(Sdl::Point, const Board&) const noexcept;
    std::string name() const;
};

class Knight_impl {
public:
    bool can_jump(Sdl::Point, const Board&) const noexcept;
    std::string name() const;
};

class Pawn_impl {
public:
    bool can_jump(Sdl::Point, const Board&) const noexcept;
    std::string name() const;
};

// TEST
// *****************************
struct SIZE_TEST1 : King {};
struct SIZE_TEST2 : Any_piece {};
// *****************************

template <class Piece_impl>
bool can_jump(
    Piece_impl pi,
    Sdl::Point to,
    const Board& board) noexcept {
    return pi.can_jump(pi, to, board);
}

Team get_team(Any_piece) noexcept;
Piece_position get_position(Any_piece) noexcept;
bool can_jump(Any_piece ap, Sdl::Point to, const Board& board) noexcept;
std::string name(Any_piece);

Piece_position position(Any_piece ap) noexcept {
    return boost::apply_visitor(
        [](auto piece) noexcept {
            return piece.position;
        }, ap
    );
}

bool can_jump(Any_piece ap, Sdl::Point to, const Board& board) noexcept {
    return boost::apply_visitor(
        [to, &board](auto piece) noexcept {
            return piece.impl.can_jump(to, board);
        }, ap
    );
}

std::string name(Any_piece ap) {
    return boost::apply_visitor(
        [](auto piece) noexcept {
            return piece.impl.name();
        }, ap
    );
}