package modelo;

import java.util.ArrayList;
import java.util.Observable;
import javax.swing.JOptionPane;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Result;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.w3c.dom.DOMImplementation;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Text;


// <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
// #[regen=yes,id=DCE.6152FD4C-6D23-B415-B6AA-5E3083D32571]
// </editor-fold> 
public class DocumentoReq extends Observable{

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.CCA1F4F7-57C3-AD84-BE75-1BB551CFC3E5]
    // </editor-fold> 
    private ArrayList<CasodeUso> mCasodeUso = new ArrayList();
    private ArrayList<ReqFuncional> mReqFunc = new ArrayList();
    private ArrayList<ReqNoFuncional> mReqNoFunc = new ArrayList();
    private ArrayList<ReqInformacion> mReqInfo = new ArrayList();
    private ArrayList<ReqRestriccion> mReqRest = new ArrayList();
    private ArrayList<Participante> mParticipante = new ArrayList();
    private ArrayList<Objetivos> mObjetivos = new ArrayList();
    private ArrayList<Reunion> mReunion = new ArrayList();

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.1D51ABF1-2DD9-82E3-126D-173DEB5FADBA]
    // </editor-fold> 
    public DocumentoReq () {
    }

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.A9A64C79-62B1-D6C4-FB8A-BCD4EF81E5C4]
    // </editor-fold> 
    public ArrayList<CasodeUso> getCasodeUso () {
        return mCasodeUso;
    }

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.53D39B7F-03CC-D44E-1C6A-CB6F6C02538E]
    // </editor-fold> 
    public void setCasodeUso (ArrayList<CasodeUso> val) {
         this.mCasodeUso=val;
         //Notificamos que ha habido un cambio
         this.setChanged();
         this.notifyObservers();
    }
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.3DF3139E-17FC-1508-86A3-908C60405553]
    // </editor-fold> 
    public CasodeUso nuevoCU (String nombreCU, boolean esAbstracto, String eventoActivacion, int frecuencia, String unidadFrecuencia, String precondicion, String postcondicion, String importancia, String urgencia, String estadodeDesarrollo, String estabilidad) {

        //// Creo la instancia
        CasodeUso auxCU=new CasodeUso();
        //// Asigno los valores a los atributos
        auxCU.setNombre(nombreCU);
        auxCU.setEsAbstracto(esAbstracto);
        auxCU.setEventoActivacion(eventoActivacion);
        auxCU.setFrecuencia(frecuencia);
        auxCU.setUnidadFrecuencia(unidadFrecuencia);
        auxCU.setPrecondicion(precondicion);
        auxCU.setPostcondicion(postcondicion);
        auxCU.setImportancia(importancia);
        auxCU.setUrgencia(urgencia);
        auxCU.setEstadodeDesarrollo(estadodeDesarrollo);
        auxCU.setEstabilidad(estabilidad);
        //// Enlazo el CasodeUso a la lista de CU que tiene el documento
        this.getCasodeUso().add(auxCU);
        //Notificamos que ha habido un cambio
         this.setChanged();
         this.notifyObservers();
        return auxCU;
    }
    public ReqFuncional nuevoReqFunc(String nombre,
                           String autores,
                           String Fuentes,
                           String comentarios,
                           String importancia,
                           String urgencia,
                           String estadoDes,
                           String estabilidad,
                           String descripcion)
    {
        ReqFuncional aux = new ReqFuncional();
        aux.setNombre(nombre);
        aux.setAutores(autores);
        aux.setFuentes(Fuentes);
        aux.setComentarios(comentarios);
        aux.setImportancia(importancia);
        aux.setUrgencia(urgencia);
        aux.setEstadoDes(estadoDes);
        aux.setEstabilidad(estabilidad);
        aux.setDescripcion(descripcion);
        this.getmReqFunc().add(aux);
        //Notificamos que ha habido un cambio
         this.setChanged();
         this.notifyObservers();
        return aux;
    }
    public ReqNoFuncional nuevoReqNoFunc(String nombre,
                           String autores,
                           String Fuentes,
                           String comentarios,
                           String importancia,
                           String urgencia,
                           String estadoDes,
                           String estabilidad,
                           String descripcion)
    {
        ReqNoFuncional aux = new ReqNoFuncional();
        aux.setNombre(nombre);
        aux.setAutores(autores);
        aux.setFuentes(Fuentes);
        aux.setComentarios(comentarios);
        aux.setImportancia(importancia);
        aux.setUrgencia(urgencia);
        aux.setEstadoDes(estadoDes);
        aux.setEstabilidad(estabilidad);
        aux.setDescripcion(descripcion);
        this.getmReqNoFunc().add(aux);
        //Notificamos que ha habido un cambio
         this.setChanged();
         this.notifyObservers();
        return aux;
    }
    public ReqRestriccion nuevoReqRest(String nombre,
                           String autores,
                           String Fuentes,
                           String comentarios,
                           String importancia,
                           String urgencia,
                           String estadoDes,
                           String estabilidad,
                           String descripcion)
    {
        ReqRestriccion aux = new ReqRestriccion();
        aux.setNombre(nombre);
        aux.setAutores(autores);
        aux.setFuentes(Fuentes);
        aux.setComentarios(comentarios);
        aux.setImportancia(importancia);
        aux.setUrgencia(urgencia);
        aux.setEstadoDes(estadoDes);
        aux.setEstabilidad(estabilidad);
        aux.setDescripcion(descripcion);
        this.getmReqRest().add(aux);
        //Notificamos que ha habido un cambio
         this.setChanged();
         this.notifyObservers();
        return aux;
    }
    public ReqInformacion nuevoReqInfo(String nombre,
                                       String autores,
                                       String Fuentes,
                                       String importancia,
                                       String urgencia,
                                       String estadoDes,
                                       String estabilidad,
                                       String comentarios,
                                       String conceptoRelevante,
                                       int tiempoMax,
                                       int tiempoMed,
                                       String unifreqmax,
                                       String unifreqmed,
                                       int numOcurrencias,
                                       int numMedio)
    {
        ReqInformacion aux = new ReqInformacion();
        aux.setNombre(nombre);
        aux.setAutores(autores);
        aux.setFuentes(Fuentes);
        aux.setComentarios(comentarios);
        aux.setImportancia(importancia);
        aux.setUrgencia(urgencia);
        aux.setEstadoDes(estadoDes);
        aux.setEstabilidad(estabilidad);
        aux.setConceptoRelevante(conceptoRelevante);
        aux.setTiempoMaxVida(tiempoMax);
        aux.setTiempoMedVida(tiempoMed);
        aux.setUnidadFreqMax(unifreqmax);
        aux.setUnidadFreqMed(unifreqmed);
        aux.setNumOcurrencias(numOcurrencias);
        aux.setNumMedio(numMedio);
        this.getmReqInfo().add(aux);
        //Notificamos que ha habido un cambio
         this.setChanged();
         this.notifyObservers();
        return aux;
    }

    public ArrayList<ReqFuncional> getmReqFunc() {
        return mReqFunc;
    }

    /**
     * @param mReqFunc the mReqFunc to set
     */
    public void setmReqFunc(ArrayList<ReqFuncional> mReqFunc) {
        this.mReqFunc = mReqFunc;
        //Notificamos que ha habido un cambio
         this.setChanged();
         this.notifyObservers();
    }

    /**
     * @return the mReqNoFunc
     */
    public ArrayList<ReqNoFuncional> getmReqNoFunc() {
        return mReqNoFunc;
    }

    /**
     * @param mReqNoFunc the mReqNoFunc to set
     */
    public void setmReqNoFunc(ArrayList<ReqNoFuncional> mReqNoFunc) {
        this.mReqNoFunc = mReqNoFunc;
        //Notificamos que ha habido un cambio
         this.setChanged();
         this.notifyObservers();
    }

    /**
     * @return the mReqInfo
     */
    public ArrayList<ReqInformacion> getmReqInfo() {
        return mReqInfo;
    }

    public void setmReqInfo(ArrayList<ReqInformacion> mReqInfo) {
        this.mReqInfo = mReqInfo;
        //Notificamos que ha habido un cambio
         this.setChanged();
         this.notifyObservers();
    }

    /**
     * @return the mReqRest
     */
    public ArrayList<ReqRestriccion> getmReqRest() {
        return mReqRest;
    }

    /**
     * @param mReqRest the mReqRest to set
     */
    public void setmReqRest(ArrayList<ReqRestriccion> mReqRest) {
        this.mReqRest = mReqRest;
        //Notificamos que ha habido un cambio
        this.setChanged();
        this.notifyObservers();
    }

    public void toXML(){
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        try{
            DocumentBuilder builder = factory.newDocumentBuilder();
            DOMImplementation implementation = builder.getDOMImplementation();
            Document document = implementation.createDocument(null, "xml", null);

            Element raiz = document.createElement("Documento"); // creamos el elemento raiz
            document.setXmlVersion("1.0"); // asignamos la version de nuestro XML
            document.getDocumentElement().appendChild(raiz); //pegamos la raiz al documento

            //A PARTIR DE AQUI SE VA MANEJANDO CADA ELEMENTO (CU,REQUISITO FUNCIONAL...)
            int numCasosUso = this.mCasodeUso.size();
            if(numCasosUso!=0)
            {
                //CREAMOS LOS DISTINTOS ELEMENTOS Y TEXT
               Element CasoU = document.createElement("CasodeUso");

               Element nombre,esAbstracto,eventoActivacion,frecuencia,unidadFrecuencia,precondicion,postcondicion,importancia,urgencia,estadodeDesarrollo,estabilidad;
               Text tnombre,tesAbstracto,teventoActivacion,tfrecuencia,tunidadFrecuencia,tprecondicion,tpostcondicion,timportancia,turgencia,testadodeDesarrollo,testabilidad;
               for (int i=0;i<numCasosUso;i++)
               {

                  //creamos cada atributo con su nombre
                  nombre=document.createElement("nombre");
                  esAbstracto=document.createElement("esAbstracto");
                  eventoActivacion=document.createElement("eventoActivacion");
                  frecuencia=document.createElement("frecuencia");
                  unidadFrecuencia=document.createElement("unidadFrecuencia");
                  precondicion=document.createElement("precondicion");
                  postcondicion=document.createElement("postcondicion");
                  importancia=document.createElement("importancia");
                  urgencia=document.createElement("urgencia");
                  estadodeDesarrollo=document.createElement("estadodeDesarrollo");
                  estabilidad=document.createElement("estabilidad");

                  //Introducimos el text
                  if(mCasodeUso.get(i).getEsAbstracto() == true)
                  {
                     tesAbstracto = document.createTextNode("SI"); //Ingresamos la info
                  }
                  else
                  {
                      tesAbstracto = document.createTextNode("NO"); //Ingresamos la info
                  }

                  String frecuencia1=String.valueOf(mCasodeUso.get(i).getFrecuencia());
                  tnombre=document.createTextNode(mCasodeUso.get(i).getNombre());
                  teventoActivacion=document.createTextNode(mCasodeUso.get(i).getEventoActivacion());
                  tfrecuencia=document.createTextNode(frecuencia1);
                  tunidadFrecuencia=document.createTextNode(mCasodeUso.get(i).getUnidadFrecuencia());
                  tprecondicion=document.createTextNode(mCasodeUso.get(i).getPrecondicion());
                  tpostcondicion=document.createTextNode(mCasodeUso.get(i).getPostcondicion());
                  timportancia=document.createTextNode(mCasodeUso.get(i).getImportancia());
                  turgencia=document.createTextNode(mCasodeUso.get(i).getUrgencia());
                  testadodeDesarrollo=document.createTextNode(mCasodeUso.get(i).getEstadodeDesarrollo());
                  testabilidad=document.createTextNode(mCasodeUso.get(i).getEstabilidad());

                  //enlazamos cada texto con su atributo
                  nombre.appendChild(tnombre);
                  esAbstracto.appendChild(tesAbstracto);
                  eventoActivacion.appendChild(teventoActivacion);
                  frecuencia.appendChild(tfrecuencia);
                  unidadFrecuencia.appendChild(tunidadFrecuencia);
                  precondicion.appendChild(tprecondicion);
                  postcondicion.appendChild(tpostcondicion);
                  importancia.appendChild(timportancia);
                  urgencia.appendChild(turgencia);
                  estadodeDesarrollo.appendChild(testadodeDesarrollo);
                  estabilidad.appendChild(testabilidad);

                  //enlazamos cada atributo a su caso de uso
                  CasoU.appendChild(nombre);
                  CasoU.appendChild(esAbstracto);
                  CasoU.appendChild(eventoActivacion);
                  CasoU.appendChild(frecuencia);
                  CasoU.appendChild(unidadFrecuencia);
                  CasoU.appendChild(precondicion);
                  CasoU.appendChild(postcondicion);
                  CasoU.appendChild(importancia);
                  CasoU.appendChild(urgencia);
                  CasoU.appendChild(estadodeDesarrollo);
                  CasoU.appendChild(estabilidad);

               }
               raiz.appendChild(CasoU); //pegamos el elemento hijo a la raiz
            }


            int numRF = this.mReqFunc.size();
            if (numRF!=0)
            {
                  //CREAMOS LOS DISTINTOS ELEMENTOS Y TEXT
               Element ReqFunc = document.createElement("ReqFun");

               Element nombre,autores,fuentes,comentarios,importancia,urgencia,estadoDes,estabilidad,descripcion;
               Text tnombre,tautores,tfuentes,tcomentarios,timportancia,turgencia,testadoDes,testabilidad,tdescripcion;
               for (int i=0;i<numRF;i++)
               {

                  //creamos cada atributo con su nombre
                  nombre=document.createElement("nombre");
                  autores=document.createElement("autores");
                  fuentes=document.createElement("fuentes");
                  comentarios=document.createElement("comentarios");
                  importancia=document.createElement("importancia");
                  urgencia=document.createElement("urgencia");
                  estadoDes=document.createElement("estadoDes");
                  estabilidad=document.createElement("estabilidad");
                  descripcion=document.createElement("descripcion");

                  //Introducimos el text

                  tnombre=document.createTextNode(mReqFunc.get(i).getNombre());
                  tautores=document.createTextNode(mReqFunc.get(i).getAutores());
                  tfuentes=document.createTextNode(mReqFunc.get(i).getFuentes());
                  tcomentarios=document.createTextNode(mReqFunc.get(i).getComentarios());
                  timportancia=document.createTextNode(mReqFunc.get(i).getImportancia());
                  turgencia=document.createTextNode(mReqFunc.get(i).getUrgencia());
                  testadoDes=document.createTextNode(mReqFunc.get(i).getEstadoDes());
                  testabilidad=document.createTextNode(mReqFunc.get(i).getEstabilidad());
                  tdescripcion=document.createTextNode(mReqFunc.get(i).getDescripcion());

                  //enlazamos cada texto con su atributo
                  nombre.appendChild(tnombre);
                  autores.appendChild(tautores);
                  fuentes.appendChild(tfuentes);
                  comentarios.appendChild(tcomentarios);
                  importancia.appendChild(timportancia);
                  urgencia.appendChild(turgencia);
                  estadoDes.appendChild(testadoDes);
                  estabilidad.appendChild(testabilidad);
                  descripcion.appendChild(tdescripcion);

                  //enlazamos cada atributo a su caso de uso
                  ReqFunc.appendChild(nombre);
                  ReqFunc.appendChild(autores);
                  ReqFunc.appendChild(fuentes);
                  ReqFunc.appendChild(comentarios);
                  ReqFunc.appendChild(importancia);
                  ReqFunc.appendChild(urgencia);
                  ReqFunc.appendChild(estadoDes);
                  ReqFunc.appendChild(estabilidad);
                  ReqFunc.appendChild(descripcion);

               }
               raiz.appendChild(ReqFunc); //pegamos el elemento hijo a la raiz

            }

            int numRNF = this.mReqNoFunc.size();
            if (numRNF!=0)
            {
                   //CREAMOS LOS DISTINTOS ELEMENTOS Y TEXT
               Element ReqNoFunc = document.createElement("ReqNoFun");

               Element nombre,autores,fuentes,comentarios,importancia,urgencia,estadoDes,estabilidad,descripcion;
               Text tnombre,tautores,tfuentes,tcomentarios,timportancia,turgencia,testadoDes,testabilidad,tdescripcion;
               for (int i=0;i<numRNF;i++)
               {

                  //creamos cada atributo con su nombre
                  nombre=document.createElement("nombre");
                  autores=document.createElement("autores");
                  fuentes=document.createElement("fuentes");
                  comentarios=document.createElement("comentarios");
                  importancia=document.createElement("importancia");
                  urgencia=document.createElement("urgencia");
                  estadoDes=document.createElement("estadoDes");
                  estabilidad=document.createElement("estabilidad");
                  descripcion=document.createElement("descripcion");

                  //Introducimos el text

                  tnombre=document.createTextNode(mReqNoFunc.get(i).getNombre());
                  tautores=document.createTextNode(mReqNoFunc.get(i).getAutores());
                  tfuentes=document.createTextNode(mReqNoFunc.get(i).getFuentes());
                  tcomentarios=document.createTextNode(mReqNoFunc.get(i).getComentarios());
                  timportancia=document.createTextNode(mReqNoFunc.get(i).getImportancia());
                  turgencia=document.createTextNode(mReqNoFunc.get(i).getUrgencia());
                  testadoDes=document.createTextNode(mReqNoFunc.get(i).getEstadoDes());
                  testabilidad=document.createTextNode(mReqNoFunc.get(i).getEstabilidad());
                  tdescripcion=document.createTextNode(mReqNoFunc.get(i).getDescripcion());

                  //enlazamos cada texto con su atributo
                  nombre.appendChild(tnombre);
                  autores.appendChild(tautores);
                  fuentes.appendChild(tfuentes);
                  comentarios.appendChild(tcomentarios);
                  importancia.appendChild(timportancia);
                  urgencia.appendChild(turgencia);
                  estadoDes.appendChild(testadoDes);
                  estabilidad.appendChild(testabilidad);
                  descripcion.appendChild(tdescripcion);

                  //enlazamos cada atributo a su caso de uso
                  ReqNoFunc.appendChild(nombre);
                  ReqNoFunc.appendChild(autores);
                  ReqNoFunc.appendChild(fuentes);
                  ReqNoFunc.appendChild(comentarios);
                  ReqNoFunc.appendChild(importancia);
                  ReqNoFunc.appendChild(urgencia);
                  ReqNoFunc.appendChild(estadoDes);
                  ReqNoFunc.appendChild(estabilidad);
                  ReqNoFunc.appendChild(descripcion);

               }
               raiz.appendChild(ReqNoFunc); //pegamos el elemento hijo a la raiz

            }

            int numRInfo = this.mReqInfo.size();
            if (numRInfo!=0)
            {
                    //CREAMOS LOS DISTINTOS ELEMENTOS Y TEXT
               Element ReqInfo = document.createElement("ReqInf");

               Element nombre,autores,fuentes,comentarios,importancia,urgencia,estadoDes,estabilidad,conceptoRelevante,tiempoMaxVida,tiempoMedVida,unidadFreqMax,unidadFreqMed,numOcurrencias,numMedio;
               Text tnombre,tautores,tfuentes,tcomentarios,timportancia,turgencia,testadoDes,testabilidad,tconceptoRelevante,ttiempoMaxVida,ttiempoMedVida,tunidadFreqMax,tunidadFreqMed,tnumOcurrencias,tnumMedio;
               for (int i=0;i<numRInfo;i++)
               {

                  //creamos cada atributo con su nombre
                  nombre=document.createElement("nombre");
                  autores=document.createElement("autores");
                  fuentes=document.createElement("fuentes");
                  comentarios=document.createElement("comentarios");
                  importancia=document.createElement("importancia");
                  urgencia=document.createElement("urgencia");
                  estadoDes=document.createElement("estadoDes");
                  estabilidad=document.createElement("estabilidad");
                  conceptoRelevante=document.createElement("conceptoRelevante");
                  tiempoMaxVida=document.createElement("tiempoMaxVida");
                  tiempoMedVida=document.createElement("tiempoMedVida");
                  unidadFreqMax=document.createElement("unidadFreqMax");
                  unidadFreqMed=document.createElement("unidadFreqMed");
                  numOcurrencias=document.createElement("numOcurrencias");
                  numMedio=document.createElement("numMedio");
                  //Introducimos el text

                  String tiempoMaxVida1=String.valueOf(mReqInfo.get(i).getTiempoMaxVida());
                  String tiempoMedVida1=String.valueOf(mReqInfo.get(i).getTiempoMedVida());
                  String numOcurrencias1=String.valueOf(mReqInfo.get(i).getNumOcurrencias());
                  String numMedio1=String.valueOf(mReqInfo.get(i).getNumMedio());
                  tnombre=document.createTextNode(mReqInfo.get(i).getNombre());
                  tautores=document.createTextNode(mReqInfo.get(i).getAutores());
                  tfuentes=document.createTextNode(mReqInfo.get(i).getFuentes());
                  tcomentarios=document.createTextNode(mReqInfo.get(i).getComentarios());
                  timportancia=document.createTextNode(mReqInfo.get(i).getImportancia());
                  turgencia=document.createTextNode(mReqInfo.get(i).getUrgencia());
                  testadoDes=document.createTextNode(mReqInfo.get(i).getEstadoDes());
                  testabilidad=document.createTextNode(mReqInfo.get(i).getEstabilidad());
                  tconceptoRelevante=document.createTextNode(mReqInfo.get(i).getConceptoRelevante());
                  ttiempoMaxVida=document.createTextNode(tiempoMaxVida1);
                  ttiempoMedVida=document.createTextNode(tiempoMedVida1);
                  tunidadFreqMax=document.createTextNode(mReqInfo.get(i).getUnidadFreqMax());
                  tunidadFreqMed=document.createTextNode(mReqInfo.get(i).getUnidadFreqMed());
                  tnumOcurrencias=document.createTextNode(numOcurrencias1);
                  tnumMedio=document.createTextNode(numMedio1);


                  //enlazamos cada texto con su atributo
                  nombre.appendChild(tnombre);
                  autores.appendChild(tautores);
                  fuentes.appendChild(tfuentes);
                  comentarios.appendChild(tcomentarios);
                  importancia.appendChild(timportancia);
                  urgencia.appendChild(turgencia);
                  estadoDes.appendChild(testadoDes);
                  estabilidad.appendChild(testabilidad);
                  conceptoRelevante.appendChild(tconceptoRelevante);
                  tiempoMaxVida.appendChild(ttiempoMaxVida);
                  tiempoMedVida.appendChild(ttiempoMedVida);
                  unidadFreqMax.appendChild(tunidadFreqMax);
                  unidadFreqMed.appendChild(tunidadFreqMed);
                  numOcurrencias.appendChild(tnumOcurrencias);
                  numMedio.appendChild(tnumMedio);

                  //enlazamos cada atributo a su caso de uso
                  ReqInfo.appendChild(nombre);
                  ReqInfo.appendChild(autores);
                  ReqInfo.appendChild(fuentes);
                  ReqInfo.appendChild(comentarios);
                  ReqInfo.appendChild(importancia);
                  ReqInfo.appendChild(urgencia);
                  ReqInfo.appendChild(estadoDes);
                  ReqInfo.appendChild(estabilidad);
                  ReqInfo.appendChild(conceptoRelevante);
                  ReqInfo.appendChild(tiempoMaxVida);
                  ReqInfo.appendChild(tiempoMedVida);
                  ReqInfo.appendChild(unidadFreqMax);
                  ReqInfo.appendChild(unidadFreqMed);
                  ReqInfo.appendChild(numOcurrencias);
                  ReqInfo.appendChild(numMedio);

               }
               raiz.appendChild(ReqInfo); //pegamos el elemento hijo a la raiz

            }

            int numRest = this.mReqRest.size();
            if (numRest!=0)
            {
                   //CREAMOS LOS DISTINTOS ELEMENTOS Y TEXT
               Element ReqRest = document.createElement("ReqRestri");

               Element nombre,autores,fuentes,comentarios,importancia,urgencia,estadoDes,estabilidad,descripcion;
               Text tnombre,tautores,tfuentes,tcomentarios,timportancia,turgencia,testadoDes,testabilidad,tdescripcion;
               for (int i=0;i<numRest;i++)
               {

                  //creamos cada atributo con su nombre
                  nombre=document.createElement("nombre");
                  autores=document.createElement("autores");
                  fuentes=document.createElement("fuentes");
                  comentarios=document.createElement("comentarios");
                  importancia=document.createElement("importancia");
                  urgencia=document.createElement("urgencia");
                  estadoDes=document.createElement("estadoDes");
                  estabilidad=document.createElement("estabilidad");
                  descripcion=document.createElement("descripcion");

                  //Introducimos el text

                  tnombre=document.createTextNode(mReqRest.get(i).getNombre());
                  tautores=document.createTextNode(mReqRest.get(i).getAutores());
                  tfuentes=document.createTextNode(mReqRest.get(i).getFuentes());
                  tcomentarios=document.createTextNode(mReqRest.get(i).getComentarios());
                  timportancia=document.createTextNode(mReqRest.get(i).getImportancia());
                  turgencia=document.createTextNode(mReqRest.get(i).getUrgencia());
                  testadoDes=document.createTextNode(mReqRest.get(i).getEstadoDes());
                  testabilidad=document.createTextNode(mReqRest.get(i).getEstabilidad());
                  tdescripcion=document.createTextNode(mReqRest.get(i).getDescripcion());

                  //enlazamos cada texto con su atributo
                  nombre.appendChild(tnombre);
                  autores.appendChild(tautores);
                  fuentes.appendChild(tfuentes);
                  comentarios.appendChild(tcomentarios);
                  importancia.appendChild(timportancia);
                  urgencia.appendChild(turgencia);
                  estadoDes.appendChild(testadoDes);
                  estabilidad.appendChild(testabilidad);
                  descripcion.appendChild(tdescripcion);

                  //enlazamos cada atributo a su caso de uso
                  ReqRest.appendChild(nombre);
                  ReqRest.appendChild(autores);
                  ReqRest.appendChild(fuentes);
                  ReqRest.appendChild(comentarios);
                  ReqRest.appendChild(importancia);
                  ReqRest.appendChild(urgencia);
                  ReqRest.appendChild(estadoDes);
                  ReqRest.appendChild(estabilidad);
                  ReqRest.appendChild(descripcion);

               }
               raiz.appendChild(ReqRest); //pegamos el elemento hijo a la raiz

            }


            int numPart = this.mParticipante.size();
            if (numPart!=0)
            {
                   //CREAMOS LOS DISTINTOS ELEMENTOS Y TEXT
               Element Participante = document.createElement("participante");

               Element nombre,esUsuario,esCliente,esDesarrollador,rol,organizacion,autores,fuentes;
               Text tnombre,tesUsuario,tesCliente,tesDesarrollador,trol,torganizacion,tautores,tfuentes;
               for (int i=0;i<numPart;i++)
               {

                  //creamos cada atributo con su nombre
                  nombre=document.createElement("nombre");
                  esUsuario=document.createElement("esUsuario");
                  esCliente=document.createElement("esCliente");
                  esDesarrollador=document.createElement("esDesarrollador");
                  rol=document.createElement("rol");
                  organizacion=document.createElement("organizacion");
                  autores=document.createElement("autores");
                  fuentes=document.createElement("fuentes");

                  //Introducimos el text

                  tnombre=document.createTextNode(mParticipante.get(i).getNombre());
                  if(mParticipante.get(i).getEsUsuario()==true)
                  {
                    tesUsuario=document.createTextNode("SI");
                  }
                  else
                  {
                      tesUsuario=document.createTextNode("NO");
                  }
                  if(mParticipante.get(i).getEsCliente()==true)
                  {
                    tesCliente=document.createTextNode("SI");
                  }
                  else
                  {
                      tesCliente=document.createTextNode("NO");
                  }
                  if(mParticipante.get(i).getEsDesarrollador()==true)
                  {
                    tesDesarrollador=document.createTextNode("SI");
                  }
                  else
                  {
                      tesDesarrollador=document.createTextNode("NO");
                  }
                  trol=document.createTextNode(mParticipante.get(i).getRol());
                  torganizacion=document.createTextNode(mParticipante.get(i).getOrganizacion());
                  tfuentes=document.createTextNode(mParticipante.get(i).getFuentes());
                  tautores=document.createTextNode(mParticipante.get(i).getAutores());
                  //enlazamos cada texto con su atributo
                  nombre.appendChild(tnombre);
                  esUsuario.appendChild(tesUsuario);
                  esCliente.appendChild(tesCliente);
                  esDesarrollador.appendChild(tesDesarrollador);
                  rol.appendChild(trol);
                  organizacion.appendChild(torganizacion);
                  fuentes.appendChild(tfuentes);
                  autores.appendChild(tautores);

                  //enlazamos cada atributo a su caso de uso
                  Participante.appendChild(nombre);
                  Participante.appendChild(esUsuario);
                  Participante.appendChild(esCliente);
                  Participante.appendChild(esDesarrollador);
                  Participante.appendChild(rol);
                  Participante.appendChild(organizacion);
                  Participante.appendChild(fuentes);
                  Participante.appendChild(autores);

               }
               raiz.appendChild(Participante); //pegamos el elemento hijo a la raiz

            }
            int numObj = this.mObjetivos.size();
            if (numObj!=0)
            {
                   //CREAMOS LOS DISTINTOS ELEMENTOS Y TEXT
               Element Objetivo = document.createElement("objetivo");

               Element nombre,autores,fuentes,comentarios,importancia,urgencia,estadoDes,estabilidad,descripcion;
               Text tnombre,tautores,tfuentes,tcomentarios,timportancia,turgencia,testadoDes,testabilidad,tdescripcion;
               for (int i=0;i<numObj;i++)
               {

                  //creamos cada atributo con su nombre
                  nombre=document.createElement("nombre");
                  autores=document.createElement("autores");
                  fuentes=document.createElement("fuentes");
                  comentarios=document.createElement("comentarios");
                  importancia=document.createElement("importancia");
                  urgencia=document.createElement("urgencia");
                  estadoDes=document.createElement("estadoDes");
                  estabilidad=document.createElement("estabilidad");
                  descripcion=document.createElement("descripcion");

                  //Introducimos el text

                  tnombre=document.createTextNode(mObjetivos.get(i).getNombre());
                  tautores=document.createTextNode(mObjetivos.get(i).getAutores());
                  tfuentes=document.createTextNode(mObjetivos.get(i).getFuentes());
                  tcomentarios=document.createTextNode(mObjetivos.get(i).getComentarios());
                  timportancia=document.createTextNode(mObjetivos.get(i).getImportancia());
                  turgencia=document.createTextNode(mObjetivos.get(i).getUrgencia());
                  testadoDes=document.createTextNode(mObjetivos.get(i).getEstadoDes());
                  testabilidad=document.createTextNode(mObjetivos.get(i).getEstabilidad());
                  tdescripcion=document.createTextNode(mObjetivos.get(i).getDescripcion());

                  //enlazamos cada texto con su atributo
                  nombre.appendChild(tnombre);
                  autores.appendChild(tautores);
                  fuentes.appendChild(tfuentes);
                  comentarios.appendChild(tcomentarios);
                  importancia.appendChild(timportancia);
                  urgencia.appendChild(turgencia);
                  estadoDes.appendChild(testadoDes);
                  estabilidad.appendChild(testabilidad);
                  descripcion.appendChild(tdescripcion);

                  //enlazamos cada atributo a su caso de uso
                  Objetivo.appendChild(nombre);
                  Objetivo.appendChild(autores);
                  Objetivo.appendChild(fuentes);
                  Objetivo.appendChild(comentarios);
                  Objetivo.appendChild(importancia);
                  Objetivo.appendChild(urgencia);
                  Objetivo.appendChild(estadoDes);
                  Objetivo.appendChild(estabilidad);
                  Objetivo.appendChild(descripcion);

               }
               raiz.appendChild(Objetivo); //pegamos el elemento hijo a la raiz

            }
            int numReu = this.mReunion.size();
            if (numReu!=0)
            {
                   //CREAMOS LOS DISTINTOS ELEMENTOS Y TEXT
               Element Reunion = document.createElement("reunion");

               Element nombre,autores,fuentes,comentarios,resultado,lugar,asistentes;
               Text tnombre,tautores,tfuentes,tcomentarios,tresultado,tlugar,tasistentes;
               for (int i=0;i<numReu;i++)
               {

                  //creamos cada atributo con su nombre
                  nombre=document.createElement("nombre");
                  autores=document.createElement("autores");
                  fuentes=document.createElement("fuentes");
                  comentarios=document.createElement("comentarios");
                  resultado=document.createElement("resultado");
                  lugar=document.createElement("lugar");
                  asistentes=document.createElement("asistentes");

                  //Introducimos el text

                  tnombre=document.createTextNode(mReunion.get(i).getNombre());
                  tautores=document.createTextNode(mReunion.get(i).getAutores());
                  tfuentes=document.createTextNode(mReunion.get(i).getFuentes());
                  tcomentarios=document.createTextNode(mReunion.get(i).getComentario());
                  tresultado=document.createTextNode(mReunion.get(i).getResultados());
                  tlugar=document.createTextNode(mReunion.get(i).getLugar());
                  tasistentes=document.createTextNode(mReunion.get(i).getAsistentes());

                  //enlazamos cada texto con su atributo
                  nombre.appendChild(tnombre);
                  autores.appendChild(tautores);
                  fuentes.appendChild(tfuentes);
                  comentarios.appendChild(tcomentarios);
                  resultado.appendChild(tresultado);
                  lugar.appendChild(tlugar);
                  asistentes.appendChild(tasistentes);

                  //enlazamos cada atributo a su caso de uso
                  Reunion.appendChild(nombre);
                  Reunion.appendChild(autores);
                  Reunion.appendChild(fuentes);
                  Reunion.appendChild(comentarios);
                  Reunion.appendChild(resultado);
                  Reunion.appendChild(lugar);
                  Reunion.appendChild(asistentes);

               }
               raiz.appendChild(Reunion); //pegamos el elemento hijo a la raiz

            }

            //guardamos en resultado.xml
            Source source = new DOMSource(document);
            Result result = new StreamResult(new java.io.File("resultado.xml")); //nombre del archivo
            Result console= new StreamResult(System.out);
            Transformer transformer = TransformerFactory.newInstance().newTransformer();
            transformer.transform(source, result);
            transformer.transform(source, console);
        }
        catch(Exception e){
            System.err.println("Error: "+e);
        }

    }
        private void mostrarMensaje(String mensaje) {
                JOptionPane.showMessageDialog(null, mensaje);
        }

        public ArrayList<Participante> getmParticipante() {
        return mParticipante;
    }

    /**
     * @param mParticipante the mParticipante to set
     */
    public void setmParticipante(ArrayList<Participante> mParticipante) {
        this.mParticipante = mParticipante;
        //Notificamos que ha habido un cambio
         this.setChanged();
         this.notifyObservers();
    }

    public Participante nuevoParticipante(String nombre,
                           boolean esUsuario,
                           boolean esCliente,
                           boolean esDesarrollador,
                           String rol,
                           String organizacion,
                           String autores,
                           String fuentes)
    {
        Participante aux = new Participante();
        aux.setNombre(nombre);
        aux.setEsUsuario(esUsuario);
        aux.setEsCliente(esCliente);
        aux.setEsDesarrollador(esDesarrollador);
        aux.setRol(rol);
        aux.setOrganizacion(organizacion);
        aux.setAutores(autores);
        aux.setFuentes(fuentes);
        this.getmParticipante().add(aux);
        //Notificamos que ha habido un cambio
         this.setChanged();
         this.notifyObservers();
        return aux;
    }

    /**
     * @return the mObjetivos
     */
    public ArrayList<Objetivos> getmObjetivos() {
        return mObjetivos;
    }

    /**
     * @param mObjetivos the mObjetivos to set
     */
    public void setmObjetivos(ArrayList<Objetivos> mObjetivos) {
        this.mObjetivos = mObjetivos;
        //Notificamos que ha habido un cambio
         this.setChanged();
         this.notifyObservers();
    }

    public Objetivos nuevoObjetivo(String nombre,
                                       String autores,
                                       String Fuentes,
                                       String descripcion,
                                       String comentarios,
                                       String importancia,
                                       String urgencia,
                                       String estadoDes,
                                       String estabilidad)
    {
        Objetivos aux = new Objetivos();
        aux.setNombre(nombre);
        aux.setAutores(autores);
        aux.setFuentes(Fuentes);
        aux.setDescripcion(descripcion);
        aux.setComentarios(comentarios);
        aux.setImportancia(importancia);
        aux.setUrgencia(urgencia);
        aux.setEstadoDes(estadoDes);
        aux.setEstabilidad(estabilidad);
        this.getmObjetivos().add(aux);
        //Notificamos que ha habido un cambio
         this.setChanged();
         this.notifyObservers();
        return aux;
    }

    /**
     * @return the mReunion
     */
    public ArrayList<Reunion> getmReunion() {
        return mReunion;
    }

    /**
     * @param mReunion the mReunion to set
     */
    public void setmReunion(ArrayList<Reunion> mReunion) {
        this.mReunion = mReunion;
        //Notificamos que ha habido un cambio
         this.setChanged();
         this.notifyObservers();
    }


    public Reunion nuevoReunion(String nombre,
                                       String autores,
                                       String Fuentes,
                                       String resultados,
                                       String lugar,
                                       String comentario,
                                       String asistentes)
    {
        Reunion aux = new Reunion();
        aux.setNombre(nombre);
        aux.setAutores(autores);
        aux.setFuentes(Fuentes);
        aux.setResultados(resultados);
        aux.setLugar(lugar);
        aux.setComentario(comentario);
        aux.setAsistentes(asistentes);
        this.getmReunion().add(aux);
        //Notificamos que ha habido un cambio
         this.setChanged();
         this.notifyObservers();
        return aux;
    }
}

    

