import java.util.*;

public enum PathFinderEnum implements PathFinderInterface {
    LEFT_HAND_TRAFFIC,
    RIGHT_HAND_TRAFFIC;

    private int [][]map;

    private Vector<Vector<Position>> positionsMap;

    enum ModeHack{
        easiestModeHack,
        fastModeHack,
        shortModeHack
    }

    enum Direction{
        left,
        right,
        straight
    }

    ModeHack modeHack;

    @Override
    public void setMap(int[][] map) {
        this.map = map;
        this.positionsMap = stupidArrayToObjectArray(map);
    }

    private  Vector<Vector<Position>>  stupidArrayToObjectArray(int [][]map){
        int x=0;
        int y=0;
        Vector<Vector<Position>> positions = new Vector<>();
        for (int[] m:map) {
            positions.add(x, new Vector<>());
            for (int w: m) {
                var p = new Position(x,y);
                if (w != 0)  {
                    p.setCost(w);
                }
                else p.setBlocked(true);
                positions.get(x).add(y, p);
                y++;
            }
            x++;
            y = 0;
        }

        return positions;
    }



    private PositionInterface[] ownResultToStupidOResult(Position start, Position end){
        Vector<Position> result = new Vector<>();
        Position next = end;
        while(next != null){
            result.add(next);
            next = next.getVisitedFromPosition();
        }
        Collections.reverse(result);

        return result.toArray(new PositionInterface[]{});

    }

    @Override
    public PositionInterface[] getFastestRoute(PositionInterface begin, PositionInterface end) {
        modeHack = ModeHack.fastModeHack;
        dijkstra(stupidOPointToOwnObject(begin), stupidOPointToOwnObject(end));
        return ownResultToStupidOResult(stupidOPointToOwnObject(begin), stupidOPointToOwnObject(end));
    }

    @Override
    public PositionInterface[] getShortestRoute(PositionInterface begin, PositionInterface end) {
        modeHack = ModeHack.shortModeHack;
        dijkstra(stupidOPointToOwnObject(begin), stupidOPointToOwnObject(end));
        return ownResultToStupidOResult(stupidOPointToOwnObject(begin), stupidOPointToOwnObject(end));
    }

    @Override
    public PositionInterface[] getEasiestRoute(PositionInterface begin, PositionInterface end) {
        modeHack = ModeHack.easiestModeHack;
        dijkstra(stupidOPointToOwnObject(begin), stupidOPointToOwnObject(end));
        return ownResultToStupidOResult(stupidOPointToOwnObject(begin), stupidOPointToOwnObject(end));
    }


    private Position stupidOPointToOwnObject(PositionInterface positionInterface){
        return positionsMap.get(positionInterface.getCol()).get((positionInterface.getRow()));
    }


    /// TO można przerzucic do osobna klasy tylko od dijkstry
    private List<DQueen> queen = new ArrayList<>();
    private boolean dijkstra(Position begin, Position end){
        begin.setTotalCost(begin.getCost());
        queen.add(new DQueen(begin, null));
        while (!queen.isEmpty()){
            var q = queen.get(0);
            var currentPosition = q.position;
            if (currentPosition.getTotalCost() > 1000 || currentPosition.getTotalCost() < 0){
                throw new InternalError();
            }
            queen.remove(0);
            if(currentPosition.isVisited()) continue;
            currentPosition.setVisited(true);
            q.position.setVisitedFromPosition(q.visitedFrom);
            if (currentPosition == end){
                queen.clear();
                return true;
            }
            checkAllDirection(currentPosition);
        }
        return false;
    }

    private void checkAllDirection(Position position){
        addToQueen(getUp(position),position);
        addToQueen(getDown(position),position);
        addToQueen(getLeft(position),position);
        addToQueen(getRight(position),position);
    }

    private void calculateTotalCostFast(Position position, Position prv) {
        int totalCost = 0;
        if (prv != null) {
            totalCost += prv.getTotalCost();
        }
        if (this.name().equals("LEFT_HAND_TRAFFIC")){
            if (checkDirection(position,prv) == Direction.right){
                totalCost += 1;
            }
        }
        if (this.name().equals("RIGHT_HAND_TRAFFIC")){
            if (checkDirection(position,prv) == Direction.left){
                totalCost += 2;
            }
            if (checkDirection(position,prv) == Direction.right){
                totalCost += 1;
            }
        }
        totalCost += position.getCost();
        position.setTotalCost(totalCost);
    }

    private void calculateTotalCostEasy(Position position, Position prv) {
        int totalCost = 0;
        if (prv != null) {
            totalCost += prv.getTotalCost();

        }
        position.setTotalCost(totalCost);
    }

    private void calculateTotalCostShort(Position position, Position prv) {
        int totalCost = 0;
        if (prv != null) {
            totalCost += prv.getTotalCost();
        }
        totalCost += 1;
        position.setTotalCost(totalCost);
    }

    private Direction checkDirection(Position position, Position prv){
        if(position.getVisitedFromPosition() != null && position.getVisitedFromPosition().getVisitedFromPosition() != null)
            prv = position.getVisitedFromPosition().getVisitedFromPosition();
        if (prv.getY() == position.getY() || position.getX() == prv.getX()){
            return Direction.straight;
        }

        if (position.getX() < prv.getX() ||  position.getY() < prv.getY()){
            return Direction.left;
        }
        else return Direction.right;

    }


    private void addToQueen(Position position, Position visitedFrom){
        if (position == null) return;
        if (position.isBlocked()) return;
        switch (modeHack){
            case fastModeHack:
                calculateTotalCostFast(position, visitedFrom);
                break;
            case shortModeHack:
                calculateTotalCostEasy(position, visitedFrom);
                break;
            case easiestModeHack:
                calculateTotalCostShort(position, visitedFrom);
        }
        queen.add(new DQueen(position, visitedFrom));
        queen.sort(Comparator.comparingInt(DQueen::getTotalCost));
    }

    private Boolean testIsExist(int x, int y){
        try {
            var test = this.map[x][y];
        }
        catch (ArrayIndexOutOfBoundsException e){
            return false;
        }
        return true;
    }

    private Position getUp(Position position){
        int x = position.getX();
        int y = position.getY() + 1;
        if (testIsExist(x, y))
            return positionsMap.get(x).get((y));
        else return null;
    }

    private Position getDown(Position position){
        int x = position.getX();
        int y = position.getY() - 1;
        if (testIsExist(x, y))
            return positionsMap.get(x).get((y));
        else return null;
    }

    private Position getLeft(Position position){
        int x = position.getX() -1;
        int y = position.getY();
        if (testIsExist(x, y))
            return positionsMap.get(x).get((y));
        else return null;
    }

    private Position getRight(Position position){
        int x = position.getX() + 1;
        int y = position.getY();
        if (testIsExist(x, y))
            return positionsMap.get(x).get((y));
        else return null;
    }

    ///DO tego miejsca
}