import estructura
#----------------------------------------------------------------------------
#------------------------------ P1 ------------------------------------------
#----------------------------------------------------------------------------
#persona: str str int bool
estructura.crear("persona", "nombre apellido edad permitido")

#personaM: str str int bool
estructura.mutable("personaM", "nombre apellido edad permitido")

#ejemplos de personas. (contigo Pipo)
pipo= persona("pipo","gonzales",18,False)
pipo2= personaM("pipo","gonzales",18,False)

#nuevoaño: persona -> persona
#suma uno a la edad de la persona
#ejemplo: nuevoaño(pipo) entrega persona("pipo","gonzales",19,False)
def nuevoaño(per):
    nueva= persona(per.nombre,per.apellido,per.edad+1,
                   per.permitido)
    return nueva
assert nuevoaño(pipo) == persona("pipo","gonzales",19,False)

#NuevoAño: persona -> None
#suma una edad a la persona
#ejemplo, si le sumamos a pipo2 la edad, tendrá un año mas
def NuevoAño(personam):
    personam.edad +=1

#test
pepe = personaM("pipo","gonzales",18,False)
NuevoAño(pepe)
assert pepe.edad == 19


#actualizar: persona, int, str -> persona
#actualiza a una persona de acuerdo a los datos
#ejemplo: actualizar(pipo,12,"gomez") entrega persona("pipo","gonzales",18,True)
def actualizar(per,eda,apell):
    if eda < per.edad or per.apellido == apell:
        return persona(per.nombre,per.apellido,per.edad,True)
    else:
        return persona(per.nombre,per.apellido,per.edad,False)

assert actualizar(pipo,12,"gomez") == persona("pipo","gonzales",18,True)


#Actualizar: persona, int, str -> None
#actualiza a una persona de acuerdo a los datos
#ejemplo: al hacer Actualizar(pipo2, 12,"gomez") pipo2.permitido será True
def Actualizar(personam,eda,apell):
    if eda < personam.edad or personam.apellido == apell:
        personam.permitido = True

pepe = personaM("pipo","gonzales",18,False)
Actualizar(pepe,12,"aa")
assert pepe.permitido == True
    
#----------------------------------------------------------------------------
#------------------------------ P2 ------------------------------------------
#----------------------------------------------------------------------------
#listamutable: valor (str,bool,num), sgte(lista,None)
estructura.mutable("listaM","valor sgte")

L = listaM(12, listaM(-1, listaM(8, listaM(4, listaM(-3, listaM(4, None))))))

def largo(L):
    if L == None:
        return 0
    else:
        return 1+largo(L.sgte)


#posicionIndice: listaM,int -> listaM
#entrega la lista en la posición i-esima
#ejemplo: posicionIndice(L,2) entrega
#listaM(8, listaM(4, listaM(-3, listaM(4, None))))
def posicionIndice(L,i):
    if i == 0:
        return L
    else:
        return posicionIndice(L.sgte,i-1)
assert posicionIndice(L,2) == listaM(8, listaM(4, listaM(-3, listaM(4, None))))

#intercambio: ListaM, int, int -> None
#intercambia los indices i y j de la lista L
#ejemplo: intercambio(L,0,1) convierte L a
#listaM(-1, listaM(12, listaM(8, listaM(4, listaM(-3, listaM(4, None))))))
def intercambio(L,i,j):
    aux1=posicionIndice(L,i)
    aux2=posicionIndice(L,j)
    val= aux1.valor
    aux1.valor = aux2.valor
    aux2.valor = val

L2 = listaM(12, listaM(-1, listaM(8, listaM(4, listaM(-3, listaM(4, None))))))
intercambio(L2,0,1)
assert L2 == listaM(-1, listaM(12, listaM(8, listaM(4, listaM(-3, listaM(4, None))))))


#menor: L -> int
#entrega el indice del menor valor de una lista
#ejemplo menor(L) entrega 4
def IndiceMenor(L,i = 0, im=0):
    if i == largo(L):
        return im
    #obtenemos valor actual y valor del menor
    actual=posicionIndice(L,i)
    menor=posicionIndice(L,im)
    #actualizamos im solo si el nuevo valor es menor
    if actual.valor < menor.valor:
        return IndiceMenor(L,i+1,i)
    else:
        return IndiceMenor(L,i+1,im)
assert IndiceMenor(L) == 4


#ordenar: L -> None
#ordena L de manera creciente
#ejemplo: ordenar(L) entrega...
#listaM(-3, listaM(-1, listaM(4, listaM(4, listaM(8, listaM(12, None))))))
def ordenar(lista):
    if lista == None:
        return None
    indice_menor= IndiceMenor(lista)
    intercambio(lista,0,indice_menor)
    return ordenar(lista.sgte)

ordenar(L2)
assert L2 == listaM(-3, listaM(-1, listaM(4, listaM(4, listaM(8, listaM(12, None))))))
    
#----------------------------------------------------------------------------
#------------------------------ P3 ------------------------------------------
#----------------------------------------------------------------------------

#arbol: valor(num, str, bool), izq(arbol, None), der(arbol, none)
estructura.mutable("arbol","valor izq der")

Tarea1=arbol("tarea1",None,None)
Tarea2=arbol("tarea2",None,None)
Tareas=arbol("tareas",Tarea1,Tarea2)
lista = arbol("lista.py",None,None)
U = arbol("U",lista,Tareas)
Osu=arbol("Osu",None,None)
Deemo=arbol("Deemo",None,None)
Lol=arbol("Lol",None,None)
Ritmicos=arbol("juegos ritmicos",Deemo,Osu)
juegos=arbol("juegos",Lol,Ritmicos)
escritorio=arbol("escritorio",juegos,U)

#renombrar: arbo, str,str -> None
#renombra un elemento en un arbol
#ejemplo, renombrar(escritorio,Osu,circulitos) cambiaria el nombrem de osu
def renombrar(a,nom,nuev):
    if a == None:
        return None
    elif a.valor == nom:
        a.valor = nuev
    else:
        renombrar(a.izq,nom,nuev)
        renombrar(a.der,nom,nuev)

renombrar(Tareas,"tarea1","tesoro")
assert Tarea1.valor == "tesoro"

#eliminar: arbol, srt -> None
#elimina los hijos de a
#por ejemplo, eliminar(U,"tareas") eliminaria las tareas
def eliminar(Arbol,a):
    if Arbol == None:
        return None
    elif Arbol.valor == a:
        Arbol.izq = None
        Arbol.der = None
    else:
        eliminar(Arbol.izq,a)
        eliminar(Arbol.der,a)
eliminar(U,"tareas")
assert Tareas.izq == None and Tareas.der == None