package projectv1a;

import java.util.Vector;

/**
 *
 * Clase CommunicationInterface
 *
 * Contiene toda la funcionalidad de la herramienta. Esta clase permite que la
 * funcionalidad de IKAT se pueda utilizar bien desde la interfaz gráfica o bien
 * desde otra herramienta.
 *
 * Class Specialization
 * A type generalization
 * B type generalization
 * New class superclass relation
 * Remove class superclass relation
 * Change precedence order
 * Change superclass
 * A type Class Removal
 * B type Class Removal
 * C type Class Removal
 */

public class CommunicationInterface {

    private OntologyLibrary ontologyLibrary;
    private CurrentOntologies currentOntologies;
    
    // atributo que será clave en la base de datos
    private int identity;
    
    private boolean found; // para saber si algo se ha encontrado o no
    private Vector instanceList;
    private InstanceList iL;
    
    private Vector instances;
    private ClassSpecification c;
    
    //  DATOS MIEMBRO PARA -A TYPE GENERALIZATION-
    private Vector classes;
    private AttributeSpecification  at;
    
    //  DATOS MIEMBRO PARA -NEW CLASS-SUPERCLASS RELATION-
    private OntologyManager oM;
    private KBManager kbM;
    private ClassSpecification root;
    private ClassSpecification tmpClass;
    
    ///////////// CONSTRUCTORES /////////////
    public CommunicationInterface() {
    }
    public CommunicationInterface(OntologyLibrary oL, CurrentOntologies cO) {
        ontologyLibrary = oL;
        currentOntologies = cO;
    }
    /////////////////////////////////////////
    
    
    public void setId(int i){
        identity = i;
    }
    public int getId(){
        return identity;
    }
    public void setOL(OntologyLibrary o){
        ontologyLibrary = o;
    }
    public OntologyLibrary getOL(){
        return ontologyLibrary;
    }
    public void setCO(CurrentOntologies o){
        currentOntologies = o;
    }
    public CurrentOntologies getCO(){
        return currentOntologies;
    }
    
    /**
     * classSpecialization
     * 
     * @param className -   Vector con objetos de tipo String, con el nombre de las nuevas subclases
     * @param criterion -   Vector con objetos de tipo Criterion
     * @param c         -   La clase que vamos a especializar
     */
    public void classSpecialization(Vector className, Vector criterion, ClassSpecification c){
        // c debe ser una clase hoja, lo comprobamos antes de iniciar ninguna operación
        if(!c.leafClass()){
            System.out.println("The class that you have choose to specializate is not a leaf class. Aborting the operation.");
        } else {
            //Creamos el vector en el que almacenaremos las instaceList de las especializaciones antes de introducirlas en la Ontología
            instanceList = new Vector(className.size());
            // Buscamos la InstanceList de la clase c
            found = false;
            iL = currentOntologies.searchIL(c);
            
            for(int i=0; i<className.size(); i++){
                // introducimos en el vector la primera clase dentro de un objeto de tipo InstanceList
                instanceList.add(new InstanceList(new ClassSpecification((String)className.get(i))));
                // Añadimos c a las superclases de la nueva clase
                ((InstanceList)instanceList.get(i)).getClassSpecification().addSuperClass(c);
                // La nueva clase será subclase de c
                c.addSubClass(((InstanceList)instanceList.get(i)).getClassSpecification());
            }
            iL.specializationOperations(criterion);
            
            
            // Hay que eliminar las instancias de c, debe quedar como una clase abstracta
            iL.setAbstract();// La ponemos como abstracta
        }
    }
    /**
     * aTypeGeneralization
     * 
     * @param classList     -   Vector que contiene las clases a generalizar
     * @param className     -   Nombre de la nueva clase
     */
    public void aTypeGeneralization(Vector classList, String className){
        // Vector para almacenar las InstanceList
        classes = new Vector();
        for (int i=0; i<classList.size(); i++){
            classes.add(currentOntologies.searchIL((ClassSpecification)classList.get(i)));
        }// Ya tenemos en el vector classes todas las InstanceList de las clases a generalizar
        
        // Tenemos que asegurarnos que comparten, al menos, una superclase
               
        if (!ClassSpecification.brotherClasses(classList)) System.out.println("The classes must have, at least, a common ancestor.");
        else{
            // Ya sabemos que comparten una superclase como mínimo
            ClassSpecification newClass = new ClassSpecification(className);
            newClass.makeSuperclassesA(classList);
            newClass.makeSubclassesA(classList);
            
            // Antes de continuar buscamos los atributos que tendrá la nueva clase(los comunes)
            newClass.attributesToClassGeneralization(classes);
            
            // Hay que asignar las instancias de las clases generalizadas a la nueva clase
            // pero tenemos que quitar a esas instancias los atributos no comunes.
            // También hay que quitar los atributos de las hijas de newClass(en toda la
            // jerarquía), siempre y cuando no se redefinan en las subclases.
            
            // Ahora tenemos que borrar los atributos no comunes de las instancias de las clases generalizadas
            newClass.removeNonCommonAttributes(classes, currentOntologies);
            
            // Ahora tenemos que buscar todas las instancias que tendrá newClass
            instances = InstanceList.addInstancesTo(newClass, classes); // Este vector será luego el vector de instanceList para la clase newClass
            // Tenemos en el vector instances todas las instancias que tendrá newClass
            // Procedemos a insertar esta nueva InstanceList en la base de conocimiento
            // Para ello nos ayudamos de la variable kbM que contiene desde el principio
            // del método la KBManager en la que estamos trabajando.
            currentOntologies.getKBM().getKBVersion().getKB().addInstanceList(new InstanceList(newClass, instances));
            // TAMBIEN TENDRÍAMOS QUE INSERTAR LA CLASE EN LA ONTOLOGIA para esto nos
            // ayudamos de la variable oM que contiene desde el comienzo del método
            // la ontología en la que estamos trabajando
            currentOntologies.getOM().getOntologyVersion().getOntology().addClass(newClass);
            
            // Ahora hay que eliminar las clases que hemos generalizado en newClass,
            // contenidas en el vector classes.
            for (int i=0; i<classes.size(); i++){
                currentOntologies.getOM().getOntologyVersion().getOntology().deleteClass((ClassSpecification)((InstanceList)classes.get(i)).getClassSpecification());
            }
            
            // Ahora hay que eliminar las InstanceList  de las clases que hemos
            // generalizado en newClass, contenidas en el vector classes.
            for (int i=0; i<classes.size(); i++){
                currentOntologies.getKBM().getKBVersion().getKB().deleteInstanceList((InstanceList)classes.get(i));
            }
        }
    } // Así ya debería estar acabada Atype Generalization salvo por la ausencia de confirmación para el borrado de atributos
    /**
     * b Type Generalization
     * 
     * @param classList Vector con objetos de tipo ClassSpecification, son las clases a generalizar
     * @param className String con el nombre de la clase que vamos a crear
     */
    public void bTypeGeneralization(Vector classList, String className){
        // Vector para almacenar las InstanceList
        classes = new Vector();
        for (int i=0; i<classList.size(); i++){
            classes.add(currentOntologies.searchIL((ClassSpecification)classList.get(i)));
        }// Ya tenemos en el vector classes todas las InstanceList de las clases a generalizar
        
        // Tenemos que asegurarnos que comparten, al menos, una superclase
        if (!ClassSpecification.brotherClasses(classList)) System.out.println("The classes must have, at least, a common ancestor.");
        else{
            // Ya sabemos que comparten una superclase como mínimo
            ClassSpecification newClass = new ClassSpecification(className);
            // Tenemos la clase nueva creada con el nombre indicado.
            // Ahora hay que indiciarle las superclases.
            newClass.setAsSuperclassOf(classes);
            // Hacemos que la clase sea abstracta
            newClass.setRole(true);
            
            // Antes de continuar buscamos los atributos que tendrá la nueva clase, que serán los comunes
            newClass.attributesToClassGeneralization(classes);
            
            // La clase nueva ya tiene los atributos comunes, ahora tenemos que quitarlos de las clases generalizadas
            for (int i=0; i<newClass.getAttribute().size(); i++){
                at = (AttributeSpecification)newClass.getAttribute().get(i);
                for (int k=0; k<classes.size(); k++){
                    ((InstanceList)classes.get(k)).getClassSpecification().deleteAttribute(at);
                }
            }
        }
    }
    /**
     * newClassSuperclassRelation(ClassSpecification superC, ClassSpecification subC)
     * 
     * Añade a la ontología y a la base de conocimiento una nueva relación clase-superclase
     * entre dos clases ya existentes.
     * Se ayuda de los metodos "addAttributes" y "searchInstances".
     */
    public void newClassSuperclassRelation(ClassSpecification superC, ClassSpecification subC){
        superC.addSubClass(subC);  // La clase sc a partir de ahora tiene como subclase a la clase c
        subC.addSuperClass(superC);// La clase c a partir de ahora tiene como superclase a la clase sc

        // Tenemos que buscar la InstanceList en la que se encuentra 'c' para aplicar los cambios a sus instancias
        found = false;
        searchInstances(superC, subC);
        // Ya hemos introducido en las instancias de subC( y en las subclases de subC y en...) los atributos de sc
    }
    /**
     * addAttributes(ClassSpecification sc, ClassSpecification c)
     * 
     * Se trata de un metodo de apoyo para simplificar el trabajo de NewClassSuperclassRelation, 
     * aunque en realidad es invocado por searchInstances.
     * Se encarga de añadir a cada instancia los atributos de su nueva superClase.
     */
    private void addAttributes(ClassSpecification sc, ClassSpecification c){
        found = false; // Añadido posterior
        for(int i=0; i<currentOntologies.getCurrentOntologies().size() && !found; i++){
            oM = (OntologyManager)currentOntologies.getCurrentOntologies().get(i);
            for(int k=0; k<oM.getCurrentKBs().getManagedKBs().size() && !found; k++){
                kbM = (KBManager)oM.getCurrentKBs().getManagedKBs().get(k);
                for(int m=0; m<kbM.getKBVersion().getKB().getInstanceList().size() && !found; m++){
                    iL = (InstanceList)kbM.getKBVersion().getKB().getInstanceList().get(m);
                    if(iL.getClassSpecification().equals(c)){
                        found = true;
                    }
                }
            }
        }// Tenemos la variable iL que almacena la InstanceList en la que esta c(o la clase que estamos buscando actualmente)
        // Ahora solo hay que instancias tendrán los atributos de sc.
        // Hay que tener en cuanta que las instancias de las subclasses de c tb tendrán los atributos de sc.
        for(int i=0; i<sc.getAttribute().size(); i++){
            at = (AttributeSpecification)sc.getAttribute().get(i);
            for(int k=0; k<iL.getInstanceList().size(); k++){
                found = false;
                if(at.getMulti()){
                    for (int l=0; l<((InstanceSpecification)iL.getInstanceList().get(k)).getMSVS().size() && !found; l++){
                    // Este for recorre el vector de atributos de  para ver si son los de las instancias
                        if (((MultiSlotValueSpecification)((InstanceSpecification)iL.getInstanceList().get(k)).getMSVS().get(l)).getAttribute().getName().equals(at.getName())){
                            found = true;
                        }
                    }
                    if (!found)
                    // Convertimos at en MultiSlotSpecification para meterlo en la lista de atributos multivaluados de la instancia k
                    ((InstanceSpecification)iL.getInstanceList().get(k)).addMSVS(new MultiSlotValueSpecification((MultiSlotSpecification)at));
                } else {
                    for (int l=0; l<((InstanceSpecification)iL.getInstanceList().get(k)).getSVS().size() && !found; l++){
                    // Este for recorre el vector de atributos de  para ver si son los de las instancias
                        if (((SlotValueSpecification)((InstanceSpecification)iL.getInstanceList().get(k)).getSVS().get(l)).getAttribute().getName().equals(at.getName())){
                            found = true;
                        }
                    }
                    if (!found)
                    // Convertimos at en SlotSpecification para meterlo en la lista de atributos simples de la instancia k
                    ((InstanceSpecification)iL.getInstanceList().get(k)).addSVS(new SlotValueSpecification((SlotSpecification)at));
                }
            }
        }
    }
    /**
     * searchInstances(ClassSpecification sc, ClassSpecification c)
     * 
     * Es un método recursivo, ya que es la forma más eficiente de ejecutar el 
     * método addAttributes para todas las instancias de clases descendientes a
     * a subC.
     * 
     * El parametro "sc" representa a superC, es decir, a la superclase nueva.
     * El parametro "c" representa a subC en la primera ejecución pero en
     * posteriores ejecuciónes irá tomando el valor de la clase a cuyas instancias
     * les estamos añadiendo los atributos de superC.
     */
    private void searchInstances(ClassSpecification sc, ClassSpecification c){
        addAttributes(sc, c);
        for(int i=0; i<c.getSubClasses().size(); i++){
                searchInstances(sc, (ClassSpecification)c.getSubClasses().get(i));
        }
    }
    /**
     * removeClassSuperclassRelation
     * 
     * Esta funcionalidad elimina una relación de clase-superclase entre dos objetos
     * de tipo ClassSpecification. Se dan distintas situaciones que tenemos que
     * controlar, como por ejemplo la existencia o no de multiples superclases de
     * esa subclase sobre la que vamos a operar.
     */
    public void removeClassSuperclassRelation(ClassSpecification superc, ClassSpecification subc){
        if(subc.getSuperClasses().size() > 1){// tiene varias superclases
            // Borramos de las clases superc y subc que estan relacionadas.
            subc.deleteSuperclass(superc);
            superc.deleteSubclass(subc);
            // Hay que buscar las instancias de subc y sus descendientes para eliminar de ellas los atributos de superc.
            searchInstancesDelete(superc, subc);
        } else {
            if (superc.getSuperClasses().isEmpty()){// La superclase es la raiz. No permitimos la operación.
                System.out.println("It is not allowed to remove this relation, excepting the root class, the rest must have a superclass");
            } else { // Necesitamos confirmación para continuar
                // La clase tiene una única superclase, al ser eliminada esa relación su superclase será la raiz.
                // Hay que buscar en la ontología aquella clase que no tenga superclases(La raiz)
                iL = currentOntologies.searchIL(c);
                // Dentro de currentOntologies, en oM tenemos almacenada la ontología en la que están las clases con las que trabajamos.
                root = currentOntologies.getRoot();
                // Añadimos la clase root a las superclases de subc
                subc.addSuperClass(root);
                // Añadimos la clase subc a las subclases de root
                root.addSubClass(subc);
                // Ahora hay que quitar los atributos de superc de las instancias de subc
                // haremos lo propio con las superclases de superc a excepción de root.
                // Lo más adecuado es ayudarnos de un método recursivo.
                deleteAttributesFromSCs(superc, subc);
            }
        }
    }
    /**
     * searchInstancesDelete(ClassSpecification sc, ClassSpecification c)
     * 
     * Es un método recursivo, ya que es la forma más eficiente de ejecutar el 
     * método deleteAttributes para todas las instancias de clases descendientes a
     * a subC.
     * 
     * Funciona de forma analoga a searchInstances porque tambien llama al un 
     * metodo, en este caso deleteAttributes pero a su vez este funciona igual
     * que el metodo addAttributes. 
     * 
     * El parametro "sc" representa a superC, es decir, a la superclase nueva.
     * El parametro "c" representa a subC en la primera ejecución pero en
     * posteriores ejecuciónes irá tomando el valor de la clase a cuyas instancias
     * les estamos eliminando los atributos de superC.
     */
    private void searchInstancesDelete(ClassSpecification sc, ClassSpecification c){
        deleteAttributes(sc, c);
        if(!c.getSubClasses().isEmpty()){
            for(int i=0; i<c.getSubClasses().size(); i++){
                searchInstancesDelete(sc, (ClassSpecification)c.getSubClasses().get(i));
            }
        }
    }
    /**
     * deleteAttributes(ClassSpecification sc, ClassSpecification c)
     * 
     * Se trata de un metodo de apoyo para simplificar el trabajo de RemoveClassSuperclassRelation, 
     * aunque en realidad es invocado por searchInstances.
     * Se encarga de eliminar de cada instancia los atributos de sc.
     */
    private void deleteAttributes(ClassSpecification sc, ClassSpecification c){
        for(int i=0; i<currentOntologies.getCurrentOntologies().size() && !found; i++){
            oM = (OntologyManager)currentOntologies.getCurrentOntologies().get(i);
            for(int k=0; k<oM.getCurrentKBs().getManagedKBs().size() && !found; k++){
                kbM = (KBManager)oM.getCurrentKBs().getManagedKBs().get(k);
                for(int m=0; m<kbM.getKBVersion().getKB().getInstanceList().size() && !found; m++){
                    iL = (InstanceList)kbM.getKBVersion().getKB().getInstanceList().get(m);
                    if(iL.getClassSpecification().equals(c)){
                        found = true;
                    }
                }
            }
        }// Tenemos la variable iL que almacena la InstanceList en la que esta c(o la clase que estamos buscando actualmente)
        // Ahora solo hay que instancias tienen los atributos de sc.
        // Hay que tener en cuanta que las instancias de las subclasses de c tb tienen los atributos de sc.
        for(int i=0; i<sc.getAttribute().size(); i++){
            at = (AttributeSpecification)sc.getAttribute().get(i);
            for(int k=0; k<iL.getInstanceList().size(); k++){
                found = true;
                if(at.getMulti()){
                    // Si el atributo está redefinido en c no tendremos que eliminarlo
                    for (int l=0; l<c.getAttribute().size() && !found; l++){
                    // Este for recorre el vector de atributos de  para ver si son los de las instancias
                        if (((AttributeSpecification)c.getAttribute().get(l)).getName().equals(at.getName())){
                            found = true;
                        }
                    }
                    if (!found)
                    // Convertimos at en MultiSlotSpecification para meterlo en la lista de atributos multivaluados de la instancia k
                    ((InstanceSpecification)iL.getInstanceList().get(k)).deleteMSVS((MultiSlotSpecification)at);
                } else {
                    for (int l=0; l<c.getAttribute().size() && !found; l++){
                    // Este for recorre el vector de atributos de  para ver si son los de las instancias
                        if (((AttributeSpecification)c.getAttribute().get(l)).getName().equals(at.getName())){
                            found = true;
                        }
                    }
                    if (!found)
                    // Convertimos at en SlotSpecification para meterlo en la lista de atributos simples de la instancia k
                    ((InstanceSpecification)iL.getInstanceList().get(k)).deleteSVS((SlotSpecification)at);
                }
            }
        }
    }
    /**
     * deleteAttributesFromSCs(ClassSpecification sc, ClassSpecification c)
     * 
     * Se trata de una extensión de searchInstancesDelete, al igual que este, es
     * un método recursivo, ya que es la forma más eficiente de ejecutar el
     * método deleteAttributes para todas las instancias de clases descendientes
     * a subC. 
     * 
     * La extensión del método consiste en que esta recursividad también afecte
     * a las superclases de superc, consiguiendo que los atributos de todos los
     * ancestros de subc(excepto de root, logicamente) sean eliminados de subc y
     * de sus subclases.
     */
    private void deleteAttributesFromSCs(ClassSpecification superc, ClassSpecification subc){
        deleteAttributes(superc, subc);
        if(!subc.getSubClasses().isEmpty()){
            for(int i=0; i<subc.getSubClasses().size(); i++){
                searchInstancesDelete(superc, (ClassSpecification)c.getSubClasses().get(i));
            }
        }
        for(int i=0; i<superc.getSuperClasses().size(); i++){
            if ((ClassSpecification)superc.getSuperClasses().get(i) != root){
                deleteAttributesFromSCs((ClassSpecification)superc.getSuperClasses().get(i),subc);
            }
        }
    }
    /**
     * changePrecedenceOrder
     * 
     * El orden de precedencia determina de que superclase hereda un atributo si
     * este está define en más de uno.
     * 
     * El orden de precedencia viene indicado en el orden en el que están las
     * superclases en la lista de superclases. La primera en el vector será la
     * de mayor precedencía
     */
    public void changePrecedenceOrder(ClassSpecification c, ClassSpecification firstClass){
        if(c.getSuperClasses().contains(firstClass)){
            c.getSuperClasses().remove(firstClass);
            c.getSuperClasses().insertElementAt(firstClass, 0);
        } else {
            System.out.println("The class "+firstClass.getName()+" is not a superclass of "+c.getName());
        }
        // Hay que propagar este cambio hacía abajo
        // Lo mejor será un método recursivo que baje niveles buscando una nueva definición en c(o en las subclases de c)
        // de los atributos heredados de firstClass.
        for(int i=0; i<firstClass.getAttribute().size(); i++){
            searchRedefineAttribute(c, (AttributeSpecification)firstClass.getAttribute().get(i));
        }
    }
    /**
     * searchRedefineAttribute(ClassSpecification c, AttributeSpecification a)
     * 
     * Método para redefinir en cascada un atributo, este mismo método se encarga
     * de ver si tiene o no tiene que hacerlo en función de si está definido
     * también en alguna subclase.
     * 
     * Le pasamos como parámetros c y a, buscamos el atributo a en la clase c y
     * si no está seguimos buscando en sus subclases, así sucesivamente.
     * 
     * Es utilizado en el método changePrecedenceOrder.
     * También lo llama el método de apollo reAddAttribute.
     */
    private void searchRedefineAttribute(ClassSpecification c, AttributeSpecification a){
        found = false;
        for(int i=0; i<c.getAttribute().size() && !found; i++){
            if(((AttributeSpecification)c.getAttribute().get(i)).getName().equals(a.getName())){
                found = true;
            }
        }
        if(!found){// Esto significa que ese atributo no se ha encontrado y hay que heredarlo y seguir buscandolo
            //iL = currentOntologies.searchIL(c);
            for(int n=0; n<currentOntologies.getCurrentOntologies().size() && !found; n++){
                oM = (OntologyManager)currentOntologies.getCurrentOntologies().get(n);
                for(int k=0; k<oM.getCurrentKBs().getManagedKBs().size() && !found; k++){
                    kbM = (KBManager)oM.getCurrentKBs().getManagedKBs().get(k);
                    for(int m=0; m<kbM.getKBVersion().getKB().getInstanceList().size() && !found; m++){
                        iL = (InstanceList)kbM.getKBVersion().getKB().getInstanceList().get(m);
                        if(iL.getClassSpecification().equals(c)){
                            found = true;
                        }
                    }
                }
            }// Como siempre en iL la InstanceList que nos interesa
            // Recorremos todas las instancias de c porque tenemos que borrar el atributo 
            // a de todas las instancias de c.

            // Hay que ver si es multivaluado o no
            for(int k=0; k<iL.getInstanceList().size(); k++){
                if(a.getMulti()){
                    for(int m=0; m<((InstanceSpecification)iL.getInstanceList().get(k)).getMSVS().size(); m++){
                        if(((MultiSlotValueSpecification)((InstanceSpecification)iL.getInstanceList().get(k)).getMSVS().get(m)).
                                getAttribute().getName().equals(a.getName())){
                            // Eliminamos el atributo que se encuentra en la posición m, xq es el mismo que él que añadiremos
                            ((InstanceSpecification)iL.getInstanceList().get(k)).deleteMSVS(m);
                            // Añadimos el atributo con los "valores" de firstClass
                            ((InstanceSpecification)iL.getInstanceList().get(k)).addMSVS(new MultiSlotValueSpecification((MultiSlotSpecification)a));
                        }
                    }
                } else { // No es un atributo multivaluado
                    for(int m=0; m<((InstanceSpecification)iL.getInstanceList().get(k)).getSVS().size(); m++){
                        if(((SlotValueSpecification)((InstanceSpecification)iL.getInstanceList().get(k)).getSVS().get(m)).
                                getAttribute().getName().equals(a.getName())){
                            // Eliminamos el atributo que se encuentra en la posición m, xq es el mismo que él que añadiremos
                            ((InstanceSpecification)iL.getInstanceList().get(k)).deleteSVS(m);
                            // Añadimos el atributo con los "valores" de firstClass
                            ((InstanceSpecification)iL.getInstanceList().get(k)).addSVS(new SlotValueSpecification((SlotSpecification)a));
                        }
                    }
                }
            }
            // Ahora necesitamos ejecutamos un método recursivo que continue la búsqueda de
            // este atributo a través de la jerarquía y en sentido descendente
            for(int i=0; i<c.getSubClasses().size(); i++){
                searchRedefineAttribute((ClassSpecification) c.getSubClasses().get(i), a);
            }
        }
    }
    /**
     * ChangeSuperclass
     * 
     * En realidad no se trata más que de añadir una nueva relación superclase y
     * eliminar otra, lo que ya hemos hecho en métodos anteriores pero ahora los 
     * dos seguidos.
     * 
     * superc representa una superclase de subc, relación que queremos eliminar,
     * mientras que la relación a añadir es entre subc y newSuperc.
     */
    public void changeSuperclass(ClassSpecification superc, ClassSpecification subc, ClassSpecification newSuperc){
        // En primer lugar ejecutamos el método removeClassSuperclassRelation
        removeClassSuperclassRelation(superc, subc);
        // Ahora añadimos la nueva relación con el método newClassSuperclassRelation
        newClassSuperclassRelation(subc, newSuperc);
    }
    /**
     * public void aTypeClassRemoval(ClassSpecification c)
     * 
     * Con este metodo al borrar una clase lo que ocurre es que sus subclases quedarán directamente
     * relacionadas con las superclases de la clase borrada.
     */
    public void aTypeClassRemoval(ClassSpecification c){
        for(int i=0; i<c.getSubClasses().size(); i++){
            tmpClass = (ClassSpecification)c.getSubClasses().get(i);
            tmpClass.deleteSuperclass(c);
            for (int k=0; k<c.getSuperClasses().size(); k++){
                tmpClass.addSuperClass((ClassSpecification)c.getSuperClasses().get(k));
                ((ClassSpecification)c.getSuperClasses().get(k)).addSubClass(tmpClass);
            }
        }
        for (int i=0; i<c.getSuperClasses().size(); i++){
            ((ClassSpecification)c.getSuperClasses().get(i)).deleteSubclass(c);
            
        }
        // Ya hemos asignado a las subclases de c las superclases de c y viceversa
        // Ahora hay que eliminar de las instancias de las subclasses de c los atributos de c
        // Como hasta ahora un método recursivo nos ayudará.
        reAddAttributes(c);
        // Hay que eliminar a clase c: poner a null... y ese tipo de cosas
        oM.getOntologyVersion().getOntology().deleteClass(c); // Lo eliminamos de la ontología
        /**
         * AKI TENEMOS QUE BUSCAR EL "INSTANCE_LIST" CUANDO SE MODIFIQUE DEL UML
         */
        kbM.getKBVersion().getKB().deleteInstanceList(iL); // Lo eliminamos de la Base de Conocimiento
    }
    /**
     * reAddAttributes(ClassSpecification c)
     * 
     * Este método aprovecha el método searchRedefineAttributes.
     * Lo primero que hace es subir de forma recursiva hasta el nivel más alto
     * de la jerarquía, una vez ahí ejecuta clase por clase y nivel por nivel
     * el método searchRedefineAttribute para que vaya atributo por atributo 
     * eliminandolo y creandolo de nuevo.
     */
    private void reAddAttributes(ClassSpecification c){
        for(int i=0; i<c.getSuperClasses().size(); i++){
            // Lo ejecutamos de forma inversa, es decir, primero las últimas superclases de la lista
            // para respetar el orden de precedencia
            reAddAttributes((ClassSpecification)c.getSuperClasses().get(c.getSuperClasses().size() - (i+1)));
        }
        for(int k=0; k<c.getAttribute().size(); k++){
            for(int m=0; m< c.getSubClasses().size(); m++){
                searchRedefineAttribute((ClassSpecification)c.getSubClasses().get(m), (AttributeSpecification)c.getAttribute().get(k));
            }
        }
    }
    /**
     * public void bTypeClassRemoval(ClassSpecification c, ClassSpecification brotherClass)
     * 
     * Al borrar una clase, esas clases serán "adoptadas" por una clase hermana de la clase eliminada.
     * La clase hermana deberá elegirla el usuario.
     */
    public void bTypeClassRemoval(ClassSpecification c, ClassSpecification brotherClass){
        // Los primero es comprobar que realmente son hermanas
        if(c.brotherClass(brotherClass)){
            // Las subclases de c serán a partir de ahora subclases de brotherClass
            //for(int i=0; i<c.getSubClasses().size() && !found; i++){
            //    ((ClassSpecification)c.getSubClasses().get(i)).addSuperClass(brotherClass);
            //}
            // Ahora Ejecutamos un método para eliminar los atributos de c y de las
            // superclases de c en las subclases y añadir como superclase de las hijas
            // de c la clase brotherClass. Que mejor método que uno ya implementado.
            // Se trata del método changeSuperClass
            for(int i=0; i<c.getSubClasses().size() && !found; i++){
                changeSuperclass(c, (ClassSpecification)c.getSubClasses().get(i), brotherClass);
            }
            // Buscamos la clase en cuestión
            found = false;
            iL = currentOntologies.searchIL(c);
            /*for(int i=0; i<currentOntologies.getCurrentOntologies().size() && !found; i++){
                oM = (OntologyManager)currentOntologies.getCurrentOntologies().get(i);
                for(int k=0; k<oM.getCurrentKBs().getManagedKBs().size() && !found; k++){
                    kbM = (KBManager)oM.getCurrentKBs().getManagedKBs().get(k);
                    for(int m=0; m<kbM.getKBVersion().getKB().getInstanceList().size() && !found; m++){
                        iL = (InstanceList)kbM.getKBVersion().getKB().getInstanceList().get(m);
                        if(iL.getClassSpecification().equals(c)){
                            found = true;
                        }
                    }
                }
            }*/// Tenemos la variable iL que almacena la InstanceList en la que está c
            // Hay que eliminar la clase c: poner a null... y ese tipo de cosas
            currentOntologies.getOM().getOntologyVersion().getOntology().deleteClass(c); // Lo eliminamos de la ontología
            currentOntologies.getKBM().getKBVersion().getKB().deleteInstanceList(iL); // Lo eliminamos de la Base de Conocimiento
        } else {
            System.out.println("The selected classes must be brothers");
        }
    }
    /**
     * public void cTypeClassRemoval(ClassSpecification c)
     * 
     * Al borrar una clase se inicia un proceso en cascada, orientado de forma recursiva.
     * La clase a borrar se elimina, pero también sus subclases si solo tienen como superclase la clase a borrar,
     * si no es así sólo se eliminará la relación clase superclase.
     */
    public void cTypeClassRemoval(ClassSpecification c){
        // Ayudados por el método recursivo removeInCascade() borramos todos las clases. 
        removeInCascade(c);    
    }
    /**
     * private void removeInCascade(ClassSpecification c)
     * 
     * Este método es llamado por la funcinalidad cTypeClassRemoval, en la que
     * necesitamos realizar el borrado en cascada de una clase.
     * 
     * La clase será borrada, y sus hijas serán borradas si la clase pasada como
     * parametro al método es su única superclase. Por esto se distinguen 2
     * casos:
     * 
     * - La clase hija de la clase pasada como parametro(c) será borrada si su
     * única superclase es la clase c.
     * - Si la hija de c tiene más de una superclase lo que haremos será quitarle
     * los atributos de c a las instancias de la hija de c.
     * 
     * En ambos casos al final del método se borra la clase c de la ontología y 
     * de la Base de Conocimientos.
     */
    private void removeInCascade(ClassSpecification c){
        iL = currentOntologies.searchIL(c);
        /*for(int i=0; i<currentOntologies.getCurrentOntologies().size() && !found; i++){
            oM = (OntologyManager)currentOntologies.getCurrentOntologies().get(i);
            for(int k=0; k<oM.getCurrentKBs().getManagedKBs().size() && !found; k++){
                kbM = (KBManager)oM.getCurrentKBs().getManagedKBs().get(k);
                for(int m=0; m<kbM.getKBVersion().getKB().getInstanceList().size() && !found; m++){
                    iL = (InstanceList)kbM.getKBVersion().getKB().getInstanceList().get(m);
                    if(iL.getClassSpecification().equals(c)){
                        found = true;
                    }
                }
            }
        }*/// Tenemos la variable iL que almacena la InstanceList en la que está c
        for (int m=0; m<c.getSubClasses().size(); m++){
            // Miramos cuantas superclases tiene la subclase de c.
            if (((ClassSpecification)c.getSubClasses().get(m)).getSuperClasses().size()>1){
                // Borramos de las clases superc y subc que estan relacionadas.
                ((ClassSpecification)c.getSubClasses().get(m)).deleteSuperclass(c);
                c.deleteSubclass(((ClassSpecification)c.getSubClasses().get(m)));
                // Hay que buscar las instancias de subc y sus descendientes para eliminar de ellas los atributos de superc.
/* Aquí */      searchInstancesDelete(c, (ClassSpecification)c.getSubClasses().get(m));
/*Corregido*/   reAddAttributes(((ClassSpecification)c.getSubClasses().get(m)));
            } else { // Si c es la única superclase de la subclase de c lo que hacemos es eliminar esa subclase
                // primero eliminamos los atributos de c de las instancias de las subclases de c POR SI HAY HERENCIA DE VARIOS NIVELES
                searchInstancesDelete(c, (ClassSpecification)c.getSubClasses().get(m));
                removeInCascade((ClassSpecification)c.getSubClasses().get(m));
            }
        }
        // Hay que eliminar la clase c de la ontología y sus instancias de la Base de Conocimientos
        currentOntologies.getOM().getOntologyVersion().getOntology().deleteClass(c); // Lo eliminamos de la ontología
        currentOntologies.getKBM().getKBVersion().getKB().deleteInstanceList(iL); // Borramos la InstanceList de la Base de Conocimientos
        for(int i=0; i<c.getSuperClasses().size(); i++){
            ((ClassSpecification)c.getSuperClasses().get(i)).deleteSubclass(c);
            c.deleteSuperclass((ClassSpecification)c.getSuperClasses().get(i));
        }
    }
}