package ch.zhaw.catan;

import ch.zhaw.catan.Config.Land;
import ch.zhaw.hexboard.HexBoard;
import ch.zhaw.hexboard.Label;

import java.awt.Point;
import java.util.*;
//TODO Enhance JavaDoc
/**
 * Subclass of HexBoard
 * Saves the fields which are set and handles Methods with specific Dice Numbers.
 */
public class SiedlerBoard extends HexBoard<Land, Settlement, Road, String> {

    /**
     * HashMap to save all Fields which are set yet.
     * Key: Point with coordinates of the field
     * //TODO Enhance JavaDoc
     * Value: Field Object
     */
    HashMap<Point, Field> fields = new HashMap<>();

    /**
     * Method to create the predefined gamefield from Config.
     */
    public void createFixGamefield(){
        Map<Point,Land> resourcePlacement = Config.getStandardLandPlacement();
        Map<Point, Integer> dicePlacement = Config.getStandardDiceNumberPlacement();
        for (Map.Entry<Point,Land> resourceField : resourcePlacement.entrySet()) {
            addField(resourceField.getKey(),resourceField.getValue());
            if(dicePlacement.get(resourceField.getKey()) != null){
                String numberAsString = dicePlacement.get(resourceField.getKey()).toString();
                char[] numbersInChar = numberAsString.toCharArray();
                if (numberAsString.length() < 2) {
                    fields.put(resourceField.getKey(), new Field(resourceField.getValue(), new Label('0', numbersInChar[0])));
                }
                else {
                    fields.put(resourceField.getKey(), new Field(resourceField.getValue(), new Label(numbersInChar[0],numbersInChar[1])));
                }
            }
        }
    }

    /**
     * Method to get the DiceNumber of a specific field.
     * @param field Point with coordinates of the specific field
     * @return the DiceNumber of the field.
     */
    private int getDiceNumber(Point field) {
        Label label = fields.get(field).getLabel();
        return Integer.parseInt(label.toString());
    }

    /**
     * Method to create a SiedlerBoardTextView Object set the LowerFieldLabels with theirs Dicenumber.
     * It is used to print the actual board in TextIO.
     * @return String of actual board.
     */
    public String getTextView () {
        SiedlerBoardTextView view = new SiedlerBoardTextView(this);
        for (Map.Entry<Point, Field> field : fields.entrySet()) {
            view.setLowerFieldLabel(field.getKey(), field.getValue().getLabel());
        }
        return view.toString();
    }

    /**
     * Returns the fields associated with the specified dice value.
     *
     * @param dice the dice value
     * @return the fields associated with the dice value
     */
    public List<Point> getFieldsForDiceValue(int dice) {
        ArrayList<Point> fields = new ArrayList<>();
        for(Point field : this.fields.keySet()){
            if(getDiceNumber(field) == dice){
               fields.add(field);
            }
        }
        return fields;
    }

    /**
     * Method to get the Resources which are paid to a specific faction for a specific field.
     *
     * @param point The Point with the Coordinates of the field, which should pay resources.
     * @param faction The faction, which should get paid.
     * @return a ArrayList with all resources, which will be paid to the specified faction.
     */
    public ArrayList<Config.Resource> getResourcesForFaction(Point point, Config.Faction faction){
        List <Settlement> possibleSettlementField = super.getCornersOfField(point);
        ArrayList<Config.Resource> resourcesToPlayer = new ArrayList<>();
        for (Settlement settlement : possibleSettlementField) {
            if (settlement.getFaction() == faction) {
                resourcesToPlayer.add(fields.get(point).getResource());
                if (settlement instanceof City) {
                    resourcesToPlayer.add(fields.get(point).getResource());
                }
            }
        }
        return resourcesToPlayer;
    }

    /**
     * Returns the {@link Land}s adjacent to the specified corner.
     *
     * @param corner the corner
     * @return the list with the adjacent {@link Land}s
     */
    public List<Land> getLandsForCorner(Point corner) {
        Point above = new Point(corner.x, corner.y + 2);
        Point below = new Point(corner.x, corner.y -2);
        Land[] lands = new Land[3];
        if (hasField(above)) {
            lands[0] = getField(above);
            lands[1] = getField(new Point(corner.x + 1, corner.y - 1));
            lands[2] = getField(new Point(corner.x - 1, corner.y - 1));
        }
        else if (hasField(below)) {
            lands[0] = getField(below);
            lands[1] = getField(new Point(corner.x + 1, corner.y + 1));
            lands[2] = getField(new Point(corner.x - 1, corner.y + 1));
        }
        else {
            return Collections.emptyList();
        }
        return List.of(lands);
    }

    /**
     * This method checks for the player with the longest road according to the catan game rules.
     * @return a HashMap<Faction,Integer> where faction is the player with the longest road longer according to catan game rules
     * and the Integer representing the length of the road
     */
    public void getLongestRoadFaction(HashMap<Config.Faction,Integer> currentLongestRoad,List<Config.Faction> factionList) {
        List<Settlement> corners = getCorners();
        HashMap<Config.Faction,Integer> players = new HashMap<>();

        for(Config.Faction faction : factionList) {
            int count = 0;
            players.put(faction,count);
            for(Settlement settlement : corners){
                if(settlement.getFaction() == faction){
                    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);
                    }
                }
            }
        }

        if(currentLongestRoad.size() == 0) {
            Config.Faction currentFaction = null;
            int currentRoad = 4;
            for(Config.Faction factionA : players.keySet()) {
                if(players.get(factionA)>currentRoad) {
                    currentFaction = factionA;
                    currentRoad = players.get(factionA);
                }
            }
            if(currentFaction != null){
                currentLongestRoad.put(currentFaction,currentRoad);
            }
        }else{
            for(Config.Faction faction : players.keySet()) {
                for(Config.Faction faction1 : currentLongestRoad.keySet()) {
                    if(players.get(faction) >= 5 && players.get(faction) > currentLongestRoad.get(faction1)) {
                        currentLongestRoad.remove(faction1);
                        currentLongestRoad.put(faction,players.get(faction));
                    }
                }
            }
        }
    }

    /**
     * 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 = getAdjacentEdges(position);
        if(getCorner(position) != null && getCorner(position).getFaction() != faction) {
            return roads;
        }

        Iterator<Road> it2 = roads.iterator();
        while(it2.hasNext()) {
            Road roadsroad = it2.next();
            Iterator<Road> it3 = roadslist.iterator();
            while (it3.hasNext()){
                Road roadslistRoad = 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;
    }
}