from copy import deepcopy


class MazeSolver:

    def __init__(self):
        self._maze_rows = []
        self._maze_parameters = []
        self._start = None
        self._stop = None
        self._flipped_maze = []
        self._x = 0
        self._y = 0
        return

    def __repr__(self):
        return 'Maze size: {0}, Maze start: {1}, Maze stop: {2}'.format(self._maze_parameters, self._start, self._stop)

    def print_maze(self):
        for row in self._maze_rows:
            print(''.join(row))
        return

    def populate_data(self, user_input):
        self._user_input = user_input

        if self._user_input == '':
            self._user_input = 'maze'
        try:
            f = open(self._user_input)

        except IOError as e:
            print(e)
            self._user_input = str(input("Please enter the maze file name:"))

        with open(self._user_input, 'r') as f:

            # Populate parameters, start and stop points
            line = f.readline()
            values = line.strip('\n').split()
            self._maze_parameters = (int(values[0]), int(values[1]))

            line = f.readline()
            values = line.strip('\n').split()
            self._start = (int(values[0]), int(values[1]))

            line = f.readline()
            values = line.strip('\n').split()
            self._stop = (int(values[0]), int(values[1]))

            # Populate maze data
            for line in f:
                line.strip()
                self._maze_rows.append(list(line.strip('\n')))

        return

    def process_rows(self, rows):
        self._rows = rows
        self._processed_rows = deepcopy(self._rows)

        for row in self._processed_rows:
            for i in range(len(row)):
                if (row[i] in "+|-"):
                    row[i] = 1
                elif (row[i] == ' '):
                    row[i] = 0

        return self._processed_rows

    def set_start_stop(self):
        self._flipped_maze = self.flip(self._processed_rows)
        for column in range(len(self._flipped_maze)):
            for row in range(len(self._flipped_maze[0])):
                if column == self._start[0] and row == self._start[1]:
                    self._flipped_maze[row][column] = 8
                if column == self._stop[0] and row == self._stop[1]:
                    self._flipped_maze[row][column] = 9

        return self._flipped_maze

    def flip(self, lst):
        flipped_lst = []
        for i in range(-1, -len(lst) - 1, -1):
            flipped_lst.append(lst[i])
        for lst in flipped_lst:
            lst.reverse()

        return flipped_lst

    def move(self, x, y):
        global FoundWayOut

        width = len(self._processed_rows)
        height = len(self._processed_rows[0])
        if FoundWayOut:
            return

        if (x < 0 or x > width - 1 or y < 0 or y > height - 1):
            print('Out of bounds');
            return
        if (self._processed_rows[x][y] == 9):
            FoundWayOut = True
            print('Got it!');
            return
        if (self._processed_rows[x][y] == 1):
            print('That is wall');
            return
        if (self._processed_rows[x][y] == 2):
            print('Was here before');
            return
        self._processed_rows[x][y] = 2

        self.move(x + 1, y)  # East
        self.move(x, y + 1)  # South
        self.move(x - 1, y)  # West
        self.move(x, y - 1)  # North

    def main(self):
        user_input = str(input("Please enter the maze file name:"))
        self.populate_data(user_input)
        processed_rows = self.process_rows(self._maze_rows)
        # print(self)
        self.set_start_stop()
        # for row in processed_rows:
        # print(row)
        # print()
        for row in reversed(self._flipped_maze):
            print(row)
        # for row in processed_rows:
        # print(row)
        # self.move(0,0)
        # if(FoundWayOut == True):
        # print("Solved!")
        # else:
        # print("Not solved")


a = MazeSolver()
a.main()
# print(a)
# a.print_maze()
# num of rows * 2 + 1 ||||||