package beans;

import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;

import javax.ejb.LocalBean;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;
import javax.servlet.http.Part;

import smile.Network;

import model.Alumno;
import model.Asignatura;
import model.Concepto;
import model.Curso;
import model.Ejercicio;
import model.Profesor;
import model.Respuesta;
import model.Sesion;
import model.Tarea;
import model.Tema;

/**
 * Session Bean implementation class AdministracionBean
 */
@Stateless
@LocalBean
public class AdministracionBean implements AdministracionBeanRemote{
	
	@PersistenceContext 
    EntityManager em;

	Separador sp;
    /**
     * Default constructor. 
     */
    public AdministracionBean() {
        // TODO Auto-generated constructor stub
    	sp = new Separador();
    }
    
    public List getConceptoList(int idTema) {
    	Tema tema = em.find(Tema.class, idTema);
    	List conceptoList = tema.getConceptoList();
    	System.out.println(conceptoList.toString());
    	return conceptoList;
    }
    
    public void agregarEjercicio(Ejercicio ejercicio, int idAsignatura) {
    	//Poner en una transaccion
    	// em.getTransaction().begin();
    	em.persist(ejercicio);
    	
    	agregarEjercicioRed(ejercicio, idAsignatura);  
    	//em.getTransaction().commit();
    }
    
    public double [] calcularProbabilidadesCCI(Ejercicio ejercicio) {
		// TODO Auto-generated method stub
    	Double dimension =  Math.pow(2, ejercicio.getConceptoList().size());
    	double [] ejercicioDef = new double[dimension.intValue() * 2];
    	
    	int j = 0;
    	int contador = 0;
    	double x = calcularXasterisco(ejercicio);
    	System.out.println("x: " + x);
    	for(int i = 0; i < dimension; i++) {
    		double multiplicador = i / (dimension - 1);
    		System.out.println("i: " + i + " /dimension: "+ dimension);
    		System.out.println("mult " + multiplicador);
    		ejercicioDef[j] = 1 - funcionGx((multiplicador * x), dimension.intValue(), ejercicio);
    		System.out.println("funcionGx: " + ejercicioDef[j]);
    		j++;
    		ejercicioDef[j] = 1 - ejercicioDef[j-1];
    		j++;
    		contador++;
    		
    	}
    	
    	return ejercicioDef;
	}

	
	private double calcularXasterisco(Ejercicio ejercicio) {
		// TODO Auto-generated method stub
		//indice de discriminacion
		double a = 2;
				
		//b = nivel de dificultad
		double b = ejercicio.getNivelDificultad();
				
		//c = 1/n n = cantidad respuesta.
		double c = 1.0 / 4 ;// Double.valueOf(ejercicio.getConceptoList().size());
		
		//s = adivinanza
		double s = ejercicio.getAdivinanza();
		
		double k = ((1 - c) * (1 + Math.exp(-1.7 * a * b)))/s - 1;
		
		double x = (Math.log(k) + (1.7 * a * b)) / (1.7 * a);
		
		return x;
		
	}

	private double funcionGx(double x, int dimension, Ejercicio ejercicio){
		//G(X) = 1- ( (1-c)(1+exp(-1.7ab)) ) / ( 1+exp(1.7a(x-b)) ) 
		System.out.println("##################################################");
		//indice de discriminacion
		double a = 2;
		
		//b = nivel de dificultad
		double b = ejercicio.getNivelDificultad();
		
		//c = 1/n
		double c = 1.0 / 4;// Double.valueOf(ejercicio.getConceptoList().size());
		System.out.println("cant concepto: " + ejercicio.getConceptoList().size());
		System.out.println("a: " + a + "b: " + b + "c: " + c);
		
		double numerador = (1 - c) * (1 + Math.exp(-1.7 * a * b));
		System.out.println("numerado: " + numerador);
		
		double denominador = 1 + Math.exp(1.7 * a * (x - b));
		System.out.println("denominador: " + denominador);
		double gX = 1 - (numerador / denominador);
		
		System.out.println("gx: " + gX);
		System.out.println("##################################################");

		return gX;
	}

	public void agregarTema(Tema tema) {
    	em.persist(tema);
    	System.out.print("asog " + tema.getDescripcion());

    	agregarTemaRed(tema);   	
    	
    }
    
    public void editarTema(Tema tema){
    	
    	Tema temaViejo = em.find(Tema.class, tema.getIdTema());
    	String tituloViejo = temaViejo.getNombre();
    	em.merge(tema);
    	
    	modificarTemaRed(tema,tituloViejo);
    	//falta actualizar red
    }
    
    public void eliminarTema(int idTema) {
    	Tema tema = em.find(Tema.class, idTema);
    	
    	for(Concepto concepto : tema.getConceptoList()) {
    		eliminarConcepto(concepto.getIdConcepto());
    	}
    	
    	em.remove(tema);
    	eliminarTemaRed(tema);
    }
    
    private void eliminarTemaRed(Tema tema) {
		// TODO Auto-generated method stub
    	String nombreRed = "red_asignatura_" + tema.getAsignatura().getIdAsignatura() + ".xdsl";
    	Network net = new Network();
		net.readFile("/home/redes/" + nombreRed);
		//cambiar formato nombre
		String nom = sp.convertirEspacioToGuion(tema.getNombre());
		net.deleteNode(nom);
		net.writeFile("/home/redes/" + nombreRed);
	}

	public void agregarConcepto(Concepto concepto) {
    	//Poner en una transaccion
    	em.persist(concepto);
    	agregarConceptoRed(concepto);   	
    	
    }
    
    public void editarConcepto(Concepto concepto, String idAsignatura) {
    
    	System.out.print("-----------modificando concepto---------------");

    	Concepto conceptoViejo = em.find(Concepto.class, concepto.getIdConcepto());
    	String tituloViejo = conceptoViejo.getNombre();
    	
    	em.merge(concepto);
    	//falta actualizar red
    	
    	
    	
    	modificarConceptoRed(concepto, tituloViejo);
    	List<Integer> idEjercicios = em.createNativeQuery("select id_ejercicio from ejercicio_concepto e where e.id_concepto =" + concepto.getIdConcepto()).getResultList();
    //	List<Ejercicio>  e = (List<Ejercicio>) em.createQuery("select e from Ejercicio where :concepto in e.conceptoList").setParameter("concepto", concepto);
    	
    	//select e from Ejercicio where :concepto in e.conceptoList
    
    	ArrayList <Ejercicio> ejercicios =  new ArrayList();
    	
    	
    	for(int idEjercicio : idEjercicios){
    		
    		ejercicios.add(em.find(Ejercicio.class,idEjercicio));
    		// = em.find(Ejercicio.class,idEjercicio);
    		
    	}
    	calcularProbabilidadesCCI(ejercicios, idAsignatura);
    }
    
    
    //elimina el concepto idconcepto que se encuentra relacionado a varios ejercicios.
    public void eliminarConcepto(int idConcepto) {
    	Concepto concepto = em.find(Concepto.class, idConcepto);
   
    	Ejercicio ejercicio= null;
    	
    	List<Integer> idEjercicios = em.createNativeQuery("select id_ejercicio from ejercicio_concepto e where e.id_concepto =" + concepto.getIdConcepto()).getResultList();
    	ArrayList <Ejercicio> ejercicios =  new ArrayList();
    	
           	for(int idEjercicio : idEjercicios){
        		
           		ejercicio = em.find(Ejercicio.class,idEjercicio);
           		ejercicio.getConceptoList().remove(concepto);
           		em.persist(ejercicio);
        		ejercicios.add(em.find(Ejercicio.class,idEjercicio));
        		
        	}
        	calcularProbabilidadesCCI(ejercicios, concepto.getTema().getAsignatura().getIdAsignatura().toString());
               	
        	
    	em.remove(concepto);
    eliminarConceptoRed(concepto);
    }
    
    
    
    private void eliminarConceptoRed(Concepto concepto) {
		// TODO Auto-generated method stub\
    	String nombreRed = "red_asignatura_" + concepto.getTema().getAsignatura().getIdAsignatura() + ".xdsl";  	
    	
    	Network net = new Network();
		net.readFile("/home/redes/" + nombreRed);
		//cambiar formato nodo
		String nom = sp.convertirEspacioToGuion(concepto.getNombre());

		net.deleteNode(nom);
		net.writeFile("/home/redes/" + nombreRed);
		
	}

	public void agregarProfesor(Profesor profesor) {
    	em.persist(profesor);
    }
	
   /* public void agregarAsignatura(Asignatura asignatura) {
 
    	em.persist(asignatura);
    	Network net = new Network();
    	String nombreRed = "red_asignatura_" + asignatura.getIdAsignatura() + ".xdsl";
    	net.writeFile("/home/redes/" + nombreRed);

    }*/
   
    public void agregarTarea(Tarea tarea, ArrayList<Concepto> conceptoList) {
    	
    
    	tarea.setConceptoList(conceptoList);
    	em.persist(tarea);
    	//em.merge(tarea);
    }
    
    public Alumno agregarAlumno(Alumno alumno){
    	
    	em.persist(alumno);
    	em.flush();
    	return alumno;
    	
    }
    
    public Integer obtenerIdAlumno(){
    	
    	return em.createNativeQuery("select max(id_alumno) from alumno ").getFirstResult();
    	
    }
    public void calcularProbabilidades(int idAsignatura) {
    	// Calculo de las probabilidades condicionales de las relaciones de agregacion
    	
    	String nombreRed = "red_asignatura_" + idAsignatura + ".xdsl";
		System.out.println("/home/redes/" + nombreRed);
		Network net = new Network();
		net.readFile("/home/redes/" + nombreRed);
		String nomTem;
		Asignatura asignatura = em.find(Asignatura.class, idAsignatura);

    	List<Tema> temaList = (List<Tema>) em.createQuery("Select e from Tema e where e.profesor = :profesor and e.asignatura=:asignatura order by e.idTema" )
				.setParameter("profesor", asignatura.getProfesor()).setParameter("asignatura", asignatura).getResultList() ;
    	
    	for(Tema tema : temaList) {
    		double[] temaDef = calcularProbabilidadesTema(tema);
    		System.out.println(tema.getNombre()+ " "+temaDef.toString() );
    		//cambiar formato de nodo
    		 nomTem = sp.convertirEspacioToGuion(tema.getNombre());
    		net.setNodeDefinition(nomTem, temaDef);
    	}
    	

    	double[] asignaturaDef = calcularProbabilidadesAsignatura(asignatura);
    	//cambiar formato de ndo
    	 nomTem = sp.convertirEspacioToGuion(asignatura.getNombre());
    	net.setNodeDefinition(nomTem, asignaturaDef);
    	
    	
    	net.writeFile("/home/redes/" + nombreRed);
    }
    
    private double[] calcularProbabilidadesAsignatura(Asignatura asignatura) {
    	int dimension = (int) Math.pow(2, asignatura.getTemaList().size());
    	double [] asignaturaDef = new double[dimension * 2];
    	
		System.out.println("DimensionAsignatura "+ dimension );

    	int j = 0;
    	for(int i = 0; i < dimension; i++) {
    		asignaturaDef[j] = 1 - cpAsignatura(asignatura, i);
    		j++;
    		asignaturaDef[j] = 1 - asignaturaDef[j-1];
    		j++;
    		
    	}
    	
    	return asignaturaDef;
	}

	private double cpAsignatura(Asignatura asignatura, int i) {
		
		
		////HAY QUE REVISAR ESTA FUNCION
		String comb = Integer.toBinaryString(i);
		int dimension = asignatura.getTemaList().size();
    	while(comb.length() != dimension){
    		comb = "0" + comb;
    	}
    	
    	double valTemp = 0;
		List<Tema> temaList = em.createQuery("Select e from Tema e where e.asignatura = :asignatura")
				.setParameter("asignatura", asignatura).getResultList(); 
		System.out.println(temaList);
    	for (int j = 0; j < temaList.size(); j++) {
    		 if(comb.charAt(j) == '1') {
    			 valTemp = valTemp + temaList.get(j).getPeso();
    		 } 
    		    	}
    	
    	return valTemp;
	}

   
    private double [] calcularProbabilidadesTema(Tema tema) {
    	//Calculo de las probabilidades condicionales 
    	int dimension = (int) Math.pow(2, tema.getConceptoList().size());
    	System.out.println("dimension " + dimension);
    	double [] temaDef = new double[dimension * 2];
    	System.out.println("**************************************************************");
    	int j = 0;
    	for(int i = 0; i < dimension; i++) {
    		temaDef[j] = 1 - cpTema(tema, i);
    		j++;
    		temaDef[j] = 1 - temaDef[j-1];
    		j++;
    		
    	}
    	System.out.println("**************************************************************");

    	
    	return temaDef;
    }
    
    private double cpTema(Tema tema, int i) {
    	
    	String comb = Integer.toBinaryString(i);
    	while(comb.length() < tema.getConceptoList().size()){
    		comb = "0" + comb;
    	}
    

    	double valTemp = 0;
    	for (int j = 0; j < tema.getConceptoList().size(); j++) {
    		 System.out.println("--------------------------------------------------------");
				System.out.println("j: " + j);

			    System.out.println("comb: " + comb);
    		 if(comb.charAt(j) == '1') {
 				   
    				System.out.println("concepto: " +  tema.getConceptoList().get(j));
    				System.out.println("peso: " +  tema.getConceptoList().get(j).getPeso());
 				    System.out.println("--------------------------------------------------------");

    			 valTemp = valTemp + tema.getConceptoList().get(j).getPeso();
    		 } 
    	}
    	
    	return valTemp;
    	
    }
    
    private void agregarEjercicioRed(Ejercicio ejercicio, int idAsignatura) {
    	//operaciones sobre la red bayesiana con smile
    	String nombreRed = "red_asignatura_" + idAsignatura + ".xdsl";
		System.out.println("/home/redes/" + nombreRed);
		Network net = new Network();
		net.readFile("/home/redes/" + nombreRed);
		
		//agregar nodo ejercicio
		String titulo = "E" + Integer.toString(ejercicio.getIdEjercicio());
		net.addNode(Network.NodeType.Cpt, titulo);
		net.setOutcomeId(titulo, 0, "Incorrecto");
		net.setOutcomeId(titulo, 1, "Correcto");
		
		//agregar los arcos
		List<Concepto> conceptoList = ejercicio.getConceptoList(); 
		for(Concepto concepto : conceptoList) {
			String conceptoRed = sp.convertirEspacioToGuion(concepto.getNombre());

			net.addArc(conceptoRed, titulo);
		}
		
		//definir probabilidades condicionales
		double[] ejercicioDef = calcularProbabilidadesCCI(ejercicio);
		net.setNodeDefinition(titulo, ejercicioDef);
		
		net.writeFile("/home/redes/" + nombreRed);
    }
    
    private void agregarTemaRed(Tema tema) {
    	//operaciones sobre la red bayesiana con smile
    	String nombreRed = "red_asignatura_" + tema.getAsignatura().getIdAsignatura() + ".xdsl";
		System.out.println("/home/redes/" + nombreRed);
		Network net = new Network();
		net.readFile("/home/redes/" + nombreRed);
	
		
		//agregar nodo ejercicio
		//cambiar formato nodo
		String titulo =  sp.convertirEspacioToGuion(tema.getNombre());

		net.addNode(Network.NodeType.Cpt, titulo);
		net.setOutcomeId(titulo, 0, "No_conoce");
		net.setOutcomeId(titulo, 1, "Conoce");
		
	//agregar los arcos
	
		net.addArc(titulo, sp.convertirEspacioToGuion(tema.getAsignatura().getNombre()));

		
		net.writeFile("/home/redes/" + nombreRed);
    }
    
    private void agregarConceptoRed(Concepto concepto) {
    	//operaciones sobre la red bayesiana con smile
    	String nombreRed = "red_asignatura_" + concepto.getTema().getAsignatura().getIdAsignatura() + ".xdsl";
    	String titulo;
		System.out.println("/home/redes/" + nombreRed);
		Network net = new Network();
		net.readFile("/home/redes/" + nombreRed);
		
		//agregar nodo concepto
		//cambiar formato nodo
		 titulo =  sp.convertirEspacioToGuion(concepto.getNombre());
		net.addNode(Network.NodeType.Cpt, titulo);
		net.setOutcomeId(titulo, 0, "No_conoce");
		net.setOutcomeId(titulo, 1, "Conoce");
		
		//agregar los arcos
		//cambiar formato nodo
		//titulo =  sp.convertirEspacioToGuion(concepto.getTema().getNombre());

		net.addArc(titulo, sp.convertirEspacioToGuion(concepto.getTema().getNombre()));
				
		//definir probabilidades
		double [] conceptoDef = new double [2];
		conceptoDef[1] = concepto.getApriori();
		conceptoDef[0] = 1 - conceptoDef[1];
		//cambiar formato nodo
		net.setNodeDefinition(titulo, conceptoDef);
		net.writeFile("/home/redes/" + nombreRed);
    }

	@Override
	public Profesor logIn(String usuario, String password) {
		// TODO Auto-generated method stub
		Profesor profesor = (Profesor) em.createNamedQuery("Profesor.findByUsuario")
				.setParameter("usuario", usuario).getSingleResult();
		
		if(password.trim().equals(profesor.getUsuario().trim())){
			System.out.println(profesor.getAsignaturaList().toString());//No Borrar, sirve para la inicializacion
			return profesor;
		}
		
		return null;
	}

	@Override
	public Asignatura agregarAsignatura(Asignatura asignatura) {
    	
    	Network net = new Network();
		String titulo =  sp.convertirEspacioToGuion(asignatura.getNombre());
		em.persist(asignatura);
    	////cambiar formato nodo
		net.addNode(Network.NodeType.Cpt, titulo);
		net.setOutcomeId(titulo, 0, "No_conoce");
		net.setOutcomeId(titulo, 1, "Conoce");
    	String nombreRed = "red_asignatura_" + asignatura.getIdAsignatura() + ".xdsl";
    	System.out.println("/home/redes/" + nombreRed);
    	net.writeFile("/home/redes/" + nombreRed);

    	System.out.println("iiiiid asignaturaaaaa  " + asignatura.getIdAsignatura());
		// TODO Auto-generated method stub
    	
		return asignatura;
	}

	@Override
	public String getValorNodoRed(String nombre, int idAsignatura, int idAlumno) {
		// TODO Auto-generated method stub
    	String nombreRed = "red_alumno_" + idAlumno + "_asignatura_" + idAsignatura + ".xdsl";

		Network net = new Network();
		net.readFile("/home/redes/" + nombreRed);
		
		net.updateBeliefs();
		//cambiar formato nodo
		//System.out.println(nombre);
		String titulo =  sp.convertirEspacioToGuion(nombre);
		//System.out.println(titulo);
		double [] valor = net.getNodeValue(titulo);
		
		double conoce = valor[1];
		
		return Double.toString(conoce);
		
	}

	

	@Override
	public void crearRedAlumnos(int idAsignatura) {
		// TODO Auto-generated method stub
		
		Asignatura asignatura = em.find(Asignatura.class, idAsignatura);
        Curso curso = asignatura.getCurso();
        List<Alumno> alumnoList = em.createQuery("Select e from Alumno e where e.curso = :curso")
				.setParameter("curso", curso).getResultList();
		
		String nombreRed = "red_asignatura_" + idAsignatura + ".xdsl";
		Network net = new Network();
		net.readFile("/home/redes/" + nombreRed);
		
        
		for (Alumno alumno : alumnoList) {

			String nombreRedAlumno = "red_alumno_" + alumno.getIdAlumno() + "_asignatura_" + idAsignatura + ".xdsl";
			net.writeFile("/home/redes/" + nombreRedAlumno);
			
		}
		
	}

	@Override
	public void editarAsignatura(Asignatura asignatura) {
		em.merge(asignatura);
	
	}
	
    private void modificarTemaRed(Tema tema, String titulo) {
    	//operaciones sobre la red bayesiana con smile
    	String nombreRed = "red_asignatura_" + tema.getAsignatura().getIdAsignatura() + ".xdsl";
		
		Network net = new Network();
		net.readFile("/home/redes/" + nombreRed);
		
	
		String tituloNuevo = sp.convertirEspacioToGuion(tema.getNombre());
		//titulo =  sp.convertirEspacioToGuion(tema.getNombre());

		//cambiar formato nodo

		//modifica el nombre
		net.setNodeId(sp.convertirEspacioToGuion(titulo), tituloNuevo);
	    net.setNodeName(tituloNuevo, tituloNuevo);
		
		
		net.writeFile("/home/redes/" + nombreRed);
    }
    
    
    private void calcularProbabilidadesCCI(List <Ejercicio>ejercicios, String idAsignatura){
    	String nombreRed = "red_asignatura_" + idAsignatura + ".xdsl";
		System.out.println("/home/redes/" + nombreRed);
		Network net = new Network();
		net.readFile("/home/redes/" + nombreRed);
    	
    	for(Ejercicio ejercicio : ejercicios){
    		
    		double[] ejercicioDef = calcularProbabilidadesCCI(ejercicio);
    		net.setNodeDefinition("E"+ejercicio.getIdEjercicio(), ejercicioDef);

    	}
		
		net.writeFile("/home/redes/" + nombreRed);
    }
    
    
    
    private void modificarConceptoRed(Concepto concepto, String tituloViejo) {
    	//operaciones sobre la red bayesiana con smile
    	String nombreRed = "red_asignatura_" + concepto.getTema().getAsignatura().getIdAsignatura() + ".xdsl";

		System.out.println("/home/redes/" + nombreRed);
		Network net = new Network();
		net.readFile("/home/redes/" + nombreRed);
		
		//se modifica el nombre del concepto
		String titulo = sp.convertirEspacioToGuion(concepto.getNombre());

		
		//cambiar formato nodo
		  System.out.println("titulo/" + titulo);
		    System.out.println("tituloViejo/" + tituloViejo);
		    
		    
		net.setNodeId(sp.convertirEspacioToGuion(tituloViejo), titulo);
	    net.setNodeName(titulo, titulo);
		
	  
	    
	    //cambiar formato nodo
		//se modifica la probabilidad
		double [] conceptoDef = new double [2];
		conceptoDef[1] = concepto.getApriori();
		conceptoDef[0] = 1 - conceptoDef[1];
		net.setNodeDefinition(titulo, conceptoDef);
		
		net.writeFile("/home/redes/" + nombreRed);
    }
    

	public void copiarRedAsignatura(Integer idAsignaturaPlanitilla, Asignatura asignatura){
		
		
		Asignatura asignaturaPlantilla = em.find( Asignatura.class, idAsignaturaPlanitilla);
		
		em.persist(asignatura);
		Profesor profesor = asignatura.getProfesor();
		//Asignatura asignatura = new Asignatura();
		Concepto concepto;
		Tema tema;
		Ejercicio ejercicio;
		Respuesta respuesta;
		ArrayList <Respuesta> respuestaList = new ArrayList();
		ArrayList <Concepto> conceptosList = new ArrayList();
		//Cargar los temas a una asignatura
		for(Tema temaPlantilla: asignaturaPlantilla.getTemaList()){
			
					
			tema = new Tema();
			tema.setNombre(temaPlantilla.getNombre());
			tema.setDescripcion(temaPlantilla.getDescripcion());
			tema.setPeso(temaPlantilla.getPeso());
			tema.setProfesor(profesor);
			tema.setAsignatura(asignatura);
			
			System.out.print("asignaturaaaaa " + asignatura.getIdAsignatura());
			//persiste el tema y agrega a la red
			em.persist(tema);
			
			System.out.println("tema: " + temaPlantilla.getNombre());
			//crear conceptos
			for(Concepto conceptoPlantilla : temaPlantilla.getConceptoList()){
				System.out.println("concepto " + conceptoPlantilla.getNombre());
				concepto = new Concepto();
				concepto.setAdivinanza(conceptoPlantilla.getAdivinanza());
				concepto.setApriori(conceptoPlantilla.getApriori());
				concepto.setDescripcion(conceptoPlantilla.getDescripcion());
				concepto.setDescuido(conceptoPlantilla.getDescuido());
				concepto.setNombre(conceptoPlantilla.getNombre());
				concepto.setPeso(conceptoPlantilla.getPeso());
				concepto.setProfesor(profesor);
				concepto.setTema(tema);
								//persistir el concepto y agregar a la red
				
				em.persist(concepto);
							
				
				
				
			}
			
			
			
		}
		em.flush();		
		List<Concepto> conceptoList = new ArrayList();
		String queryConceptosPlantillas = "select c from Concepto c  join c.tema t where t.asignatura = :asignatura";
		String queryEjercicios = "select DISTINCT  e from Ejercicio e join e.conceptoList c where c in (:conceptos)";

		String queryConceptos = "Select c from Concepto c where c.nombre = :nombre and c.descripcion = :descripcion and c.profesor = :profe order by c.idConcepto asc";
		List<Concepto> conceptos = em.createQuery(queryConceptosPlantillas)
				.setParameter("asignatura", asignaturaPlantilla).getResultList();

		System.out.println("tamanooooo conceptos " + conceptos.size());

		List<Ejercicio> ejercicios = em.createQuery(queryEjercicios)
				.setParameter("conceptos", conceptos).getResultList();

		System.out.println("tamanooooo " + ejercicios.size());

		for (Ejercicio ejercicioPlantilla : ejercicios) {

			ejercicio = new Ejercicio();
			ejercicio.setAdivinanza(ejercicioPlantilla.getAdivinanza());
			ejercicio.setEnunciado(ejercicioPlantilla.getEnunciado());
			ejercicio.setImagen(ejercicioPlantilla.getImagen());
			ejercicio.setNivelDificultad(ejercicioPlantilla
					.getNivelDificultad());
			ejercicio.setProfesor(profesor);
			ejercicio.setRespuesta(ejercicioPlantilla.getRespuesta());
            em.persist(ejercicio);
			// ejercicio.setConceptoList(ejercicioPlantilla.getConceptoList());
			// crear Respuestas para ejercicios
            em.flush();
			for (Concepto conceptoP : ejercicioPlantilla.getConceptoList()) {

				Concepto nuev = (Concepto) em
						.createQuery(queryConceptos)
						.setParameter("nombre", conceptoP.getNombre())
						.setParameter("descripcion", conceptoP.getDescripcion())
						.setParameter("profe", profesor).setMaxResults(1)
						.getSingleResult();

				conceptoList.add(nuev);

			}
			
			
			String queryRespuesta = "select r from Respuesta r join r.ejercicioList e where e = :ejercicio ";
			List <Respuesta>respuestas = em.createQuery(queryRespuesta).setParameter("ejercicio", ejercicioPlantilla).getResultList();
			for (Respuesta respuestaPlantilla : respuestas) {

				respuesta = new Respuesta();
				respuesta.setDescripcion(respuestaPlantilla.getDescripcion());

				respuestaList.add(respuesta);

			}
			
			ejercicio.setConceptoList(conceptoList);
			ejercicio.setRespuestaList(respuestaList);

			// agregar ejercicio a la red

			em.persist(ejercicio);
			
			conceptoList.clear();
		}
			
			
	}
		
	public int aPorcentaje (String valor) {
		
		Double val = Double.valueOf(valor);
		val = val * 100;
		int parteEntera = val.intValue();
		
		return parteEntera;
	}	
	
	public int aPorcentaje (Double valor) {
		
		Double val = valor;
		val = val * 100;
		int parteEntera = val.intValue();
		
		return parteEntera;
	}	
	
	public ArrayList <Object> registrarEjercicio(Asignatura asignatura, Integer idAlumno, Ejercicio ejercicio, Boolean respuesta){
		
		ArrayList<Object> datosFila = new ArrayList();
				
		String queryConceptos = "select c from Concepto c  join c.tema t where t.asignatura = :asignatura";
		Query query = em.createQuery(queryConceptos);
		query.setParameter("asignatura", asignatura);
		List <Concepto>conceptos = query.getResultList();
		List<Tema> temas= obtenerTemas(asignatura);
		//System.out.println("temas: " + temas.toString());
		//System.out.println("conceptos: " + conceptos.toString());


		datosFila.add(idAlumno);
		datosFila.add( getValorNodoRed(asignatura.getNombre(), asignatura.getIdAsignatura(), idAlumno));
		for(Tema tema : temas){
			String porcentajeTema = getValorNodoRed(tema.getNombre(), asignatura.getIdAsignatura(), idAlumno);
			datosFila.add(porcentajeTema);
		}
		
		for(Concepto concepto : conceptos){
			String porcentajeConcepto = getValorNodoRed(concepto.getNombre(), asignatura.getIdAsignatura(), idAlumno);
			datosFila.add(porcentajeConcepto);
		}
		datosFila.add(ejercicio.getIdEjercicio());
		datosFila.add(ejercicio.getAdivinanza());
		datosFila.add(ejercicio.getNivelDificultad());
		datosFila.add((respuesta)?"SI":"NO");
		datosFila.add("\r");

		return datosFila;
		
	}
	
	public Tarea obtenerTarea(Integer idTarea){
		
		Tarea tarea = em.find(Tarea.class, idTarea);
		return tarea;
	}
	
	public Asignatura obtenerAsignatura (Integer idAsignatura){
		
		return em.find(Asignatura.class, idAsignatura);
		
	}
	
	public Ejercicio obtenerEjercicio(Integer id){
		
		return em.find(Ejercicio.class, id);
		
	}
	
	public List obtenerRespuestas(Ejercicio ejercicio){
		String queryRespuesta = "select r from Respuesta r join r.ejercicioList e where e = :ejercicio ";
		List <Respuesta>respuestas = em.createQuery(queryRespuesta).setParameter("ejercicio", ejercicio).getResultList();
		return respuestas;
	}
	
	public List obtenerTemas(Asignatura asignatura){
		List<Tema> temaList = (List<Tema>) em.createQuery("Select e from Tema e where e.asignatura=:asignatura" )
				.setParameter("asignatura", asignatura).getResultList() ;
		return temaList;
	}

}