package projectv1a;
import java.util.*;

/**
 *  Clase InstanceList
 *  
 *  En esta clase almacenaremos una lista con todas las instancias clasificadas
 *  por clases.
 *  
 *  Tendrá 1 objeto de tipo ClassSpecification y X tipo InstanceSpecification 
 */
public class InstanceList{
    private ClassSpecification classSpecification; // La clase en cuestion
    private Vector instanceList;      // Todas las instancias de la clase   - InstanceSpecification
    //CASTOR
    private int identity;
    private KnowledgeBase knowledgeBase;
    
    // Variables auxiliares
    InstanceSpecification instance;
    SlotValueSpecification attributeValue;
    boolean found;

    //////////// CONSTRUCTORES //////////////
    public InstanceList(){
        instanceList = new Vector();
    }
    public InstanceList(ClassSpecification c){
        classSpecification = c;
        instanceList = new Vector();
    }
    public InstanceList(ClassSpecification c, Vector v){
        classSpecification = c;
        instanceList = v;
    }
    /////////////////////////////////////////
    
    public KnowledgeBase getKnowledgeBase(){
        return knowledgeBase;
    }    
    public void setKnowledgeBase(KnowledgeBase kb){
        knowledgeBase = kb;
    }
    
    public void setId(int i){
        identity = i;
    }    
    public int getId(){
        return identity;
    }
    public void addInstance(InstanceSpecification instance){
        instanceList.add(instance);
        instance.setInstanceList(this);
    }
    public Vector getInstanceList(){
        return instanceList;
    }
    public void setInstanceList(Vector v){
        instanceList = v;
    }
    public ClassSpecification getClassSpecification(){
        return classSpecification;
    }
    public void setClassSpecification(ClassSpecification c){
        classSpecification = c;
    }
    public void setAbstract(){  // pone como abstracta la clase, lo que implica la eliminación de sus instancias
        instanceList = new Vector();    // se supone que si nos interesa conservar las instancias ya las habremos recolocado
        classSpecification.setRole(true);
    }
    
    public void specializationOperations(Vector criterion){
        for(int i=0; i<getInstanceList().size(); i++){
            instance = (InstanceSpecification)getInstanceList().get(i);
            for(int m=0; m<instance.getSVS().size(); m++){
                attributeValue = (SlotValueSpecification)instance.getSVS().get(m);
                found = false;
                for(int k=0; k<criterion.size() && !found; k++){
                    // Si este es el atributo que estamos buscando...
                    if(attributeValue.getAttribute().getName().equals(((Criterion)criterion.get(k)).getAttribute().getName())){
                        // Si NO tiene una lista de valores permitidos
                        if(!((Criterion)criterion.get(k)).getAllowedValues().getList().isEmpty()){
                            // Si hay un rango de valores permitidos y es de tipo numerico
                            if(((Criterion)criterion.get(k)).getAllowedValues().getRank() != null && 
                                        (attributeValue.getAttribute().getType().equals(TypeEnum.INTEGER_TYPE) ||
                                         attributeValue.getAttribute().getType().equals(TypeEnum.FLOAT_TYPE)   ||
                                         attributeValue.getAttribute().getType().equals(TypeEnum.DOUBLE_TYPE))) {
                                // Si el valor almacenado en la instancia está dentro del rango...
                                if(((Criterion)criterion.get(k)).getAllowedValues().getRank().isIn(Double.parseDouble(attributeValue.getValue()))){
                                    found = true;
                                    instance.setClassObject(((InstanceList)instanceList.get(k)).getClassSpecification());
                                    ((InstanceList)instanceList.get(k)).addInstance(instance);
                                }
                            }
                        } else { // Si tiene una lista de valores permitidos buscamos en ella
                            for(int n=0; n<((Criterion)criterion.get(k)).getAllowedValues().getList().size(); n++){
                                // COMPARACIÓN SOSPECHOSA, POSIBLE BUG
                                if(attributeValue.getValue().equals(((Criterion)criterion.get(k)).getAllowedValues().getList().get(n))){
                                    found = true;
                                    instance.setClassObject(((InstanceList)instanceList.get(k)).getClassSpecification());
                                    ((InstanceList)instanceList.get(k)).addInstance(instance);
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    static public Vector addInstancesTo(ClassSpecification newClass, Vector classes){
        Vector instances = new Vector(); // Este vector será luego el vector de instanceList para la clase newClass
        for (int i=0; i<classes.size(); i++){
            // Recorre el vector de InstanceList(el que contiene las InstanceSpecification que habra que pasar a instances)
            for (int k=0; k<((InstanceList)classes.get(i)).getInstanceList().size(); k++){                
                //temp = (InstanceSpecification)((InstanceList)classes.get(i)).getInstanceList().get(k);
                //temp.setClassObject(newClass);
                ((InstanceSpecification)((InstanceList)classes.get(i)).getInstanceList().get(k)).setClassObject(newClass);
                if (!instances.contains((InstanceSpecification)((InstanceList)classes.get(i)).getInstanceList().get(k))){
                    instances.add((InstanceSpecification)((InstanceList)classes.get(i)).getInstanceList().get(k));
                }
            }
        }
        return instances;
    }
    
}