package projectv1a;

import java.util.*;

public class ClassSpecification extends Object{
    private String name;
    private boolean role;           // ¿Abstracta? || false: No es abstracta
    private boolean patternMatch;
    private String description;
    private Vector attributeList;   // Listado de todos sus atributos   - AttributeSpecification
    private Vector superClassList;  // Listado de sus superclases       - ClassSpecification
    private Vector subClassList;    // Listado de sus subclases         - ClassSpecification
    // CLASES PARA CASTOR
    // Si aquí nos diera problemas una "posible solución" sería crear vectores de subclases y superclases replicados para CASTOR
    private Vector /*ClassSpecification*/ subClass;     // Para las referencias de CASTOR
    private Vector /*ClassSpecification*/ superClass;   // Para las referencias de CASTOR
    
    private int identity;
    private Ontology ontology; // Referencia a la ontología a la que pertenece.
    
    
    ///////////// CONSTRUCTORES /////////////
    public ClassSpecification(){
        name = "anonima";
        role = false;
        patternMatch = false;
        attributeList = new Vector();
        superClassList = new Vector();
        subClassList = new Vector();
        superClass = new Vector();
        subClass = new Vector();
    }
    public ClassSpecification(String n, boolean r, boolean pM){
        name = n;
        role = r;
        patternMatch = pM;
        attributeList = new Vector();
        superClassList = new Vector();
        subClassList = new Vector();
        superClass = new Vector();
        subClass = new Vector();
    }
    public ClassSpecification(String n){
        name = n;
        role = false;
        patternMatch = false;
        attributeList = new Vector();
        superClassList = new Vector();
        subClassList = new Vector();
        superClass = new Vector();
        subClass = new Vector();
    }
    /////////////////////////////////////////

    public void setId(int i){
        identity = i;
    }
    public int getId(){
        return identity;
    }
    public void addAttribute(AttributeSpecification attribute){ // En realidad serán objetos de las hijas de AttributeSpecification
        if (attributeList.contains(attribute)){
            System.out.println("The attribute already exists.");
        } else {
            attributeList.add(attribute);
            attribute.setClassSpecification(this);
        }
    }
    public void addSuperClass(ClassSpecification a){ // AL LORO: si añadimos una superclase, en otro lugar añadimos una subclase
        if (superClassList.contains(a)){
            System.out.println("The class "+a.getName()+" already is a superclass of "+getName()+".");
        } else {
            superClassList.add(a);
        }
    }
    public void addSubClass(ClassSpecification a){ // AL LORO: si añadimos una subclase, en otro lugar añadimos una superclase
        if (subClassList.contains(a)){
            System.out.println("The class "+a.getName()+" already is a subclass of "+getName()+".");
        } else {
            subClassList.add(a);
        }
    }

    public Vector getAttribute(){
        return attributeList;
    }
    public void setAttribute(Vector v){
        attributeList = v;
    }
    public void deleteAttribute(AttributeSpecification at){
        if (attributeList.contains(at)){
            attributeList.remove(at);
        } else {
            System.out.println("The selected attribute does not exist in the class");
        }
    }
    public Vector getSuperClasses(){
        return superClassList;
    }
    public Vector getSuperClassList(){
        return superClassList;
    }
    public void setSuperClasses(Vector v){
        superClassList = v;
    }
    public void setSuperClassList(Vector v){
        superClassList = v;
    }
    public void deleteSuperclass(ClassSpecification c){
        if (superClassList.contains(c)){
            superClassList.remove(c);
        } else {
            System.out.println("The selected class is not a superclass.");
        }
    }
    public Vector getSubClasses(){
        return subClassList;
    }
    public Vector getSubClassList(){
        return subClassList;
    }
    public void setSubClasses(Vector v){
        subClassList = v;
    }
    public void setSubClassList(Vector v){
        subClassList = v;
    }
    public void deleteSubclass(ClassSpecification c){
        if (subClassList.contains(c)){
            subClassList.remove(c);
        } else {
            System.out.println("The selected class is not a subclass.");
        }
    }
    
    //////// PARA CASTOR ////////
    public Vector getSubClass(){
        return subClass;
    }
    public void setSubClass(Vector subC){
        subClass = subC;
    }
    public Vector getSuperClass(){
        return superClass;
    }
    public void setSuperClass(Vector superC){
        superClass = superC;
    }
    /////////////////////////////
    
    public Ontology getOntology(){
        return ontology;
    }    
    public void setOntology(Ontology o){
        ontology = o;
    }
    
    public String getName(){
        return name;
    }
    public void setName(String n){
        name = n;
    }
    public boolean getRole()
    {
        return role;
    }
    public void setRole(boolean r){
        role = r;
    }
    public boolean getPM(){
        return patternMatch;
    }
    public void setPM(boolean b){
        patternMatch = b;
    }
    public void setDescription(String s){
        description = s;
    }
    public String getDescription(){
        return description;
    }
    
    public boolean leafClass(){ // Clase hoja
        if (subClassList.isEmpty()){
            return true; // Si no tiene subclases es una clase hoja
        } else {
            return false; // Si tiene subclases NO es una clase hoja
        }
    }
    public boolean brotherClass(ClassSpecification brotherClass){
        boolean found = false;
        for(int i=0; i<getSuperClasses().size() && !found; i++){
            for (int k=0; k<brotherClass.getSuperClasses().size() && !found; k++){
                if(getSuperClasses().get(i).equals(brotherClass.getSuperClasses().get(k))){
                    found = true;
                }
            }
        }
        if (!found){
            return false;
        } else {
            return true;
        }
    }
    public static boolean brotherClasses(Vector classes){
        boolean found = false;
        boolean is[] = new boolean[classes.size()];
        is[0] = true; // El primero es el que buscamos en las otras clases, así que ya sabemos que está en la primera
        ClassSpecification base;
        
        for (int i=0; i<((ClassSpecification)classes.get(0)).getSuperClasses().size() && !found; i++){
            found = true;
            for (int k=1; k<classes.size(); k++) is[k]=false;
            base = (ClassSpecification)((ClassSpecification)classes.get(0)).getSuperClasses().get(i);
            for (int m=1; m<classes.size(); m++){
                for(int l=0; l<((ClassSpecification)classes.get(m)).getSuperClasses().size(); l++){
                    if(((ClassSpecification)classes.get(m)).getSuperClasses().get(l).equals(base)){
                        is[m] = true;
                    } 
                }
            }
            // Este último bucle es para saber si ya hemos encontrado o no la superclase común
            for(int m=1; m<classes.size() && found; m++){
                if(is[m] == false){
                    found = false;
                }
            }
        }
        if (!found) return false;
        else return true;
    }
    public void makeSuperclassesA(Vector classList){
        for (int i=0; i<classList.size(); i++){
            for (int m=0; m<((ClassSpecification)classList.get(i)).getSuperClasses().size(); m++){
                //si no está ya en el vector newClass.getSuperClasses() lo metemos
                if (!getSuperClasses().contains(((ClassSpecification)classList.get(i)).getSuperClasses().get(m))){
                    addSuperClass((ClassSpecification)((ClassSpecification)classList.get(i)).getSuperClasses().get(m));
                    // Añadimos newClass a las subclases de la clase que acabamos de poner como superclase de newClass
                    ((ClassSpecification)((ClassSpecification)classList.get(i)).getSuperClasses().get(m)).addSubClass(this);
                    // Borramos classes.get(i).getClassSpecification de las subclases de la superclase que estamos tratando ahora
                    ((ClassSpecification)((ClassSpecification)classList.get(i)).getSuperClasses().get(m))
                                                                    .deleteSubclass((ClassSpecification)classList.get(i));
                }
            }
        }
    }
    public void makeSubclassesA(Vector classList){
        for (int i=0; i<classList.size(); i++){
            for (int m=0; m<((ClassSpecification)classList.get(i)).getSubClasses().size(); m++){
                //sino esta ya en el vector newClass.getSubClasses lo metemos
                if (!getSubClasses().contains(((ClassSpecification)classList.get(i)).getSubClasses().get(m))){
                    addSubClass((ClassSpecification)((ClassSpecification)classList.get(i)).getSubClasses().get(m));
                    // Añadimos newClass a las superclases de la clase que acabamos de poner como subclase de newClass
                    ((ClassSpecification)((ClassSpecification)classList.get(i)).getSubClasses().get(m)).addSuperClass(this);
                    // Borramos classes.get(i).getClassSpecification de las subclases de la superclase que estamos tratando ahora
                    ((ClassSpecification)((ClassSpecification)classList.get(i)).getSubClasses().get(m))
                                                                    .deleteSuperclass((ClassSpecification)classList.get(i));
                }
            }
        }
    }
    /**
     * 
     * @param classes Vector con objetos de tipo InstanceList de las clases a generalizar
     */
    public void setAsSuperclassOf(Vector classes){
        // En este bucle las superclases de "classes" pasarán a ser superclases de la clase actual(this)
        for (int i=0; i<classes.size(); i++){
            for (int m=0; m<((InstanceList)classes.get(i)).getClassSpecification().getSuperClasses().size(); m++){
                /*sino esta ya en el vector newClass.getSuperClasses lo metemos*/
                if (!getSuperClasses().contains(((InstanceList)classes.get(i)).getClassSpecification().getSuperClasses().get(m))){
                    addSuperClass((ClassSpecification)((InstanceList)classes.get(i)).getClassSpecification().getSuperClasses().get(m));
                }
            }
        }
        // A newClass le ponemos como superclase de las clases generalizadas
        for (int i=0; i<classes.size(); i++){
            addSubClass(((InstanceList)classes.get(i)).getClassSpecification());
            for (int k=0; k<((InstanceList)classes.get(i)).getClassSpecification().getSuperClasses().size(); k++){
                addSuperClass((ClassSpecification)((InstanceList)classes.get(i)).getClassSpecification().getSuperClasses().get(k));
            }
        }
        // A las superclases naturales de las clases generalizadas les quitamos de sus subclases las clases generalizadas
        for (int i=0; i<classes.size(); i++){
            for (int k=0; k<((InstanceList)classes.get(i)).getClassSpecification().getSuperClasses().size(); k++){
                ((ClassSpecification)(((InstanceList)classes.get(i)).getClassSpecification().getSuperClasses()).get(k)).deleteSubclass((ClassSpecification)(((InstanceList)classes.get(i)).getClassSpecification()));
            }
        }
        // A las superclases naturales de las clases generalizadas les añadimos la clase actual como subclase
        for (int i=0; i< classes.size(); i++){
            for (int j=0; j<((InstanceList)classes.get(i)).getClassSpecification().getSuperClasses().size(); j++){
                ((ClassSpecification)((InstanceList)classes.get(i)).getClassSpecification().getSuperClasses().get(j)).addSubClass(this);
            }
        }
        // La unica superclase de las clases generalizadas será newClass
        for (int i=0; i<classes.size(); i++){
            ((InstanceList)classes.get(i)).getClassSpecification().getSuperClasses().removeAllElements();
            ((InstanceList)classes.get(i)).getClassSpecification().addSuperClass(this);
        }
        
    }
    /**
     * Busca los atributos que le añadiremos a la clase invocante. Estos atributos seran los comunes
     * a todas las ClassSpecification contenidas en los InstanceList del vector classes
     * @param classes - Contiene InstanceList de las clases que tenemos que buscar los atributos comunes
     */
    public void attributesToClassGeneralization(Vector classes){
        boolean found;
        AttributeSpecification at;
        boolean is[] = new boolean[classes.size()];
        is[0] = true;
        for (int i=0; i<((InstanceList)classes.get(0)).getClassSpecification().getAttribute().size(); i++){
            found = true;
            for (int k=1; k<classes.size(); k++) is[k]=false;
            at = (AttributeSpecification)((InstanceList)classes.get(0)).getClassSpecification().getAttribute().get(i);
            for (int m=1; m<classes.size(); m++){
                for (int l=0; l<((InstanceList)classes.get(m)).getClassSpecification().getAttribute().size(); l++){
                    is[m] = true; 
                }
            }
            // Este último bucle es para saber si ya hemos encontrado o no un atributo común
            for (int m=1; m<classes.size(); m++){
                if (is[m] == false) found = false;
            }
            if (found) addAttribute(at);
        }
    }
    /**
     * COMPROBAR QUE LA DESCRIPCIÓN ES CORRECTA
     * Los atributos que no estan en la clase invocante los elimina de las instancias
     * de las clases contenidas en el vector classes.
     * @param classes
     * @param co
     */
    public void removeNonCommonAttributes(Vector classes, CurrentOntologies co){
        boolean found = false;
        InstanceSpecification temp;
        String nameAt;
        for (int i=0; i<classes.size(); i++){ // Recorre todas las clases generalizadas
        //AKI VOY-TENGO QUE MIRAR SI PUEDO EJECUTAR LO DE ABAJO EN INSTANCELIST TAL COMO ESTA. SI FUNCIONA HACERLO
            for(int k=0; k<((InstanceList)classes.get(i)).getInstanceList().size(); k++){
            // El for de arriba recorre la lista de InstanceSpecification de la clase generalizada actual (i)
                // En temp, en cada ejecución almacenamos una instancia de la clase generalizada actual
                temp = (InstanceSpecification)((InstanceList)classes.get(i)).getInstanceList().get(k);
                // Controlamos los atributos simples
                for (int m=0; m<temp.getSVS().size(); m++){ // Recorre el vector SlotValueSp de InstanceSpecification
                    // Mirar si el atributo coincide con alguno de  los que hay en newClass.getAttributes()
                    // Si no coindice borrarlo, si coincide dejarlo
                    nameAt = ((SlotValueSpecification)temp.getSVS().get(m)).getAttribute().getName();
                    found = false;
                    for (int l=0; l<getAttribute().size() && !found; l++){
                    // Este for recorre el vector de atributos de newClass para ver si son los de las instancias
                        if (((AttributeSpecification)getAttribute().get(l)).getName().equals(nameAt)){
                            found = true;
                        }
                    }
                    if (!found){ // Borrar de la lista de atributos en InstanceSpecification
                        // Ahora hay que asegurarse que las modificaciones hechas se propagan a traves
                        // de la jerarquía y en sentido descendente.
                        removeAttributeInCascade(((InstanceList)classes.get(i)).getClassSpecification(), ((SlotValueSpecification)temp.getSVS().get(m)).getAttribute(), co);
                        //((InstanceList)classes.get(i)).getClassSpecification().removeAttributeInCascade(((SlotValueSpecification)temp.getSVS().get(m)).getAttribute(), co);
                    }
                }
                // Controlamos los atributos multivaluados
                for (int m=0; m<temp.getMSVS().size(); m++) {  // Recorre el vector MultiSlotValueSp de InstanceSpecification
                    nameAt = ((MultiSlotValueSpecification)temp.getMSVS().get(m)).getAttribute().getName();
                    found = false;
                    for (int l=0; l<getAttribute().size() && !found; l++){
                    // Este for recorre el vector de attributos de newClass para ver si son los de las instancias
                        if (((AttributeSpecification)getAttribute().get(l)).getName().equals(nameAt)){
                            found = true;
                        }
                    }
                    if (!found){ // Borrar de la lista de atributos en InstanceSpecification
                        // Ahora hay que asegurarse que las modificaciones hechas se propagan a traves
                        // de la jerarquía y en sentido descendente.
                        removeAttributeInCascade(((InstanceList)classes.get(i)).getClassSpecification(), ((MultiSlotValueSpecification)temp.getMSVS().get(m)).getAttribute(), co);
                    }
                }
            }
        }
    }
    /**
     * removeAttributeInCascade
     * 
     * Elimina de las instancias de la clase c y de sus subclases el atributo a
     * @param c
     * @param a
     */
    // ELEGIR UNO!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    /*private void removeAttributeInCascade(AttributeSpecification a, CurrentOntologies currentOntologies){
        InstanceList iL;
        // Buscamos las clases en cuestion
        iL = currentOntologies.searchIL(this);
        // En iL almacenada la InstanceList de la clase c
        // Borramos el atributo a de las instancias de c
        for(int i=0; i<iL.getInstanceList().size(); i++){
            if(!a.getMulti()){
                ((InstanceSpecification)iL.getInstanceList().get(i)).deleteSVS((SlotSpecification)a);
            }else { // a es multivaluado
                ((InstanceSpecification)iL.getInstanceList().get(i)).deleteMSVS((MultiSlotSpecification)a);
            }
        }
        // Ahora volvemos a ejecutar el método para el resto de la jerarquía en orden descendente
        for(int i=0; i<getSubClasses().size(); i++){
            ((ClassSpecification)getSubClasses().get(i)).removeAttributeInCascade(a, currentOntologies);
        }
    }*/
    private void removeAttributeInCascade(ClassSpecification c, AttributeSpecification a, CurrentOntologies currentOntologies){
        InstanceList iL;
        // Buscamos las clases en cuestion
        iL = currentOntologies.searchIL(c);
        // En iL almacenada la InstanceList de la clase c
        // Borramos el atributo a de las instancias de c
        for(int i=0; i<iL.getInstanceList().size(); i++){
            if(!a.getMulti()){
                ((InstanceSpecification)iL.getInstanceList().get(i)).deleteSVS((SlotSpecification)a);
            }else { // a es multivaluado
                ((InstanceSpecification)iL.getInstanceList().get(i)).deleteMSVS((MultiSlotSpecification)a);
            }
        }
        // Ahora volvemos a ejecutar el método para el resto de la jerarquía en orden descendente
        for(int i=0; i<c.getSubClasses().size(); i++){
            removeAttributeInCascade((ClassSpecification)c.getSubClasses().get(i), a, currentOntologies);
        }
    }
}