package ch.epfl.javass.jass;

import java.util.ArrayList;
import java.util.Collections;
import java.util.EnumMap;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;

import ch.epfl.javass.jass.Card.Color;
import ch.epfl.javass.jass.Card.Rank;

public final class JassGame {

    private TurnState turnState;
    private Random shuffleRng;
    private Random trumpRng;
    private Map<PlayerId, Player> players;
    private Map<PlayerId, String> playerNames;
    private PlayerId firstPlayer;
    private Map<PlayerId, CardSet> playerSet;

    public JassGame(long rngSeed, Map<PlayerId, Player> players,
            Map<PlayerId, String> playerNames) {

        Random rng = new Random(rngSeed);
        this.shuffleRng = new Random(rng.nextLong());
        this.trumpRng = new Random(rng.nextLong());
        this.players = Collections.unmodifiableMap(new EnumMap<>(players));
        this.playerNames = Collections.unmodifiableMap(new EnumMap<>(playerNames));
        playerSet = new EnumMap<>(PlayerId.class);
        shuffleAndDistribute();
        firstPlayer = starterPlayer();
        this.turnState = TurnState.initial(trumpRandom(), Score.INITIAL, firstPlayer);

    }

    public boolean isGameOver() {
        return (PackedScore.totalPoints(turnState.pkScore,
                TeamId.TEAM_1) >= 1000
                || PackedScore.totalPoints(turnState.pkScore,
                     TeamId.TEAM_2) >= 1000);
    }

    public void advanceToEndOfNextTrick() {
        if (isGameOver()) {
            return;
        }

        turnState = turnState.withTrickCollected();

        for (Map.Entry<PlayerId, Player> p : players.entrySet()) {
            p.getValue().updateScore(this.turnState.score());
            ;
        }

        for (Map.Entry<PlayerId, Player> p : players.entrySet()) {
            p.getValue().setPlayers(p.getKey(), playerNames);
        }
        shuffleAndDistribute();
        Color trump = trumpRandom();
        if (this.turnState.isTerminal()) {
            this.turnState.initial(trump, this.turnState.score(),
                    this.turnState.nextPlayer());
            players.get(this.turnState.nextPlayer()).setTrump(trump);
            play();
            play();
            play();
            play();
        } else {
            this.turnState.trick().nextEmpty();
            play();
            play();
            play();
            play();

        }

    }

    private PlayerId starterPlayer() {

        for (int i = 0; i < 4; ++i) {
            if (playerSet.get(PlayerId.ALL.get(i)).contains(Card.of(Card.Color.DIAMOND, Card.Rank.SEVEN)))
                return PlayerId.ALL.get(i);
        }
        throw new IllegalArgumentException();

    }

    private Color trumpRandom() {
        return Card.Color.ALL.get(trumpRng.nextInt(4));

    }

    private void shuffleAndDistribute() {
        List<Card> deck = new ArrayList<Card>();
        for (Color c : Card.Color.ALL) {
            for (Rank r : Card.Rank.ALL) {
                deck.add(Card.of(c, r));
            }
        }
        Collections.shuffle(deck, shuffleRng);

        for (int i = 0; i < 4; i++) {
            playerSet.put(PlayerId.ALL.get(i), CardSet.of(deck.subList(i * 9, (i + 1) * 9)));
        }
    }

    private void play() {
        PlayerId player = this.turnState.nextPlayer();
        Card cardPlayed = players.get(player).cardToPlay(this.turnState,
                playerSet.get(player));
        this.turnState.withNewCardPlayed(cardPlayed);
        playerSet.replace(player, playerSet.get(player).remove(cardPlayed));
        players.get(player).updateHand(playerSet.get(player));
        players.get(player).updateTrick(this.turnState.trick());
    }

}