package ch.zhaw.catan;

import ch.zhaw.catan.Config.Faction;
import ch.zhaw.catan.Config.Resource;

import java.awt.*;
import java.util.*;
import java.util.List;


/**
 * This class performs all actions related to modifying the game state.
 * <p>
 * TODO: (your documentation)
 *
 * @author TODO
 */
public class SiedlerGame {
    static final int FOUR_TO_ONE_TRADE_OFFER = 4;
    static final int FOUR_TO_ONE_TRADE_WANT = 1;

    private SiedlerBoard board;
    private ArrayList<Player> allPlayers;
    private int winPointsForWin;
    private Bank bank;
    private int activePlayer;

    /**
     * Constructs a SiedlerGame game state object.
     *
     * @param winPoints       the number of points required to win the game
     * @param numberOfPlayers the number of players
     * @throws IllegalArgumentException if winPoints is lower than
     *                                  three or players is not between two and four
     */
    public SiedlerGame(int winPoints, int numberOfPlayers) {
        if(winPoints < 3 || numberOfPlayers < 2 || numberOfPlayers > 4) {
            throw new IllegalArgumentException();
        }
        bank = new Bank();
        board = new SiedlerBoard();
        board.createFixGamefield();
        allPlayers = new ArrayList<>();
        createPlayer(numberOfPlayers);
        activePlayer = 0;
        this.winPointsForWin = winPoints;
    }

    private void createPlayer(int numberOfPlayers) {
        for (int i = 0; i < numberOfPlayers; i++) {
            allPlayers.add(new Player(Config.Faction.values()[i]));
        }
    }

    /**
     * Switches to the next player in the defined sequence of players.
     */
    public void switchToNextPlayer() {
        if (activePlayer < allPlayers.size() -1){
            activePlayer++;
        }
        else if (activePlayer == allPlayers.size() -1){
            activePlayer = 0;
        }
    }

    /**
     * Switches to the previous player in the defined sequence of players.
     */
    public void switchToPreviousPlayer() {
        if (activePlayer > 0){
            activePlayer--;
        }
        else if (activePlayer == 0){
            activePlayer = allPlayers.size()-1;
        }
    }

    private boolean addResourcesToPlayer(Player player, Resource resource, int numberToAdd){
        if(bank.getResourceFromBank(resource, numberToAdd)){
            player.addResource(resource, numberToAdd);
            return true;
        }
        return false;
    }

    private boolean substractResourceFromPlayer(Player player, Resource resource, int numberToSubstract){
        if(player.substractResource(resource, numberToSubstract)){
            bank.storeResourceToBank(resource, numberToSubstract);
            return true;
        }
        return false;
    }

    /**
     * Returns the {@link Faction}s of the active players.
     *
     * <p>The order of the player's factions in the list must
     * correspond to the oder in which they play.
     * Hence, the player that sets the first settlement must be
     * at position 0 in the list etc.
     *
     * <strong>Important note:</strong> The list must contain the
     * factions of active players only.</p>
     *
     * @return the list with player's factions
     */
    public List<Faction> getPlayerFactions() {
        List<Faction> factions = new ArrayList<>();
        for (Player player: allPlayers ) {
            factions.add(player.getFaction());
        }

        return factions;
    }


    /**
     * Returns the game board.
     *
     * @return the game board
     */
    public SiedlerBoard getBoard() {
        return board;
    }

    /**
     * Returns the {@link Faction} of the current player.
     *
     * @return the faction of the current player
     */
    public Faction getCurrentPlayerFaction() {
        return allPlayers.get(activePlayer).getFaction();
    }

    /**
     * Returns how many resource cards of the specified type
     * the current player owns.
     *
     * @param resource the resource type
     * @return the number of resource cards of this type
     */
    public int getCurrentPlayerResourceStock(Resource resource) {
        return allPlayers.get(activePlayer).getSpecificResource(resource);
    }

    public HashMap<Resource, Integer> getCurrentPlayerResource() {
        return allPlayers.get(activePlayer).getResources();
    }

    /**
     * Places a settlement in the founder's phase (phase II) of the game.
     *
     * <p>The placement does not cost any resource cards. If payout is
     * set to true, for each adjacent resource-producing field, a resource card of the
     * type of the resource produced by the field is taken from the bank (if available) and added to
     * the players' stock of resource cards.</p>
     *
     * @param position the position of the settlement
     * @param payout   if true, the player gets one resource card per adjacent resource-producing field
     * @return true, if the placement was successful
     */
    public boolean placeInitialSettlement(Point position, boolean payout) {
        if(!validPositionForSettlement(position)){
            return false;
        }
        board.setCorner(position, new Settlement(allPlayers.get(activePlayer).getFaction(),position));
        if(payout) {
            List<Config.Land> lands = board.getLandsForCorner(position);
            for (Config.Land land : lands) {
                if (land.getResource() != null) {
                    addResourcesToPlayer(allPlayers.get(activePlayer), land.getResource(), 1);
                }
            }
        }
        return true;
    }

    /**
     * Places a road in the founder's phase (phase II) of the game.
     * The placement does not cost any resource cards.
     *
     * @param roadStart position of the start of the road
     * @param roadEnd   position of the end of the road
     * @return true, if the placement was successful
     */
    public boolean placeInitialRoad(Point roadStart, Point roadEnd) {
        if (!validPositionForRoad(roadStart, roadEnd)){
            return false;
        }
        board.setEdge(roadStart, roadEnd, new Road(allPlayers.get(activePlayer).getFaction(),roadStart,roadEnd));
        return true;
    }

    /**
     * This method takes care of actions depending on the dice throw result.
     * <p>
     * A key action is the payout of the resource cards to the players
     * according to the payout rules of the game. This includes the
     * "negative payout" in case a 7 is thrown and a player has more than
     * {@link Config#MAX_CARDS_IN_HAND_NO_DROP} resource cards.
     * <p>
     * If a player does not get resource cards, the list for this players'
     * {@link Faction} is <b>an empty list (not null)</b>!.
     *
     * <p>
     * The payout rules of the game take into account factors such as, the number
     * of resource cards currently available in the bank, settlement types
     * (settlement or city), and the number of players that should get resource
     * cards of a certain type (relevant if there are not enough left in the bank).
     * </p>
     *
     * @param dicethrow the resource cards that have been distributed to the players
     * @return the resource cards added to the stock of the different players
     */
    public Map<Faction, List<Resource>> throwDice(int dicethrow) {
        if (dicethrow == 7) {
            for(Player player : allPlayers) {
                handleDiceThrow7(player);
            }
        } else {
            Map<Faction,List<Resource>> returnMap= new HashMap<>();
            List<Point> diceValueFields = board.getFieldsForDiceValue(dicethrow);
            for (Player player : allPlayers) {
                returnMap.put(player.getFaction(), new ArrayList());
                for (Point field : diceValueFields) {
                    List<Resource> resources = board.getResourcesforFaction(field,player.getFaction());
                    for (Config.Resource resource : resources){
                        returnMap.get(player.getFaction()).add(resource);
                        addResourcesToPlayer(player, resource, 1);
                    }
                }
            }
            return returnMap;
        }
        return null;
    }

    public void handleDiceThrow7(Player player) {
        ArrayList<Config.Resource> resourceArrayList = new ArrayList<>();
        HashMap<Resource, Integer> resources = player.getResources();
        for(Config.Resource resource : resources.keySet()){
            for(int i = 0; i < resources.get(resource); i++) {
                resourceArrayList.add(resource);
            }
        }
        if(resourceArrayList.size() > 7){
            int resourcesToRemove =resourceArrayList.size() - (resourceArrayList.size() / 2);
            Random random = new Random();
            for(int i = 0; i < resourcesToRemove; i++){
                substractResourceFromPlayer(player, resourceArrayList.remove(random.nextInt(resourceArrayList.size())), 1);
            }
        }
    }



    /**
     * Builds a settlement at the specified position on the board.
     *
     * <p>The settlement can be built if:
     * <ul>
     * <li> the player possesses the required resource cards</li>
     * <li> a settlement to place on the board</li>
     * <li> the specified position meets the build rules for settlements</li>
     * </ul>
     *
     * @param position the position of the settlement
     * @return true, if the placement was successful
     */
    public boolean buildSettlement(Point position) {
        //1. Check if position is corner && is empty && neighbour Corners are empty
        if(!validPositionForSettlement(position)) {
            return false;
        }
        //2. Check if neighbourEdge are Roads belong to active Player
        if(!checkAdjacentEdgesList(position)) {
            return false;
        }
        //3. Can Player build Settlement
        if (!allPlayers.get(activePlayer).build(Config.Structure.SETTLEMENT)) {
            return false;
        }

        List<Config.Resource> costs = Config.Structure.SETTLEMENT.getCosts();
        for (Config.Resource resource : costs) {
            substractResourceFromPlayer(allPlayers.get(activePlayer), resource, 1);
        }

        //4. Insert Settlement to map
        board.setCorner(position, new Settlement(allPlayers.get(activePlayer).getFaction(),position));
        return true;
    }

    /**
     * Builds a city at the specified position on the board.
     *
     * <p>The city can be built if:
     * <ul>
     * <li> the player possesses the required resource cards</li>
     * <li> a city to place on the board</li>
     * <li> the specified position meets the build rules for cities</li>
     * </ul>
     *
     * @param position the position of the city
     * @return true, if the placement was successful
     */
    public boolean buildCity(Point position) {
        //1. Check if Corner.
        if (!board.hasCorner(position)){
            return false;
        }
        //2. Check if Settlement has already been built
        Settlement atCurrentPosition = board.getCorner(position);
        if (atCurrentPosition == null || atCurrentPosition instanceof City || atCurrentPosition.getFaction() != allPlayers.get(activePlayer).getFaction()){
            return false;
        }
        //3. Can player build a City.
        if(!allPlayers.get(activePlayer).build(Config.Structure.CITY)){
            return false;
        }

        List<Config.Resource> costs = Config.Structure.CITY.getCosts();
        for (Config.Resource resource : costs) {
            substractResourceFromPlayer(allPlayers.get(activePlayer), resource, 1);
        }

        //4.Insert City into the map.
        board.setCorner(position,new City(allPlayers.get(activePlayer).getFaction(),position));
        return true;

    }

    /**
     * Builds a road at the specified position on the board.
     *
     * <p>The road can be built if:
     * <ul>
     * <li> the player possesses the required resource cards</li>
     * <li> a road to place on the board</li>
     * <li> the specified position meets the build rules for roads</li>
     * </ul>
     *
     * @param roadStart the position of the start of the road
     * @param roadEnd   the position of the end of the road
     * @return true, if the placement was successful
     */
    public boolean buildRoad(Point roadStart, Point roadEnd) {
        //1. Check if is edge && is empty && if neighbour Edge or Corners belong to Settlement of active Player
        if (!validPositionForRoad(roadStart,roadEnd)){
            return false;
        }
        //2. Can Player build road
        if (!allPlayers.get(activePlayer).build(Config.Structure.ROAD)) {
            return false;
        }

        List<Config.Resource> costs = Config.Structure.ROAD.getCosts();
        for (Config.Resource resource : costs) {
            substractResourceFromPlayer(allPlayers.get(activePlayer), resource, 1);
        }

        //3. Insert Road to map
        board.setEdge(roadStart, roadEnd, new Road(allPlayers.get(activePlayer).getFaction(),roadStart,roadEnd));
        return true;
    }


    /**
     * Can be used for both initial Settlement and normal Phase.
     * @param roadStart
     * @param roadEnd
     * @return
     */
    private boolean validPositionForRoad(Point roadStart, Point roadEnd){
        //1. Check if Edge
        if (!board.hasEdge(roadStart, roadEnd)) {
            return false;
        }
        //2. Check if Edge is empty
        if (board.getEdge(roadStart, roadEnd) != null) {
            return false;
        }
        //3. Check if NeighbourEdge are Roads
        boolean hasNeighbourRoad = (checkAdjacentEdgesList(roadStart) || checkAdjacentEdgesList(roadEnd));
        if(hasNeighbourRoad) {
            return true;
        }
        //4.Check if roadStart or roadEnd is Settlement of current player
        if((board.getCorner(roadStart)!=null && board.getCorner(roadStart).getFaction() == allPlayers.get(activePlayer).getFaction())
        ||(board.getCorner(roadEnd)!=null && board.getCorner(roadEnd).getFaction() == allPlayers.get(activePlayer).getFaction())) {
            return true;
        }
        return false;
    }

    /**
     * Can be used for both initial Settlement and normal Phase.
     * @param position
     * @return
     */
    private boolean validPositionForSettlement(Point position){
        //1. Check if Corner
        if (!board.hasCorner(position)) {
            return false;
        }
        //2. Check if water
        if(checkIfWater(position)) {
            return false;
        }
        //3. Check if Corner is empty
        if(board.getCorner(position) != null) {
            return false;
        }
        //3. Check if neighbourCorners are empty
        if(!checkAdjacentCornerList(position)) {
            return false;
        }
        return true;
    }

    private boolean checkIfWater(Point point) {
        List<Config.Land> fields = board.getFields(point);
        for(Config.Land land : fields) {
            if(!land.equals(Config.Land.WATER)) {
                return false;
            }
        }
        return true;
    }

    /**
     * This method checks if there are Roads build by active Player on adjacent edges
     * @param point
     * @return
     */
    private boolean checkAdjacentEdgesList(Point point) {
        List<Road> results = board.getAdjacentEdges(point);
        for(int i = 0; i < results.size(); i++) {
            if(results.get(i).getFaction() == allPlayers.get(activePlayer).getFaction()) {
                return true;
            }
        }
        return false;
    }

    /**
     * Checks if Adjacent Corners are empty
     * @param point Corner to check
     * @return true if all Neighbour Corners are emtpy
     */
    private boolean checkAdjacentCornerList(Point point) {
        List<Settlement> results = board.getNeighboursOfCorner(point);
        if(results.size() > 0) {
            return false;
        }
        return true;
    }

    /**
     * Trades in {@link #FOUR_TO_ONE_TRADE_OFFER} resource cards of the
     * offered type for {@link #FOUR_TO_ONE_TRADE_WANT} resource cards of the wanted type.
     * <p>
     * The trade only works when bank and player possess the resource cards
     * for the trade before the trade is executed.
     *
     * @param offer offered type
     * @param want  wanted type
     * @return true, if the trade was successful
     */
    public boolean tradeWithBankFourToOne(Resource offer, Resource want) {
        Player player = allPlayers.get(activePlayer);
        if(player.getSpecificResource(offer) >= FOUR_TO_ONE_TRADE_OFFER && addResourcesToPlayer(player, want, FOUR_TO_ONE_TRADE_WANT)){
            substractResourceFromPlayer(player, offer, FOUR_TO_ONE_TRADE_OFFER);
            return true;
        }
        return false;
    }

    /**
     * Returns the winner of the game, if any.
     *
     * @return the winner of the game or null, if there is no winner (yet)
     */
        public Faction getWinner() {
            if(getCurrentPlayerWinpoints() >= winPointsForWin){
                return getCurrentPlayerFaction();
            }
            return null;
        }

        public int getCurrentPlayerWinpoints(){
            int winPoints = 0;
            List<Settlement> settlements = board.getCorners();
            for(Structure structure : settlements) {

                int newWinPoints = 0;
                if(structure instanceof City){
                    newWinPoints = 2;
                } else if(structure instanceof Settlement) {
                    newWinPoints = 1;
                }
                if(structure.getFaction() == getCurrentPlayerFaction()){
                    winPoints ++;
                }
            }
            if(getLongestRoadFaction() == getCurrentPlayerFaction()){
                winPoints += 2;
            }
            return winPoints;
        }


    /**
     * This method returns the faction of the player with the longest road longer than 5.
     * @return null if there is no player with a road longer than 5 otherwise it returns the faction of the specific player
     */
    private Faction getLongestRoadFaction() {
            List<Settlement> corners = board.getCorners();
            List<Config.Faction> factionList = getPlayerFactions();
            HashMap<Config.Faction,Integer> players = new HashMap<>();
            int highest = 0;
            Config.Faction longestRoad = null;
            for(Config.Faction faction : factionList) {
                int count = 0;
                players.put(faction,count);
                for(Settlement settlement : corners){
                    HashSet<Road> roads = new HashSet<>();
                    roads = countRoad(faction,settlement.getPosition(),roads,true);
                    count = roads.size();
                    int currentCount = players.get(faction);
                    if(count > currentCount) {
                        players.put(faction,count);
                    }
                }
            }
            for(Config.Faction faction : players.keySet()) {
                if(players.get(faction) >= 5 && players.get(faction)>highest) {
                    highest = players.get(faction);
                    longestRoad = faction;
                }
            }
            return longestRoad;
        }

    /**
     * This method is recursive and adds all roads which belongs to a specific players and stringing together to a HashSet.
     * The length of the HashSet represents the length of the longest Road the player has.
     * @param faction the faction of the player to check on
     * @param position there has to be a starting point to start counting. In this case it's a corner where a settlement belonging to the players faction is build on.
     * @param roads is the hashset with all roads belong to the player which are stringing together
     * @param add if true branches needs to be count together. (for example if it is the starting point(first time of counting)) otherwise the longest branch is beeing added to roads.
     * @return HashSet with all roads from a specific player which are string together.
     */
        private HashSet<Road> countRoad(Config.Faction faction,Point position,HashSet<Road> roads,boolean add) {
            List<Road> roadslist = board.getAdjacentEdges(position);
            if(board.getCorner(position) != null || board.getCorner(position).getFaction() != faction) {
                return roads;
            }

            Iterator it2 = roads.iterator();
            while(it2.hasNext()) {
                Road roadsroad = (Road) it2.next();
                Iterator it3 = roadslist.iterator();
                while (it3.hasNext()){
                    Road roadslistRoad = (Road) it3.next();
                    if(roadslistRoad == roadsroad || roadslistRoad.getFaction() != faction) {
                        it3.remove();
                    }
                }
            }


            if(roadslist.size() == 1) {
                roads.add(roadslist.get(0));
                position = getNextPoint(roadslist.get(0),position);
                roads = countRoad(faction,position,roads,false);
            }

            else if(roadslist.size() == 2) {
                HashSet<Road> listOne = (HashSet<Road>) roads.clone();
                HashSet<Road> listTwo = (HashSet<Road>) roads.clone();
                listOne.add(roadslist.get(0));
                Point positionOne = getNextPoint(roadslist.get(0),position);
                listTwo.add(roadslist.get(1));
                Point positionTwo = getNextPoint(roadslist.get(1),position);
                listOne = countRoad(faction,positionOne,listOne,false);
                listTwo = countRoad(faction,positionTwo,listTwo,false);
                if(add) {
                    for (Road road : listOne) {
                        listTwo.add(road);
                    }
                    roads = listTwo;
                }else {
                    HashSet<Road> tallest;
                    if(listOne.size()>= listTwo.size()) {
                        tallest = listOne;
                    }else{
                        tallest = listTwo;
                    }
                    for (Road road : tallest) {
                        roads.add(road);
                    }
                }

            }

            else if(roadslist.size() == 3) {
                HashSet<Road> listOne = (HashSet<Road>) roads.clone();
                HashSet<Road> listTwo = (HashSet<Road>) roads.clone();
                HashSet<Road> listThree = (HashSet<Road>) roads.clone();
                listOne.add(roadslist.get(0));
                Point positionOne = getNextPoint(roadslist.get(0),position);
                listTwo.add(roadslist.get(1));
                Point positionTwo = getNextPoint(roadslist.get(1),position);
                listThree.add(roadslist.get(2));
                Point positionThree = getNextPoint(roadslist.get(2),position);
                listOne = countRoad(faction,positionOne,listOne,false);
                listTwo = countRoad(faction,positionTwo,listTwo,false);
                listThree = countRoad(faction,positionThree,listThree,false);

                HashSet<Road> tallest;
                HashSet<Road> secondtallest;

                if(listOne.size()>=listTwo.size()) {
                    tallest = listOne;
                    secondtallest = listTwo;
                }else {
                    tallest = listTwo;
                    secondtallest = listOne;
                }if(listThree.size() >= secondtallest.size()) {
                    secondtallest = listThree;
                }
                for(Road road : secondtallest) {
                    tallest.add(road);
                }
                roads = tallest;
            }
            return roads;
        }

    /**
     * This method is beeing used to evaluate the next starting position to get the adjacent Roads from it.
     * @param road the next road to check on
     * @param position the current starting point
     * @return return the oposite point of the current point.
     */
    private Point getNextPoint(Road road,Point position) {
        Point start = road.getStart();
        Point end = road.getEnd();
        if(position.equals(start)) {
            position = end;
        }else {
            position = start;
        }
        return position;
    }

    /**
     * Places the thief on the specified field and steals a random resource card (if
     * the player has such cards) from a random player with a settlement at that
     * field (if there is a settlement) and adds it to the resource cards of the
     * current player.
     *
     * @param field the field on which to place the thief
     * @return false, if the specified field is not a field or the thief cannot be
     * placed there (e.g., on water)
     */
    public boolean placeThiefAndStealCard(Point field) {
        //TODO: Implement (or longest road functionality)
        return false;
    }

}