package admin;

import player.PlayerProcessor;
import utils.*;
import utils.comparator.*;
import edu.neu.ccs.demeterf.demfgen.lib.List;
import edu.neu.ccs.demeterf.demfgen.lib.Option;
import classes.*;

/**
 * Administrator of the game 
 * @author animesh */
public class Administrator{
    private static Players players;
    private static Config config;

    /**
     * Main method for Administrator
     * @param args 
     */
    public static void main(String[] args) {
        players = DocumentHandler.getPlayers();
        config = DocumentHandler.getConfig();
        Administrator administrator = new Administrator();		
        int i=0;
        while(i<config.maxRounds){
            System.out.println("ROUND "+i);
            List<PlayerTransaction> pTransactions = List.create();
            Round round = new Round(i, pTransactions);
            for(Player player: players.players){				
                Administrator.passTurn(player);
                PlayerTransaction pTrans = DocumentHandler.getPlayerTrans(player);
                boolean isRuleFollowed = new RuleChecker().isRuleFollowed(pTrans);
                if(isRuleFollowed){
                    Administrator.updateStore(pTrans);
                    Administrator.updateAccounts(pTrans);					
                }
                else{
                    System.out.println("**************Player "+player.id.id+" has violated the rule.***************	");
                    administrator.takeViolationAction(players, player);
                }				
                round.ptransactions = round.ptransactions.push(pTrans);
            }
            Administrator.updateHistory(round);
            i++;
        }
    }


    /** Takes appropriate actions in case one of the players violates rules
     * @param players
     * @param player
     */
    private void takeViolationAction(Players players, Player player) {
        Store existingStore = DocumentHandler.getStore();
        Accounts existingAccounts = DocumentHandler.getAccounts();
        if(existingStore.stores.contains(new PlayerStoreComparator(player.id))){
//          for each derivative in the <boughtstore> of the player 
//          deduct price value from the account of the seller
//          add the derivative back to the <forSale> store of the seller
            Pair<PlayerID, PlayerStore> pIDAndStore = existingStore.stores.find(new PlayerStoreComparator(player.id));
            List<Derivative> playerBoughtStore = pIDAndStore.b.bought;

            for(Derivative der: playerBoughtStore){
                Pair<PlayerID, Double> dummyAccount = new Pair<PlayerID,Double>(der.seller, 0.0);
                Pair<PlayerID, Double> sellerAccount = existingAccounts.accounts.find(new PlayerAccountComparator(dummyAccount));
                sellerAccount.b = sellerAccount.b-der.price.val;
                existingAccounts.accounts = existingAccounts.accounts.replace(new PlayerAccountComparator(sellerAccount), sellerAccount);
                Pair<PlayerID, PlayerStore> sellerIDAndStore = existingStore.stores.find(new PlayerStoreComparator(der.seller));
                sellerIDAndStore.b.forSale = sellerIDAndStore.b.forSale
                .push(new Derivative(der.name, der.seller, Option.<PlayerID>none(), der.price, der.type,
                        Option.<RawMaterial>none(), Option.<FinishedProduct>none()));
                existingStore.stores = existingStore.stores.replace(new PlayerStoreComparator(sellerIDAndStore.a), sellerIDAndStore);	
            }


//          for each derivative that is created by the player AND in the <boughtStore> of Players
//          add price value to the account of the buyer
//          remove derivative from the bought store of the buyer
            for(Player otherPlayer: players.players){
                Pair<PlayerID, PlayerStore> otherPIDAndStore = existingStore.stores.find(new PlayerStoreComparator(otherPlayer.id));
                List<Derivative> otherPlayerBoughtStore = otherPIDAndStore.b.bought;
                for(Derivative der: otherPlayerBoughtStore){
                    if(der.seller.equals(player.id)){
                        Pair<PlayerID, Double> dummyAccount = new Pair<PlayerID, Double>(otherPIDAndStore.a, 0.0);
                        Pair<PlayerID, Double> buyerAccount = existingAccounts.accounts.find(new PlayerAccountComparator(dummyAccount));
                        buyerAccount.b = buyerAccount.b+der.price.val;
                        existingAccounts.accounts = existingAccounts.accounts.replace(new PlayerAccountComparator(buyerAccount), buyerAccount);
                        otherPlayerBoughtStore = otherPlayerBoughtStore.remove(der);
                    }
                }
                otherPIDAndStore.b.bought = otherPlayerBoughtStore;
                existingStore.stores = existingStore.stores.replace(new PlayerStoreComparator(otherPlayer.id), otherPIDAndStore);
//              existingStore.stores = existingStore.stores.remove(new PlayerStoreComparator(otherPlayer.id));
//              existingStore.stores = existingStore.stores.push(otherPIDAndStore);

            }
            DocumentHandler.commitStore(existingStore);			
            DocumentHandler.commitAccounts(existingAccounts);		
        }
//      remove the player store from store
        existingStore.stores = existingStore.stores.remove(new PlayerStoreComparator(player.id));
        DocumentHandler.commitStore(existingStore);
//      remove the player account from accounts
        Pair<PlayerID, Double> dummyAccount = new Pair<PlayerID,Double>(player.id, 0.0);
        existingAccounts.accounts = existingAccounts.accounts.remove(new PlayerAccountComparator(dummyAccount));
        DocumentHandler.commitAccounts(existingAccounts);		
//      remove the player from players
        players.players = players.players.remove(player);
    }

    /** Updates the store with the player transaction */
    private static void updateStore(PlayerTransaction trans) {
        Store existingStore = DocumentHandler.getStore();
        Store newStore = StoreUpdater.updateStore(existingStore, trans);
        DocumentHandler.commitStore(newStore);		
    }
    /** Updates the accounts with the player transaction */
    private static void updateAccounts(PlayerTransaction pTrans) {
        Accounts existingAccounts = DocumentHandler.getAccounts();
        Accounts newAccounts = AccountUpdater.updateAccounts(existingAccounts, pTrans);
        DocumentHandler.commitAccounts(newAccounts);		
    }
    /** Updates the history with the round */
    private static void updateHistory(Round round) {
        History history = DocumentHandler.getHistory();
        history.rounds = history.rounds.push(round);
        DocumentHandler.commitHistory(history);		
    }
    /** Passes the turn to player */
    private static void passTurn(Player player) {		
        PlayerProcessor playerProcessor = new PlayerProcessor(player);
        playerProcessor.takeTurn();
    }	
}