-- Dada una posición y un desplazamiento , devuevle una nueva posición
movInstantaneo :: Posicion -> Desplazamiento -> Posicion
movInstantaneo (x,y) Arriba = (x-1 , y)
movInstantaneo (x,y) Abajo = (x+1 , y)
movInstantaneo (x,y) Derecha = (x , y+1)
movInstantaneo (x,y) Izquierda = (x , y-1)


-- Determina si un camino se mantiene dentro de los limites del tablero a lo largo de su trayectoria, asumiendo que comenzara por la posicion (1,1)
caminoValidodesde :: Tablero a -> Camino -> Posicion -> Bool
caminoValidodesde _ [] _ = True
caminoValidodesde t (x:xs) p | posValida t (movInstantaneo p x) = caminoValidodesde t xs (movInstantaneo p x)
                             | otherwise = False

caminoValido :: Tablero a -> Camino -> Bool
caminoValido t c = caminoValidodesde t c (1,1)

-- Asumiendo que tenemos un camino valido, determina si comenzando en (1,1), al seguir el camino dado, llega a la pos (n,n) sin pisar ninguna mina
-- Notemos que si llegamos al (n,n) pero todavía hay mas para recorrer, el programa no termina aún.
caminoDesalidaDesde :: CampoMinado -> Camino -> Posicion -> Bool
caminoDesalidaDesde cm [] (a, b) | a == tamano cm && b == tamano cm = True
                                 | otherwise = False
caminoDesalidaDesde cm (x:xs) p | valor (cm) p = False
                                | otherwise = caminoDesalidaDesde cm xs (movInstantaneo p x)

-- Verifico que el Camino sea valido
-- Corremos el caminodesalidaDesde el (1,1)
caminoDeSalida :: CampoMinado -> Camino -> Bool
caminoDeSalida cm c | not (caminoValido cm c) = False
                    | otherwise = caminoDesalidaDesde cm c (1,1)

-- Dada una lista de Posiciones devuelve True si hay dos Posiciones repetidas
hayRepetidos :: [Posicion] -> Bool
hayRepetidos [] = False
hayRepetidos (x:xs) | elem x xs = True
                    | otherwise = hayRepetidos xs

-- Dado un Camino devuelve una lista de las Posiciones que recorre
convertirDesde :: Posicion -> Camino -> [Posicion]
convertirDesde p [] = [p]
convertirDesde p (x:xs) = p : (convertirDesde (movInstantaneo p x) xs)

convertir :: Camino -> [Posicion]
convertir c = convertirDesde (1,1) c

--Determina si un RAE, comenzando en la posición (1, 1), al seguir el camino dado, llega a la posición
--(n, n) sin pisar ninguna mina y sin pasar dos veces por una misma posición.

caminoDeSalidaSinRep :: CampoMinado -> Camino -> Bool
caminoDeSalidaSinRep cm c | hayRepetidos (convertir c) = False
                          | otherwise = caminoDeSalida cm c

recorrido :: TableroAF -> Posicion -> [Posicion]
recorrido t p | not (posValida t p) = []
              | otherwise = p : recorrido t (movInstantaneo p (valor t p))

-- Dado un tablero y una posicion p, determina si al colocar un AF en p, el AF escapará del tablero o entrará en un loop infinito
escapaDelTableroaux :: TableroAF -> Posicion -> [Posicion] -> Bool
escapaDelTableroaux t p l | not (posValida t p) = True
                          | hayRepetidos l = False
                          | otherwise = escapaDelTableroaux t (movInstantaneo p (valor t p)) (p:l)

escapaDelTablero :: TableroAF -> Posicion -> Bool
escapaDelTablero t p = escapaDelTableroaux t p []