import records.Move;

import java.util.HashSet;
import java.util.LinkedList;
import java.util.Queue;

public class SnakeBot extends Bot {
    protected final static String obstacles = "~#X*";
    protected final static char target = '@';
    protected boolean offByOne = true;
    protected int currentStepCount = 0;
    protected int steps = 0;

    public static void main(String[] args) {
        if (args.length == 0) {
            String[] dummyArgs = {"localhost", "63187"};
            for (int i = 0; i < 5; i++) {
                new Thread(new SnakeBot(dummyArgs)).start();
            }
        }

        Bot bot = new SnakeBot(args);
        bot.run();
    }

    protected SnakeBot(String[] args) {
        super(args);
    }

    @Override
    protected char nextMove(View view) {
        System.out.println();
        String data = view.data
                .replace('^', '*')
                .replace('<', '*')
                .replace('>', '*')
                .replace('v', '*');
        char[][] grid = dataToGrid(data, view.width);

        if (data.contains("@")) {
            return breadthFirstSearch(grid);
        } else {
            return walkAround(grid);
        }
    }

    protected char[][] dataToGrid(String data, int size) {
        char[][] grid = new char[size][size];
        for (int i = 0; i < data.length(); i++) {
            grid[i % size][i / size] = data.charAt(i);
        }
        return grid;
    }

    protected char walkAround(char[][] grid) {
        if (steps == 0) {
            currentStepCount++;
            if (offByOne) {
                currentStepCount++;
            }
            offByOne = !offByOne;
            steps = currentStepCount;
            return '>';
        } else {
            steps--;
            return safeMove(grid);
        }
    }

    protected char safeMove(char[][] grid) {
        int size = grid.length;
        if (grid[size / 2][size / 2 - 1] == '*') {
            return safeTurn(grid);
        } else {
            return '^';
        }
    }

    protected char safeTurn(char[][] grid) {
        int size = grid.length;

        int leftStars = 0;
        int rightStars = 0;
        for (int x = 0; x < size / 2; x++) {
            for (int y = 0; y < size; y++) {
                if (grid[x][y] == '*') leftStars++;
                if (grid[size - x - 1][y] == '*') rightStars++;
            }
        }

        if (leftStars > rightStars) {
            return '>';
        } else {
            return '<';
        }
    }

    protected char breadthFirstSearch(char[][] grid) {
        int size = grid.length;
        int start = size / 2;

        boolean[][] visited = new boolean[size][size];
        Queue<Move> queue = new LinkedList<>();

        int[][] directions = {{0, -1}, {0, 1}, {1, 0}, {-1, 0}};
        char[] commands = {'^', '>', '>', '<'};
        for (int i = 0; i < 4; i++) {
            queue.add(new Move(start + directions[i][0], start + directions[i][1], commands[i]));
        }

        while (!queue.isEmpty()) {
            Move move = queue.poll();
            if (move.x() < 0 || move.x() >= size || move.y() < 0 || move.y() >= size || visited[move.x()][move.y()]) continue;
            visited[move.x()][move.y()] = true;
            if (obstacles.contains("" + grid[move.x()][move.y()])) continue;
            if (grid[move.x()][move.y()] == target) return move.direction();

            for (int[] direction : directions) {
                queue.add(new Move(move.x() + direction[0], move.y() + direction[1], move.direction()));
            }
        }

        System.err.println("No path found");
        return safeMove(grid);
    }

}