import os
os.chdir("/media/eleve/1B2E-2F4E/MPx/")
from piles import *
import random
import labyrinthe as laby


def copie(pile):
    els = Pile()
    out = Pile()
    while not pile.estPileVide():
        els.empiler(pile.depiler())
    while not els.estPileVide():
        x = els.depiler()
        out.empiler(x)
        pile.empiler(x)
        
    return out

Pile.copie = copie

"""
    Complexité temporelle, avec n la longueur de la pile: O(n)
    Complexité spaciale, avec n la taille de la pile: O(n)
"""

def miroir(pile):
    deca = pile.copie()
    out = Pile()
    while not deca.estPileVide():
        out.empiler(deca.depiler())
    return out
Pile.miroir = miroir
"""
 O(n)
 O(n)
"""

def taille(pile):
    deca = pile.copie()
    i = 0
    while not deca.estPileVide():
        i+=1
        deca.depiler()
    return i
Pile.taille = taille
"""
    O(n)
    O(n)
"""

def nth(pile,n):
    t = pile.taille()
    deca = pile.copie()
    i = 0
    while not deca.estPileVide():
        i+=1
        if i==t-n:
            return deca.depiler()
        deca.depiler()
    raise IndexError("La pile est trop petite !")

Pile.nth = nth
"""
    O(n)
    O(n)
"""

def degringoler(pile):
    if pile.estPileVide():
        raise IndexError("Mais ……… cette pile est vide !")
    x0 = pile.depiler()
    deca = Pile()
    while not pile.estPileVide():
        deca.empiler(pile.depiler())
    pile.empiler(x0)
    while not deca.estPileVide():
        pile.empiler(deca.depiler())

Pile.degringoler = degringoler
"""
    O(exp(42*n))                           non, bien sur, c'est du O(n)
    O(n)
"""

def toList(pile):
    deca = pile.copie()
    out=[]
    while not deca.estPileVide():
        out.append(deca.depiler())
    return out

Pile.toList = toList


print("----------------------------")
print("Essai de la (nouvelle) classe pile")
p = Pile()
p.empiler(1)
p.empiler(2)
print(p)
p.depiler()
print(p)
p.depiler()
print(p)
p.empiler('*')
p.empiler('p')
p.empiler('m')
print(p)
print(p.nth(0))
print(p.nth(1))
print(p.nth(2))
print(p.miroir())
p.empiler(1)
print(p)
print("----------------------------")



### Labyrinthes

def estValide(i,j,n,p):
    return (0<=i and i<n) and (0<=j and j<p)
    
def initList(n,p):
    out = []
    for _ in range(n):
        out.append(p*[False])
    return out
    
def initNList(n,p):
    out = []
    for _ in range(n):
        out.append(p*[None])
    return out
    
def voisins(case,n,p,dejaVu):
    i,j = case
    out = [(i-1,j),(i,j-1),(i,j+1),(i+1,j)]
    return [(i,j) for i,j in out if estValide(i,j,n,p) and not dejaVu[i][j]]

def choix(L):
    if(len(L)==0):
        raise IndexError("Un élément du vide ? Je propose néant mais vous n'allez pas aimer.")
    return L[random.randrange(len(L))]

def labyrinthe(n,p):
    dejaVu = initList(n,p)
    predecesseur  = initNList(n,p)
    pile = Pile()
    pile.empiler((0,0))
    segs = Pile()
    
    while not pile.estPileVide():
        caseCourante=pile.depiler()
        vz = voisins(caseCourante,n,p,dejaVu)
        if not len(vz)==0:
            nouvelleCase = choix(vz)
            (inn,jnn) = nouvelleCase
            dejaVu[inn][jnn] = True
            segs.empiler((caseCourante,nouvelleCase))
            predecesseur[inn][jnn] = caseCourante
            pile.empiler(caseCourante)
            pile.empiler(nouvelleCase)
            
    return segs.toList(),predecesseur
def plusCourtParfait(l,pdz,dest):
    path = Pile()
    pile.empile(out)
    whereami = dest
    while 
l,pdz = labyrinthe(100,100)

laby.affiche(l,100,100)