#include "gamestate.h"
#include <random>
#include <QDebug>

GameState::GameState(QObject *parent)
    : QObject{parent}
{
    // Initialize the foundation piles (4 suits)
    for (int i = 0; i < 4; ++i) {
        m_foundation.append(QList<PlayingCard*>());
    }

    // Initialize the columns (7 piles)
    for (int i = 0; i < 7; ++i) {
        m_columns.append(QList<ColumnSlot*>());
    }
}

void GameState::dealCards()
{
    QList<PlayingCard*> deck = PlayingCard::createDeck();

    // Randomly shuffle the deck
    std::random_device rd;
    std::default_random_engine rng(rd());
    std::shuffle(deck.begin(), deck.end(), rng);

    // Deal the cards into the columns
    int index = 0;
    for (int i = 0; i < 7; i++) {
        QList<ColumnSlot*> column;

        // Deal exactly i+1 cards to the i-th column
        for (int j = 0; j <= i; j++) {
            bool revealed = (j == i);
            ColumnSlot *col = new ColumnSlot(deck[index], revealed);
            column.append(col);
            index++;
        }

        m_columns[i] = column;
    }

    // Use the remaining cards as the draw pile
    m_drawPile = deck.mid(index);

    // Reset the foundation & throwaway pile
    m_foundation.clear();
    m_throwawayPile.clear();

    emit onDrawPileChanged();
    emit onThrowawayPileChanged();
    emit onColumnsChanged();
    emit onFoundationChanged();
}

void GameState::drawNextCard()
{
    // If drawPile is empty, flip the throwawayPile to drawPile
    if (m_drawPile.isEmpty()) {
        m_drawPile = m_throwawayPile;
        m_throwawayPile.clear();
        std::reverse(m_drawPile.begin(), m_drawPile.end());
    }

    // Draw the top card from drawPile, dropping it into throwawayPile
    m_throwawayPile.append(m_drawPile.takeFirst());

    emit onDrawPileChanged();
    emit onThrowawayPileChanged();
}

bool GameState::moveCardToColumn(int columnId)
{
    assert(columnId >= 0 && columnId < 7);

    if (m_throwawayPile.isEmpty()) {
        // Consider raising an exception here instead
        return false;
    }

    // We'll be moving the last card in the throwaway pile (maybe)
    PlayingCard *cardToMove = m_throwawayPile.last();

    if (m_columns[columnId].isEmpty()) {
        // If the column is empty, we can only place a king
        if (cardToMove->value() != PlayingCard::Value::King)
            return false;

        ColumnSlot *col = new ColumnSlot(cardToMove, true);
        m_columns[columnId].append(col);
        m_throwawayPile.removeLast();

        emit onThrowawayPileChanged();
        emit onColumnsChanged();
        return true;
    }

    // We'll be comparing this card against the last card in the column
    PlayingCard* columnCard = m_columns[columnId].last()->card();

    // This card's value must be one less than the card in the column
    if (cardToMove->value() != columnCard->value() - 1)
        return false;

    // This card must be of opposite color
    if (!PlayingCard::areOppositeColors(*cardToMove, *columnCard))
        return false;

    ColumnSlot *col = new ColumnSlot(cardToMove, true);
    m_columns[columnId].append(col);
    m_throwawayPile.removeLast();
    ensureColumnRevealed(columnId);

    emit onThrowawayPileChanged();
    emit onColumnsChanged();
    return true;
}

bool GameState::moveThrownCardToFoundation(PlayingCard::Suit foundationId)
{
    if (m_throwawayPile.isEmpty()) {
        // Consider raising an exception here instead
        return false;
    }

    // We'll be moving the last card in the foundation pile (maybe)
    PlayingCard *cardToMove = m_throwawayPile.last();

    // Try moving the card into the foundation
    if (!tryMoveCardToFoundation(foundationId, cardToMove))
        return false;

    // We succeeded, the card is now in the appropriate foundation pile,
    // let's remove the card from the throwaway pile.
    m_throwawayPile.removeLast();

    emit onThrowawayPileChanged();
    return true;
}

bool GameState::moveColumnCardToFoundation(int columnId, PlayingCard::Suit foundationId)
{
    assert(columnId >= 0 && columnId < 7);

    if (m_columns[columnId].isEmpty()) {
        // Consider raising an exception here instead
        return false;
    }

    // We'll be moving the top card in the column (maybe)
    PlayingCard *cardToMove = m_columns[columnId].first()->card();

    // Try moving the card into the foundation
    if (!tryMoveCardToFoundation(foundationId, cardToMove))
        return false;

    // We succeeded, the card is now in the appropriate foundation pile,
    // let's remove the column slot.
    m_columns[columnId].removeFirst();
    ensureColumnRevealed(columnId);

    emit onColumnsChanged();
    return true;

}

bool GameState::tryMoveCardToFoundation(PlayingCard::Suit foundationId, PlayingCard* cardToMove)
{
    assert(foundationId >= PlayingCard::Suit::Clubs && foundationId < PlayingCard::Suit::Spades);

    if (cardToMove->suit() != foundationId)
        return false;

    PlayingCard::Value requiredValue;
    if (m_foundation[foundationId].isEmpty()) {
        // If the pile is empty, only an ace can go in
        requiredValue = PlayingCard::Value::Ace;
    } else {
        // Otherwise it's the next card by value, unless we're already at king
        PlayingCard::Value curValue = m_foundation[foundationId].first()->value();
        if (curValue == PlayingCard::Value::King)
            return false;

        // Clever trick to get the next value. Note that this relies on the enum having
        // the variants defined in correct order.
        requiredValue = static_cast<PlayingCard::Value>(static_cast<int>(curValue) + 1);
    }

    if (cardToMove->value() != requiredValue)
        return false;

    m_foundation[foundationId].push_front(cardToMove);

    emit onFoundationChanged();
    return true;
}

void GameState::ensureColumnRevealed(int columnId)
{
    assert(columnId >= 0 && columnId < 7);

    // Nothing to reveal
    if (m_columns[columnId].isEmpty())
        return;

    // Get the top column slot
    ColumnSlot *col = m_columns[columnId].first();

    // If it's already revealed, there's nothing to do
    if (col->isRevealed())
        return;

    // First slot in the column must always be revealed, reveal it
    col->reveal();
}

QList<PlayingCard *> GameState::drawPile() const
{
    return m_drawPile;
}

QList<PlayingCard *> GameState::throwawayPile() const
{
    return m_throwawayPile;
}

QList<QList<ColumnSlot *> > GameState::columns() const
{
    return m_columns;
}

QList<QList<PlayingCard *> > GameState::foundation() const
{
    return m_foundation;
}