package arboles;

import listas.Lista;
import colas.*;

public class arbolGeneral<Elemento> implements Cloneable{

private Elemento raiz;
private Lista<arbolGeneral<Elemento>> hijos;

public arbolGeneral(){
this(null);//raiz=null
}

public arbolGeneral(Elemento ob){

raiz=ob;
hijos=new Lista<arbolGeneral<Elemento>>();
}

public arbolGeneral(Elemento ob, Lista<arbolGeneral<Elemento>> h){

this(ob);
if(raiz!=null && h!=null) hijos=h;
}

public boolean esVacio(){

return raiz==null;
}

public Elemento raiz(){

return raiz;
}

protected Lista<arbolGeneral<Elemento>> hijos(){//ojo las referencias son

las mismas
return hijos;
}

public Lista<Elemento> hijosOb(){

//son las raices nada mas
Lista<Elemento> hijos=new Lista<Elemento>();
if(!esVacio()){
Lista<arbolGeneral<Elemento>> aux=hijos();
while (!aux.esVacia()){
hijos.insertarFinal(aux.primero().raiz());
aux=aux.resto();
}
}
return hijos;
}

public void nuevoHijo(Elemento e){

if(esVacio()){
raiz=e;
hijos=new Lista<arbolGeneral<Elemento>>();
}
else nuevoHijo(new arbolGeneral<Elemento>(e));
}

public void nuevoHijo(arbolGeneral<Elemento> a){

if(a!=this && !a.esVacio()) hijos.insertarFinal(a);
}
 public arbolGeneral<Elemento> localiza(Elemento ob){
arbolGeneral<Elemento> loca=new arbolGeneral<Elemento>();
if (!esVacio()){
if (raiz().equals(ob)) loca=this;
else {
Lista<arbolGeneral<Elemento>> hijos=hijos();
while(!hijos.esVacia() && loca.esVacio()){
loca=hijos.primero().localiza(ob);
hijos=hijos.resto();
}
}
}
return loca;
}//localiza

public boolean pertenece(Elemento ob){

return !localiza(ob).esVacio();
}

public void eliminar(Elemento dato){

//elimina todas las apariciones de dato y sus ramas
if(!esVacio()){
if (raiz().equals(dato)){
raiz=null;
hijos=new Lista<arbolGeneral<Elemento>>();
}
else{
Lista<arbolGeneral<Elemento>> hijos=hijos();
while(hijosOb().posicion(dato)>0)
hijos.eliminaN(hijosOb().posicion(dato));
while(!hijos.esVacia()){
hijos.primero().eliminar(dato);
hijos=hijos.resto();
}
}
}
}

public arbolGeneral<Elemento> padre(Elemento ob){

arbolGeneral<Elemento> aux=new arbolGeneral<Elemento>();
if (!esVacio()){
if (hijosOb().pertenece(ob)) aux=this;
else{
Lista<arbolGeneral<Elemento>> hijos=hijos();
for (int n=1;n<=hijos.longitud() && aux.esVacio();n++)
aux=hijos.elementoN(n).padre(ob);
}
}
return aux;
}

@Override public String toString(){

return "\n"+toString(0);
}

public String toString(int espacios){

String linea="\n";
for (int e=0;e<=espacios;e++) linea=linea+" ";
if(esVacio()) linea=linea+"vacio";
else{
linea=linea+raiz().toString()+" "+getClass();
 Lista<arbolGeneral<Elemento>> hijos=hijos();
for (int n=1;n<=hijos.longitud();n++)
linea=linea+hijos.elementoN(n).toString(espacios+2);
}
return linea;
}

public int altura()throws Exception{

int i=0;
if (!esVacio()){
Lista<arbolGeneral<Elemento>> hijos=hijos();
for (int n=1;n<=hijos.longitud();n++)
i=Math.max(i,1+hijos.elementoN(n).altura());
}
return i;
}
public int profundidad(Elemento a){
//devuelve la profundidad de a con respecto a this. Es el nivel
int prof=-1;
if (!esVacio()){
if (raiz().equals(a)) prof=0;
else {
Lista<arbolGeneral<Elemento>> hijos=hijos();
while(prof<0 && !hijos.esVacia()){
prof=hijos.primero().profundidad(a);
if (prof!=-1) prof++;
hijos=hijos.resto();
}
}
}
return prof;
}

public int profundidad(arbolGeneral<Elemento> a){

int prof=-1;
if (!esVacio()){
if (this.equals(a)) prof=0;
else {
Lista<arbolGeneral<Elemento>> hijos=hijos();
while(prof<0 && !hijos.esVacia()){
prof=hijos.primero().profundidad(a);
if (prof!=-1) prof++;
hijos=hijos.resto();
}
}
}
return prof;
}
public boolean esHoja(){
return !esVacio() && hijos().esVacia();
}

@Override public boolean equals(Object a){

boolean iguales=false;
if (!iguales && a instanceof arbolGeneral){
arbolGeneral<Elemento> ag=(arbolGeneral<Elemento>)a;
if((esVacio() && ag.esVacio())||this==ag) iguales=true;
else//no hace falta controlar que uno es vacio y el otro no
if(!esVacio() && !ag.esVacio()) iguales=raiz().equals(ag.raiz())
&& hijos().equals(ag.hijos());
}
 return iguales;
}

public Lista<Elemento> recAnchura(){

Cola<arbolGeneral<Elemento>> ar=new
colaDinamica<arbolGeneral<Elemento>>();
Lista<Elemento> rec=new Lista<Elemento>();
if(!esVacio()){
ar.añadir(this);
while(!ar.esVacia()){
arbolGeneral<Elemento> p=ar.primero();
ar.quitar();
rec.insertarFinal(p.raiz());
Lista<arbolGeneral<Elemento>> hijos=p.hijos();
while(!hijos.esVacia()){
ar.añadir(hijos.primero());
hijos=hijos.resto();
}
}
}
return rec;
}

@Override public arbolGeneral<Elemento> clone()throws

CloneNotSupportedException{
arbolGeneral<Elemento> copia=new arbolGeneral<Elemento>();
if(!esVacio()){
copia=new arbolGeneral<Elemento>(raiz());
Lista<arbolGeneral<Elemento>> hijos=hijos();
while(!hijos.esVacia()){//mas profunda que
copia.hijos=hijos.clone()
copia.hijos().insertarFinal(hijos.primero().clone());
hijos=hijos.resto();
}
}
return copia;
}//clone
}//arbolGeneral