package ch.epfl.javass.jass;
import ch.epfl.javass.bits.Bits32;
import ch.epfl.javass.jass.Card.Color;;

public final class TurnState {

    public long pkScore;
    public int pkTrick;
    public long pkUnplayedCards;

    private TurnState(long pkScore,long pkUnplayedCards,int pkTrick) {
        this.pkScore = pkScore;
        this.pkTrick = pkTrick;
        this.pkUnplayedCards = pkUnplayedCards;
    }

    public static TurnState initial(Color trump, Score score, PlayerId firstPlayer) {
        return ofPackedComponents(score.packed(), PackedCardSet.ALL_CARDS, PackedTrick.firstEmpty(trump, firstPlayer));
    }

    public static TurnState ofPackedComponents(long pkScore, long pkUnplayedCards, int pkTrick) {
        if (PackedScore.isValid(pkScore) && PackedCardSet.isValid(pkUnplayedCards) && PackedTrick.isValid(pkTrick)) {
            return new TurnState(pkScore,pkUnplayedCards,pkTrick);
        }
        else {
            throw new IllegalArgumentException();
        }
    }

    public long packedScore() {
        return pkScore;
    }

    public long packedUnplayedCards() {
        return pkUnplayedCards;
    }

    public int packedTrick() {
        return pkTrick;
    }

    public Score score() {
        return Score.ofPacked(pkScore);
    }

    public CardSet unplayedCards() {
        return CardSet.ofPacked(pkUnplayedCards);
    }

    public Trick trick() {
        return Trick.ofPacked(pkTrick);
    }

    public boolean isTerminal() {
        return (pkTrick == PackedTrick.INVALID);
    }

    public PlayerId nextPlayer() {
        if(!PackedTrick.isFull(pkTrick)) {
            if(PackedTrick.isEmpty(pkTrick)) {
                return PackedTrick.player(pkTrick, 0);
            }
            else {
                int lastPlayerOrdinal = PackedTrick.player(pkTrick, PackedTrick.size(pkTrick)-1).ordinal();
                if (lastPlayerOrdinal == 4) {
                    return PlayerId.ALL.get(0);
                }
                else {
                    return PlayerId.ALL.get(lastPlayerOrdinal - 1);
                }
            }

        }
        else {
            throw new IllegalStateException();
        }
    }

    public TurnState withNewCardPlayed(Card card) {
        if(!PackedTrick.isFull(pkTrick)) {
            return ofPackedComponents(pkScore,PackedCardSet.remove(pkUnplayedCards, card.packed()), PackedTrick.withAddedCard(pkTrick, card.packed()));
        }
        else {
            throw new IllegalStateException();
        }
    }

    public TurnState withTrickCollected() {
        if(PackedTrick.isFull(pkTrick)) {
            long newScore = PackedScore.withAdditionalTrick(pkScore, PackedTrick.winningPlayer(pkTrick).team(), PackedTrick.points(pkTrick));
            return new TurnState(newScore,pkUnplayedCards,PackedTrick.nextEmpty(pkTrick)) ;
        }
        else {
            throw new IllegalStateException();
        }
    }

    public TurnState withNewCardPlayedAndTrickCollected(Card card){
        TurnState newState = this.withNewCardPlayed(card);
        return newState.withTrickCollected();

    }
}