#include "Piece.hpp"

#include <ostream>

Piece::Piece(PieceColor color, PieceType type) : mColor(color), mType(type) {
}

Piece::Optional Piece::fromSymbol(char symbol) {
    PieceColor color = std::isupper(symbol) ? PieceColor::White : PieceColor::Black;
    auto type = pieceTypeFromSymbol(symbol);
    if (!type.has_value()) {
        return std::nullopt;
    }

    return Piece(color, type.value());
}

PieceColor Piece::color() const {
    return mColor;
}

int Piece::colorVal() const {
    return static_cast<int>(mColor);
}

PieceType Piece::type() const {
    return mType;
}

int Piece::typeVal() const {
    return static_cast<int>(mType);
}

std::optional<PieceType> Piece::pieceTypeFromSymbol(char symbol) {
    switch (toupper(symbol)) {
    case 'P': return PieceType::Pawn;
    case 'N': return PieceType::Knight;
    case 'B': return PieceType::Bishop;
    case 'R': return PieceType::Rook;
    case 'Q': return PieceType::Queen;
    case 'K': return PieceType::King;
    default: return std::nullopt;
    }
}
Piece::Optional Piece::fromValue(unsigned int value) {
    return Piece(valToColor(value), valToType(value));
}

bool operator==(const Piece &lhs, const Piece &rhs) {
    return lhs.color() == rhs.color() && lhs.type() == rhs.type();
}

std::ostream &operator<<(std::ostream &os, const Piece &piece) {
    int typeNum;

    switch (piece.type()) {
    case PieceType::Pawn: typeNum = 'P';
        break;
    case PieceType::Knight: typeNum = 'N';
        break;
    case PieceType::Bishop: typeNum = 'B';
        break;
    case PieceType::Rook:typeNum = 'R';
        break;
    case PieceType::Queen: typeNum = 'Q';
        break;
    case PieceType::King: typeNum = 'K';
        break;
    default:
        return os;
    }

    if (piece.color() == PieceColor::Black) {
        typeNum = std::tolower(typeNum);
    }

    os << static_cast<char>(typeNum);
    return os;
}

PieceColor operator!(PieceColor color) {
    return static_cast<PieceColor>((static_cast<int>(color) + 1) % 2);
}