from flask import Flask, redirect, render_template, Response, request
from flask_limiter import Limiter
from flask_limiter.util import get_remote_address
from sqlite3 import *
from uuid import uuid4
from time import sleep

from maze import Maze

app = Flask(__name__)
limiter = Limiter(
    get_remote_address,
    app=app,
    storage_uri="memory://",
)

MAZE_SIZE = 35   
       
def initDb():
    con = connect("/tmp/mazes.db")
    cur = con.cursor()
    cur.execute('''
        CREATE TABLE IF NOT EXISTS mazes(
            id TEXT PRIMARY KEY, 
            maze TEXT NOT NULL,
            row INTEGER NOT NULL DEFAULT 0,
            col INTEGER NOT NULL DEFAULT 0,
            up BOOL NOT NULL DEFAULT False,
            down BOOL NOT NULL DEFAULT True,
            left BOOL NOT NULL DEFAULT False,
            right BOOL NOT NULL DEFAULT True
            )
    ''')
    con.commit()
    cur.close()
    con.close()     
                
def createMaze():
    mazeId = str(uuid4())
    maze = Maze(2, MAZE_SIZE)

    con = connect("/tmp/mazes.db")
    cur = con.cursor()
    cur.execute('''
        INSERT INTO mazes (id, maze)
        VALUES (?, ?)
    ''', (mazeId, str(maze).strip()))
    con.commit()
    cur.close()
    con.close()
    return mazeId

def getLoc(mazeId):
    con = connect("/tmp/mazes.db")
    cur = con.cursor()
    ret = cur.execute("SELECT row, col FROM mazes WHERE id = ?", (mazeId,)).fetchone()
    cur.close()
    con.close()
    return ret

...

@app.route("/", defaults={"mazeId": None})
@app.route("/<mazeId>")
def index(mazeId):
    if not mazeId:
        return redirect(f"/{createMaze()}")
    solved=getLoc(mazeId) == (MAZE_SIZE-1, MAZE_SIZE-1)
    return render_template("maze.html", 
        maze=getMaze(mazeId), 
        mazeId=mazeId,
        flag=open("flag.txt").read() if solved else ""
    )
      
...

initDb()
if __name__ == "__main__":
    app.run(host='0.0.0.0', port=7000)

class Maze:
    ...

    def gen(self): 
        ...

        self.set(*([0]*self.dim), val='@')
        for i in self.neighbors(*([0]*self.dim)):
            self.set(*i, val='.')

        self.set(*([self.size-1]*self.dim), val='F')
        for i in self.neighbors(*([self.size-1]*self.dim)):
            self.set(*i, val='#')

def getMaze(mazeId):
    con = connect("/tmp/mazes.db")
    cur = con.cursor()
    ret = cur.execute("SELECT maze FROM mazes WHERE id = ?", (mazeId,)).fetchone()[0]
    cur.close()
    con.close()
    return ret

def getLoc(mazeId):
    con = connect("/tmp/mazes.db")
    cur = con.cursor()
    ret = cur.execute("SELECT row, col FROM mazes WHERE id = ?", (mazeId,)).fetchone()
    cur.close()
    con.close()
    return ret

def getCanMove(mazeId):
    con = connect("/tmp/mazes.db")
    cur = con.cursor()
    ret = cur.execute("SELECT up, down, left, right FROM mazes WHERE id = ?", (mazeId,)).fetchone()
    cur.close()
    con.close()
    return ret

def writeMaze(mazeId, maze):
    con = connect("/tmp/mazes.db")
    cur = con.cursor()
    cur.execute('''
        UPDATE mazes SET maze = ? WHERE id = ?
    ''', (maze, mazeId))
    con.commit()
    cur.close()
    con.close()

def writeLoc(mazeId, loc):
    con = connect("/tmp/mazes.db")
    cur = con.cursor()
    cur.execute('''
        UPDATE mazes SET row = ?, col = ? WHERE id = ?
    ''', (*loc, mazeId))
    con.commit()
    cur.close()
    con.close()

def writeCanMove(mazeId, canMove):
    con = connect("/tmp/mazes.db")
    cur = con.cursor()
    cur.execute('''
        UPDATE mazes SET up = ?, down = ?, left = ?, right = ? WHERE id = ?
    ''', (*canMove, mazeId))
    con.commit()
    cur.close()
    con.close()

def bound(n, mn=0, mx=MAZE_SIZE):
    return max(min(n, mx), mn)

def inn(n, mn = 0, mx = MAZE_SIZE):
    return mn <= n < mx 

@app.route("/move", methods=["POST"])
def move():
    mazeId = request.args["id"]
    moveStr = request.args["move"]

    canMove = getCanMove(mazeId)
    validMoves = ["up", "down", "left", "right"]
    moveIdx = None
    if moveStr in validMoves:
        moveIdx = validMoves.index(moveStr)
    validMovesDict = {"up": (-1, 0), "down": (1, 0), "left": (0, -1), "right": (0, 1)}
    move = validMovesDict.get(moveStr, None)
    if not move or moveIdx is None or not canMove[moveIdx]:
        return redirect(f"/{mazeId}")

    currentLoc = getLoc(mazeId)
    newLoc = [bound(currentLoc[0] + move[0]), bound(currentLoc[1] + move[1])]

    writeLoc(mazeId, newLoc)

    mazeStr = getMaze(mazeId)
    maze = [[c for c in row] for row in mazeStr.splitlines()]
    maze[currentLoc[0]][currentLoc[1]] = '.'
    maze[newLoc[0]][newLoc[1]] = '@'
    writeMaze(mazeId, '\n'.join(''.join(row) for row in maze))

    newCanMove = []
    for dr, dc in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
        checkLoc = [newLoc[0] + dr, newLoc[1] + dc]
        newCanMove.append(
            inn(checkLoc[0]) and inn(checkLoc[1])
            and maze[checkLoc[0]][checkLoc[1]] != '#'
        )
    writeCanMove(mazeId, newCanMove)

    return redirect(f"/{mazeId}")

if not move or moveIdx is None or not canMove[moveIdx]:
    return redirect(f"/{mazeId}")

import requests
import copy 
from collections import deque

MAZE_SIZE = 35
visited = [[0] * MAZE_SIZE for _ in range(MAZE_SIZE)]

dx = [-1, 0, 1, 0]
dy = [ 0, 1, 0,-1]
dir = [ 'L', 'D', 'R', 'U']
curr_y, curr_x = 0, 1 

id = "fbb96d75-3d61-471f-9233-c63548c1b743"
url = f"http://the-amazing-race.chal.imaginaryctf.org"
# url = f"http://localhost:7000"

def move(path): 
    # path.append("D")
    # path.append("R")
    dr = {"L": "left", "D": "down", "R": "right", "U": "up"}
    for x in path:
        r = requests.post(
            f"{url}/move?id={id}&move={dr[x]}", 
        )
        # print(r.status_code)
        # print(r.text) 
        assert r.status_code == 200
    print("Done")
    r = requests.get(
        f"{url}/{id}"
    )
    print(r.text)

r = requests.get(
    f"{url}/{id}"
)

maze = r.text[ r.text.find("<code>")+7 : r.text.find("</code>")-1 ]
mat = [[] for _ in range(MAZE_SIZE)]
i = 0
for j in range(len(maze)):
    if maze[j] == "\n": 
        i = i + 1
        continue
    mat[i].append(maze[j])
maze = mat 

for i in range(len(mat)): 
    for j in range(len(mat[i])): 
        print(mat[i][j], end='')
    print()
    

d = deque([[0, 0, []]])
visited[0][0] = 1

while len(d) != 0: 
    curr = d.popleft() 
    curr_y, curr_x, path = curr[0], curr[1], curr[2]

    if curr_y == MAZE_SIZE - 2 and curr_x == MAZE_SIZE - 2: 
        print(path)
        move(path) 
        break 

    for k in range(4): 
        next_y = curr_y + dy[k]
        next_x = curr_x + dx[k] 

        if next_x < 0 or next_y < 0 or next_y >= MAZE_SIZE - 1 or next_x >= MAZE_SIZE - 1: continue 
        if visited[next_y][next_x] or maze[next_y][next_x] == '#': continue 
        visited[next_y][next_x] = 1
        new_path = copy.deepcopy(path) 
        new_path.append(dir[k])
        d.append([next_y, next_x, new_path])

for i in range(len(mat)): 
    for j in range(len(mat[i])): 
        print(visited[i][j], end='')
    print()