package it.corenet.j2ee.servlet;

import java.io.IOException;
import java.io.Reader;

import java.net.MalformedURLException;
import java.net.URL;

import java.util.Set;

import javax.security.auth.Subject;

import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.Templates;
import javax.xml.transform.TransformerException;

import org.apache.log4j.Logger;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import it.core.security.srm.credentials.ApplicationId;
import it.core.security.srm.credentials.TokenId;
import it.core.security.srm.credentials.XMLToken;

import it.corenet.j2ee.common.LogUtils;
import it.corenet.j2ee.common.xml.BadXmlDocumentException;
import it.corenet.j2ee.common.xml.InvalidXmlDocumentException;
import it.corenet.j2ee.common.xml.XMLUtils;
import it.corenet.j2ee.messages.Message;

/**
 * Classe generale per l'implementazione di una applicazione servlet. Questa classe fornisce i servizi di base per le
 * comunicazioni con i servizi di back office.<br>
 * Le servlet che estendono da questa devono definire, nel deployment descriptor, i seguenti parametri:<br>
 *
 * <table border="1">
 *   <tr>
 *     <td>Nome</td>
 *     <td>Descrizione</td>
 *     <td>Tipo</td>
 *     <td>Obbligatorio</td>
 *   </tr>
 *   <tr>
 *     <td><code>outputStylesheet</code></td>
 *     <td>Il percorso ella risorsa da utilizzare come stylesheet XSL per la formattazione dell'output Il nome del
 *       parametro, per uso applicativo, e' definito nella costante <code>{@link #PNAME_OUTPUT_STYLESHEET}</code>.</td>
 *     <td><code>String</code></td>
 *     <td>Si, a meno che non venga specificato il parametro <code>portaDelegataID</code></td>
 *   </tr>
 *   <tr>
 *     <td><code>xsdURL</code></td>
 *     <td>La URL che punta all'XSD da utilizzare per la validazione dell'XML ottenuto in risposta dai servizi</td>
 *     <td><code>String</code></td>
 *     <td>No</td>
 *   </tr>
 *   <tr>
 *     <td><code>characterEncoding</code></td>
 *     <td>Il valore da utilizzare come encoding delle risposte di questa servlet. Il nome del parametro, per uso
 *       applicativo, e' definito nella costante <code>{@link #PNAME_CHARACTER_ENCODING}</code>.</td>
 *     <td><code>String</code></td>
 *     <td>No</td>
 *   </tr>
 *   <tr>
 *     <td><code>fopStylesheet</code></td>
 *     <td>Il nome del parametro che definisce lo stylesheet XSL da utilizzare per formattare le richieste da inviare al
 *       servizio in caso di formato binario (es. pdf). Il nome del parametro, per uso applicativo, e' definito nella
 *       costante <code>{@link #PNAME_FOP_STYLESHEET}</code>.</td>
 *     <td><code>String</code></td>
 *     <td>No</td>
 *   </tr>
 *   <tr>
 *     <td><code>responseContentPartID</code></td>
 *     <td>L'identificativo della parte della risposta ottenuta dal servizio che deve essere resa al client. Questo
 *       parametro viene utilizzato solo se e' necessario trasmettere il contenuto applicativo in una parte diversa da
 *       quella di default (0) per motivi che possono dipendere dalle dimensioni della risposta o altro. Il nome del
 *       parametro, per uso applicativo, e' definito nella costante <code>{@link #PNAME_RESPONSE_CONTENT_PART_ID}</code>.
 *     </td>
 *     <td><code>Integer</code></td>
 *     <td>No</td>
 *   </tr>
 *   <tr>
 *     <td><code>srmApplicationId</code></td>
 *     <td>L'application ID utilizzato per la gestione della sicurezza in ambito SRM. Se questo parametro non e'
 *       presente la sicurezza SRM viene ignorata.</td>
 *     <td><code>String</code></td>
 *     <td></td>
 *   </tr>
 *   <tr>
 *     <td><code>srmUserName</code></td>
 *     <td>Lo username utilizzato per la gestione della sicurezza in ambito SRM. Viene utilizzato dalle applicazioni
 *       locali.</td>
 *     <td><code>String</code></td>
 *     <td></td>
 *   </tr>
 *   <tr>
 *     <td><code>srmUserPassword</code></td>
 *     <td>La password utilizzata per la gestione della sicurezza in ambito SRM. Viene utilizzata dalle applicazioni
 *       locali.</td>
 *     <td><code>String</code></td>
 *     <td></td>
 *   </tr>
 *   <tr>
 *     <td><code>jaasConfigurationName</code></td>
 *     <td>Il nome utilizzato per l'istanziazione di un Context JAAS (autenticazione e autorizzazione). Se questo
 *       parametro non e' presente la sicurezza SRM viene ignorata.</td>
 *     <td><code>String</code></td>
 *     <td></td>
 *   </tr>
 * </table>
 *
 * @author  Simone Casciaroli
 */
public abstract class AbstractGeneralServlet extends HttpServlet
{
    /**
     * L'identificativo della parte della risposta ottenuta dal servizio che deve essere resa al client. Questo
     * parametro viene utilizzato solo se e' necessario trasmettere il contenuto applicativo in una parte diversa da
     * quella di default (0) per motivi che possono dipendere dalle dimensioni della risposta o altro.
     */
    public static final String PNAME_RESPONSE_CONTENT_PART_ID = "responseContentPartID";

    /**
     * L'application id utilizzato per la gestione della sicurezza in ambito SRM. Se questo parametro e' assente la
     * sicurezza SRM non viene gestita.
     */
    public static final String PNAME_SRM_APPLICATION_NAME = "srmApplicationId";

    /**
     * Il nome del parametro che definisce la URL che punta all'XSD da utilizzare per la validazione dell'XML ottenuto
     * in risposta dai servizi.
     */
    public static final String PNAME_XSD_URL = "xsdURL";

    /** Il nome del file, cercato con il classloader, che rappresenta le proprieta' di connessione al server JNDI. */
    public static final String JNDI_PROPERTIES_FILE = "jndi.properties";

    /** Il nome del parametro che definisce la codifica dei caratteri della risposta da inviare al client. */
    public static final String PNAME_CHARACTER_ENCODING = "characterEncoding";

    /** Il nome del parametro che definisce l'elemento radice della richiesta. */
    public static final String PNAME_ROOT_DATA_REQUEST = "dataRequestRootElement";

    /** Il nome del parametro che definisce lo stylesheet XSL da utilizzare per fare il rendering delle risposte. */
    public static final String PNAME_OUTPUT_STYLESHEET = "outputStylesheet";

    /**
     * Il nome del parametro che definisce lo stylesheet XSL da utilizzare per fare il rendering delle risposte FOP
     * (PDF).
     */
    public static final String PNAME_FOP_STYLESHEET = "fopStylesheet";

    /** Il nome del parametro che indica se effettuare validazione dei documenti XML in uscita. */
    public static final String PNAME_SERVLET_VALIDATION = "servletValidation";

    /** Il nome dell'elemento da inviare per la richiesta dei metadati. */
    public static final String XML_ELEMENT_METADATA_REQUEST = "FormatoRichiesta";

    /** Il nome dell'elemento root per i documenti di richiesta. */
    public static final String XML_ELEMENT_REQUEST_ROOT = "RichiestaUtente";

    /** Il nome dell'elemento per gli attributi di sicurezza. */
    public static final String XML_ELEMENT_REQUEST_SICUREZZA = "Sicurezza";

    /** Il nome dell'elemento per il subject. */

    // public static final String XML_ELEMENT_REQUEST_SUBJECT = "Subject";

    /** Il nome dell'elemento per il token Id (SRM). */
    public static final String XML_ELEMENT_REQUEST_SRM_TOKEN_ID = "SRMTokenID";

    /** Il nome dell'elemento per l'application Id (SRM). */
    public static final String XML_ELEMENT_REQUEST_SRM_APPLICATION_ID = "SRMApplicationID";

    /** Il nome dell'elemento per il token xml (SRM). */
    public static final String XML_ELEMENT_REQUEST_SRM_TOKEN_XML = "SRMTokenXML";

    /** Il nome dell'elemento root per i documenti di precompilazione. */
    public static final String XML_ELEMENT_PRECOMPILAZIONE_ROOT = "Precompilazione";

    /** Il logger di log4j (NB: HTTPServlet ha gia' un suo logger) */
    protected static Logger logger = null;

    /** Il nome utilizzato per salvare il subject (e quindi l'autenticazione) nella sessione. */
    protected static final String SUBJECT_SESSION_ATTRIBUTE_NAME = "it.corenet.j2ee.servlet.subject";

    /** Il nome dell'elemento radice della richiesta. */
    protected String dataRequestRootElement = null;

    /** L'istanza dello stylesheet riutilizzabile in output per la trasformazione FOP(PDF). */
    protected Templates fopStylesheetTemplate = null;

    /** Il nome della configurazione JAAS. */
    protected String jaasConfigurationName = null;

    /** L'istanza dello stylesheet riutilizzabile in output. */
    protected Templates outputStylesheetTemplate = null;

    /** L'id dell'applicazione in ambito SRM. */
    protected String srmApplicationId = null;

    /** Lo username dell'applicazione in ambito SRM. */
    protected String srmUserName = null;

    /** La password dell'applicazione in ambito SRM. */
    protected String srmUserPassword = null;

    /** La codifica dei caratteri della risposta da inviare al client. */
    private String encoding = null;

    /** L'identificativo della parte della risposta ottenuta dal servizio che deve essere resa al client. */
    private int responseContentPartID = 0;

    /**
     * Flag che indica se viene effetuata la validazione delle risposte XML ottenute dai servizi infrastrutturali
     * richiamati.
     */
    private boolean validation = false;

    /**
     * Inizializza il logger.
     */
    public AbstractGeneralServlet()
    {
        super();
        logger = Logger.getLogger(this.getClass());
    }

    /**
     * Provvede al rilascio delle risorse della servlet. Le servlet che ereditano da questa possono fare l'override di
     * questo metodo ma devo sempre invocare <code>super.destroy()</code>.
     */
    public void destroy()
    {
        super.destroy();
    }

    /**
     * Provvede alla configurazione della servlet. Le servlet che ereditano da questa possono fare l'override di questo
     * metodo ma devo sempre invocare <code>super.init(config)</code>.
     *
     * @param   config  la configurazione della servlet
     *
     * @throws  ServletException  se la configurazione non e' corretta o manca di dati essenziali.
     */
    public void init(ServletConfig config)
        throws ServletException
    {
        super.init(config);

        initEncoding(config);

        initOutputValidation(config);

        initContendPartID(config);

        initSecurity(config);
    }

    /**
     * Stampa il messaggio di log.
     *
     * @param  arg0  il messaggio da stampare
     *
     * @see    javax.servlet.GenericServlet#log(String)
     */
    public void log(String arg0)
    {
        logger.debug(arg0);
    }

    /**
     * Stampa il messaggio di log.
     *
     * @param  arg0  il messaggio da stampare
     * @param  arg1  l'eccezione o errore da stampare
     *
     * @see    javax.servlet.GenericServlet#log(String, Throwable)
     */
    public void log(String arg0, Throwable arg1)
    {
        logger.debug(arg0, arg1);
    }

    /**
     * Compila uno stylesheet per poterlo riutilizzare.
     *
     * @param   config   la configurazione della servlet
     * @param   resName  il nome della risorsa che punta allo stylesheet
     *
     * @return  il template riutilizzabile dello stylesheet
     *
     * @throws  ServletException  se non e' possibile compilare lo stylesheet
     */
    protected Templates compileStylesheet(ServletConfig config, String resName)
        throws ServletException
    {
        logger.debug("Compilazione dello stylesheet dall'URL" + resName);

        try
        {
            URL url = config.getServletContext().getResource(resName);

            if (url == null)
            {
                throw new ServletException("Impossibile recuperare lo stylesheet '" + resName + "'");
            }

            return XMLUtils.getTemplates(url);
        }
        catch (TransformerException te)
        {
            throw new ServletException("Impossibile compilare lo stylesheet '" + resName + "'", te);
        }
        catch (MalformedURLException mue)
        {
            throw new ServletException("Impossibile recuperare lo stylesheet '" + resName + "'", mue);
        }
    }

    /**
     * Crea una struttura xml a partire dai parametri CGI presenti nella richiesta http fornita, attribuendogli la
     * radice specificata.<br/>
     *
     * @param   source    la richiesta http ricevuta in ingresso
     * @param   rootName  il nome dell'elemento radice
     *
     * @return  il documento creato in base ai parametri CGI trovati. La struttura del documento �:<br/>
     *
     *          <pre>
     * &lt;radice&gt;
     *     &lt;parametro&gt;
     *         &lt;nome&gt;nomeDelParametro&lt;/nome&gt;
     *         &lt;valore&gt;valoreDelParametro&lt;/valore&gt;
     *         ...
     *     &lt;/parametro&gt;
     * &lt;/radice&gt;
     * </pre>
     *          <br/>
     *
     * @throws  ParserConfigurationException  in presenza di errori di configurazione del parser xml.
     */
    protected Document createIntermediateStructure(HttpServletRequest source, String rootName)
        throws ParserConfigurationException
    {
        Document intermediateDoc = ServletToolBox.createRequestDocument(source, rootName);
        LogUtils.logXMLDocument("Struttura intermedia", intermediateDoc, logger);

        return intermediateDoc;
    }

    /**
     * Restituisce la modalit� di validazione impostata per la servlet in fase di configurazione.
     *
     * @return  <code>true</code> se � stata impostata l'estrazione validante dei documenti di risposta, <code>
     *          false</code> altrimenti.
     */
    protected boolean getValidationMode()
    {
        return validation;
    }

    /**
     * Carica lo stylesheet e lo precompila.
     *
     * @param   config  la configurazione della servlet
     *
     * @throws  ServletException  se la configurazione non e' corretta o manca di dati essenziali.
     */
    protected void initStylesheets(ServletConfig config)
        throws ServletException
    {
        String outputStylesheet = config.getInitParameter(PNAME_OUTPUT_STYLESHEET);

        String fopStylesheet = config.getInitParameter(PNAME_FOP_STYLESHEET);

        if (outputStylesheet != null)
        {
            outputStylesheetTemplate = compileStylesheet(config, outputStylesheet);
        }
        else
        {
            logger.debug("Nessuno stylesheet di output configurato");
        }

        if (fopStylesheet != null)
        {
            fopStylesheetTemplate = compileStylesheet(config, fopStylesheet);
        }
        else
        {
            logger.debug("Nessuno stylesheet FOP(PDF) configurato");
        }
    }

    /**
     * Invia la richiesta al servizio integrato specificato e riceve la risposta prodotta dallo stesso.
     *
     * @param   reqDocument        il documento XML che modella la richiesta
     * @param   serviceId          identificativo univoco del servizio cui richiedere l'esecuzione
     * @param   communicationMode  <code>EJB</code> se si intende effettuare la richiesta ad un servizio locale senza
     *                             porta delegata, <code>PDD</code> se si intende effettuare la richiesta ad un servizio
     *                             remoto tramite porta delegata <code>HTTP</code> se si intende effettuare la richiesta
     *                             ad un servizio remoto tramite connessione HTTP
     *
     * @return  il documento XML che contiene la risposta
     *
     * @throws  ServletException             se si incontra una eccezione bloccante
     * @throws  BadXmlDocumentException      sollevata nel caso il contenuto del messaggio di risposta non rappresenti
     *                                       un documento xml ben formato.
     * @throws  InvalidXmlDocumentException  sollevata nel caso il contenuto del messaggio di risposta, pur se attinente
     *                                       alle specifiche xml, non rappresenti un documento xml valido rispetto allo
     *                                       schema xml di validazione.
     */
    protected Document performRequest(Document reqDocument, String serviceId, String communicationMode)
        throws ServletException, InvalidXmlDocumentException, BadXmlDocumentException
    {
        return performRequest(reqDocument, serviceId, communicationMode, null);
    }

    /**
     * Invia la richiesta al servizio infrastrutturale specificato e riceve la risposta prodotta dallo stesso.
     *
     * @param   reqMsg             il messaggio che modella la richiesta
     * @param   serviceId          identificativo univoco del servizio cui richiedere l'esecuzione
     * @param   communicationMode  <code>EJB</code> se si intende effettuare la richiesta ad un servizio locale senza
     *                             porta delegata, <code>PDD</code> se si intende effettuare la richiesta ad un servizio
     *                             remoto tramite porta delegata <code>HTTP</code> se si intende effettuare la richiesta
     *                             ad un servizio remoto tramite connessione HTTP
     *
     * @return  il messaggio che contiene la risposta
     *
     * @throws  ServletException  se si incontra una eccezione bloccante
     */
    protected Message performRequest(Message reqMsg, String serviceId, String communicationMode)
        throws ServletException
    {
        return performRequest(reqMsg, serviceId, communicationMode, null);
    }

    /**
     * Invia la richiesta al servizio integrato specificato e riceve la risposta prodotta dallo stesso.
     *
     * @param   reqDocument        il documento XML che modella la richiesta
     * @param   serviceId          identificativo univoco del servizio cui richiedere l'esecuzione
     * @param   communicationMode  <code>EJB</code> se si intende effettuare la richiesta ad un servizio locale senza
     *                             porta delegata, <code>PDD</code> se si intende effettuare la richiesta ad un servizio
     *                             remoto tramite porta delegata <code>HTTP</code> se si intende effettuare la richiesta
     *                             ad un servizio remoto tramite connessione HTTP
     * @param   subject            il subject cui appartiene la richiesta.
     *
     * @return  il documento XML che contiene la risposta
     *
     * @throws  ServletException             se si incontra una eccezione bloccante
     * @throws  BadXmlDocumentException      sollevata nel caso il contenuto del messaggio di risposta non rappresenti
     *                                       un documento xml ben formato.
     * @throws  InvalidXmlDocumentException  sollevata nel caso il contenuto del messaggio di risposta, pur se attinente
     *                                       alle specifiche xml, non rappresenti un documento xml valido rispetto allo
     *                                       schema xml di validazione.
     */
    protected Document performRequest(Document reqDocument, String serviceId, String communicationMode, Subject subject)
        throws ServletException, InvalidXmlDocumentException, BadXmlDocumentException
    {
        try
        {
            return ServletToolBox.performRequest(reqDocument, serviceId, communicationMode, validation,
                responseContentPartID, subject);
        }
        catch (ServletException se)
        {
            logger.error("ECCEZIONE COMPLETA: " + LogUtils.getCompleteExceptionString(se));
            throw se;
        }
        catch (InvalidXmlDocumentException ixde)
        {
            logger.error("ECCEZIONE COMPLETA: " + LogUtils.getCompleteExceptionString(ixde));
            throw ixde;
        }
        catch (BadXmlDocumentException bxde)
        {
            logger.error("ECCEZIONE COMPLETA: " + LogUtils.getCompleteExceptionString(bxde));
            throw bxde;
        }
    }

    /**
     * Invia la richiesta al servizio infrastrutturale specificato e riceve la risposta prodotta dallo stesso.
     *
     * @param   reqMsg             il messaggio che modella la richiesta
     * @param   serviceId          identificativo univoco del servizio cui richiedere l'esecuzione
     * @param   communicationMode  <code>EJB</code> se si intende effettuare la richiesta ad un servizio locale senza
     *                             porta delegata, <code>PDD</code> se si intende effettuare la richiesta ad un servizio
     *                             remoto tramite porta delegata <code>HTTP</code> se si intende effettuare la richiesta
     *                             ad un servizio remoto tramite connessione HTTP
     * @param   soapAction         SOAPAction per il servizio web
     *
     * @return  il messaggio che contiene la risposta
     *
     * @throws  ServletException  se si incontra una eccezione bloccante
     */
    protected Message performRequest(Message reqMsg, String serviceId, String communicationMode, String soapAction)
        throws ServletException
    {
        try
        {
            return ServletToolBox.performRequest(reqMsg, serviceId, communicationMode, soapAction);
        }
        catch (ServletException se)
        {
            logger.error("ECCEZIONE COMPLETA: " + LogUtils.getCompleteExceptionString(se));
            throw se;
        }
    }

    /**
     * Invia la richiesta al servizio integrato specificato e riceve la risposta prodotta dallo stesso.
     *
     * @param   reqReader          il reader da cui leggere l'XML di richiesta
     * @param   serviceId          identificativo univoco del servizio cui richiedere l'esecuzione
     * @param   communicationMode  <code>EJB</code> se si intende effettuare la richiesta ad un servizio locale senza
     *                             porta delegata, <code>PDD</code> se si intende effettuare la richiesta ad un servizio
     *                             remoto tramite porta delegata <code>HTTP</code> se si intende effettuare la richiesta
     *                             ad un servizio remoto tramite connessione HTTP
     *
     * @return  il reader da cui leggere l'XML di risposta
     *
     * @throws  ServletException             se si incontra una eccezione bloccante
     * @throws  BadXmlDocumentException      sollevata nel caso il contenuto del messaggio di risposta non rappresenti
     *                                       un documento xml ben formato.
     * @throws  InvalidXmlDocumentException  sollevata nel caso il contenuto del messaggio di risposta, pur se attinente
     *                                       alle specifiche xml, non rappresenti un documento xml valido rispetto allo
     *                                       schema xml di validazione.
     */
    protected Reader performRequestUseStream(Reader reqReader, String serviceId, String communicationMode)
        throws ServletException, InvalidXmlDocumentException, BadXmlDocumentException
    {
        return performRequestUseStream(reqReader, serviceId, communicationMode, null);
    }

    /**
     * Invia la richiesta al servizio integrato specificato e riceve la risposta prodotta dallo stesso.
     *
     * @param   reqReader          il reader da cui leggere l'XML di richiesta
     * @param   serviceId          identificativo univoco del servizio cui richiedere l'esecuzione
     * @param   communicationMode  <code>EJB</code> se si intende effettuare la richiesta ad un servizio locale senza
     *                             porta delegata, <code>PDD</code> se si intende effettuare la richiesta ad un servizio
     *                             remoto tramite porta delegata <code>HTTP</code> se si intende effettuare la richiesta
     *                             ad un servizio remoto tramite connessione HTTP
     * @param   subject            il subject cui appartiene la richiesta.
     *
     * @return  il reader da cui leggere l'XML di risposta
     *
     * @throws  ServletException             se si incontra una eccezione bloccante
     * @throws  BadXmlDocumentException      sollevata nel caso il contenuto del messaggio di risposta non rappresenti
     *                                       un documento xml ben formato.
     * @throws  InvalidXmlDocumentException  sollevata nel caso il contenuto del messaggio di risposta, pur se attinente
     *                                       alle specifiche xml, non rappresenti un documento xml valido rispetto allo
     *                                       schema xml di validazione.
     */
    protected Reader performRequestUseStream(Reader reqReader, String serviceId, String communicationMode,
        Subject subject)
        throws ServletException, InvalidXmlDocumentException, BadXmlDocumentException
    {
        try
        {
            return ServletToolBox.performRequestUseStream(reqReader, serviceId, communicationMode,
                responseContentPartID, subject);
        }
        catch (ServletException se)
        {
            logger.error("ECCEZIONE COMPLETA: " + LogUtils.getCompleteExceptionString(se));
            throw se;
        }
        catch (InvalidXmlDocumentException ixde)
        {
            logger.error("ECCEZIONE COMPLETA: " + LogUtils.getCompleteExceptionString(ixde));
            throw ixde;
        }
        catch (BadXmlDocumentException bxde)
        {
            logger.error("ECCEZIONE COMPLETA: " + LogUtils.getCompleteExceptionString(bxde));
            throw bxde;
        }
    }

    /**
     * Recupera il subject dalla richiesta (e sessione) corrente, se esiste.
     *
     * @param   req  la richiesta corrente.
     *
     * @return  il subject della sessione corrente, se esiste, altrimenti null.
     */
    protected Subject retrieveSubject(HttpServletRequest req)
    {
        HttpSession session = req.getSession(false);

        if (session == null)
        {
            logger.debug("Nessuna sessione associata alla richiesta corrente.");

            return null;
        }
        else
        {
            if (srmApplicationId == null)
            {
                return null;
            }

            // il nome del subject e' differente per ciascuna applicazione
            Subject s = (Subject)session.getAttribute(srmApplicationId + SUBJECT_SESSION_ATTRIBUTE_NAME);

            if (s == null)
            {
                logger.debug("La richiesta corrente ha una propria sessione (" +
                    (session.isNew() ? "new" : "established") + ") ma nessun subject associato.");
            }
            else
            {
                logger.debug("La richiesta corrente ha una propria sessione (" +
                    (session.isNew() ? "new" : "established") + ") ed un subject preesistente.");
            }

            return s;
        }
    }

    /**
     * Setta la codifica dei caratteri della risposta HTTP in base ai valori specificati come parametri nel file di
     * configurazione della servlet. La codifica dei caratteri non puo' essere trasmessa via HTTP se la servlet non
     * specifica un content type.
     *
     * @param  resp  la risposta
     */
    protected void setEncoding(HttpServletResponse resp)
    {
        if (encoding != null)
        {
            resp.setCharacterEncoding(encoding);
            logger.debug("Settata la codifica dei caratteri della risposta a '" + encoding + "'");
        }
    }

    /**
     * Salva il subject nel documento xml.
     *
     * @param   doc      il documento di richiesta in cui mettere le credenziali.
     * @param   subject  il subject da salvare nella sessione.
     *
     * @throws  ServletException  se si verifica un'eccezione nella gestione delle sessioni.
     * @throws  IOException       se si verifica un'eccezione di IO.
     */
    protected void storeSubject(Document doc, Subject subject)
        throws ServletException, IOException
    {
        String serializedSubject = it.corenet.j2ee.common.io.Utils.objectToString(subject);
        logger.debug("Il subject in formato stringa e': " + serializedSubject);

        String nsURI    = doc.getDocumentElement().getNamespaceURI();
        String nsPrefix = doc.getDocumentElement().getPrefix();

        NodeList nl = doc.getDocumentElement().getElementsByTagName(XML_ELEMENT_REQUEST_SICUREZZA);

        Element sicurezzaEl = null;

        if (nl.getLength() > 0)
        {
            sicurezzaEl = (Element)nl.item(0);
        }
        else
        {
            sicurezzaEl = doc.createElementNS(nsURI, nsPrefix + ":" + XML_ELEMENT_REQUEST_SICUREZZA);
            doc.getDocumentElement().appendChild(sicurezzaEl);
        }

        Set s = subject.getPrincipals(ApplicationId.class);

        if (!s.isEmpty())
        {
            Element applicationIdEl = doc.createElementNS(nsURI,
                    nsPrefix + ":" + XML_ELEMENT_REQUEST_SRM_APPLICATION_ID);
            sicurezzaEl.appendChild(applicationIdEl);

            Node applicationIdData = doc.createCDATASection(
                    ((ApplicationId)subject.getPrincipals(ApplicationId.class).iterator().next()).getToken());
            applicationIdEl.appendChild(applicationIdData);
        }

        s = subject.getPrincipals(TokenId.class);

        if (!s.isEmpty())
        {
            Element tokenIdEl = doc.createElementNS(nsURI, nsPrefix + ":" + XML_ELEMENT_REQUEST_SRM_TOKEN_ID);
            sicurezzaEl.appendChild(tokenIdEl);

            Node tokenIdData = doc.createCDATASection(((TokenId)subject.getPrincipals(TokenId.class).iterator().next())
                    .getToken());
            tokenIdEl.appendChild(tokenIdData);
        }

        s = subject.getPrincipals(XMLToken.class);

        if (!s.isEmpty())
        {
            Element tokenXmlEl = doc.createElementNS(nsURI, nsPrefix + ":" + XML_ELEMENT_REQUEST_SRM_TOKEN_XML);
            sicurezzaEl.appendChild(tokenXmlEl);

            Node tokenXmlData = doc.createCDATASection(
                    ((XMLToken)subject.getPrincipals(XMLToken.class).iterator().next()).getToken());
            tokenXmlEl.appendChild(tokenXmlData);
        }
    }

    /**
     * Processa il documento specificato con lo stylesheet configurato per la servlet per produrre un output PDF.
     *
     * @param   source  il documento da trasformare
     * @param   target  la risposta su cui scrivere l'output
     *
     * @throws  ServletException  in caso di errore
     */
    protected void transformPDFResponse(Document source, HttpServletResponse target)
        throws ServletException
    {
        if (fopStylesheetTemplate == null)
        {
            throw new ServletException("Output PDF non disponibile: stylesheet mancante.");
        }

        ServletToolBox.transformPDFResponse(source, target, fopStylesheetTemplate);
    }

    /**
     * Processa il documento specificato con lo stylesheet configurato per la servlet per produrre un output PDF.
     *
     * @param   source  il reader associato al documento da trasformare
     * @param   target  la risposta su cui scrivere l'output
     *
     * @throws  ServletException  in caso di errore
     */
    protected void transformPDFResponse(Reader source, HttpServletResponse target)
        throws ServletException
    {
        if (fopStylesheetTemplate == null)
        {
            throw new ServletException("Output PDF non disponibile: stylesheet mancante.");
        }

        ServletToolBox.transformPDFResponse(source, target, fopStylesheetTemplate);
    }

    /**
     * Processa il documento specificato con lo stylesheet configurato per la servlet.
     *
     * @param   source  il documento da trasformare
     * @param   target  la risposta su cui scrivere l'output
     *
     * @throws  ServletException  in caso di errore
     */
    protected void transformResponse(Document source, HttpServletResponse target)
        throws ServletException
    {
        LogUtils.logXMLDocument("Documento di risposta del servizio", source, logger);

        try
        {
            ServletToolBox.transformResponse(source, target, outputStylesheetTemplate);
        }
        catch (ServletException se)
        {
            logger.error("ECCEZIONE COMPLETA: " + LogUtils.getCompleteExceptionString(se));
            throw se;
        }
    }

    /**
     * Processa il documento specificato con lo stylesheet configurato per la servlet.
     *
     * @param   source  il reader associato al documento da trasformare
     * @param   target  la risposta su cui scrivere l'output
     *
     * @throws  ServletException  in caso di errore
     */
    protected void transformResponse(Reader source, HttpServletResponse target)
        throws ServletException
    {
        try
        {
            ServletToolBox.transformResponse(source, target, outputStylesheetTemplate);
        }
        catch (ServletException se)
        {
            logger.error("ECCEZIONE COMPLETA: " + LogUtils.getCompleteExceptionString(se));
            throw se;
        }
    }

    /**
     * Determina la modalita' di comunicazione da impiegare per il colloquio con il servizio .
     *
     * @param   config  la configurazione della servlet
     *
     * @throws  ServletException  se la configurazione non e' corretta o manca di dati essenziali.
     */
    private void initContendPartID(ServletConfig config)
        throws ServletException
    {
        String cpID = config.getInitParameter(PNAME_RESPONSE_CONTENT_PART_ID);

        if (cpID != null)
        {
            try
            {
                responseContentPartID = Integer.parseInt(cpID);
                logger.info(PNAME_RESPONSE_CONTENT_PART_ID + " = " + responseContentPartID +
                    ". Le risposte dei servizi verranno prodotte utilizzando la " + responseContentPartID +
                    "esima parte del messaggio.");
            }
            catch (NumberFormatException nfe)
            {
                logger.error("Valore non valido per il parametro " + PNAME_RESPONSE_CONTENT_PART_ID + ": '" + cpID +
                    "'");
            }
        }
    }

    /**
     * Inizializza le variabili che determinano il content type e la codifica dei caratteri della risposta in questo
     * modo: 1. Legge i valori dei due parametri dalla configurazione specifica della servlet (che hanno quindi
     * priorita' massima sugli altri settaggi). Se non specificati, 2. Legge i valori dei due parametri dal contesto
     * comune alle servlet 3. Se risulta essere settata la codifica ma non il content type, utilizza per il content type
     * il valore di default
     *
     * @param   config  la configurazione della servlet
     *
     * @throws  ServletException  se la configurazione non e' corretta o manca di dati essenziali.
     */
    private void initEncoding(ServletConfig config)
        throws ServletException
    {
        encoding = config.getInitParameter(PNAME_CHARACTER_ENCODING);

        if ((encoding != null) && (encoding.length() > 0))
        {
            logger.debug("Codifica dei caratteri della risposta specifica per la servlet: '" + encoding + "'");
        }
        else
        {
            // Ottiene dalla configurazione della servlet la codifica dei caratteri
            encoding = config.getServletContext().getInitParameter(PNAME_CHARACTER_ENCODING);

            if ((encoding != null) && (encoding.length() > 0))
            {
                logger.debug("Codifica dei caratteri della risposta ottenuta dal " + "contesto della servlet: '" +
                    encoding + "'");
            }
            else
            {
                logger.debug("Codifica dei caratteri della risposta non settato. ");
            }
        }
    }

    /**
     * Imposta il tipo di estrazione (validante/non validante) dei documenti xml dai messaggi di risposta dei servizi.
     *
     * @param   config  la configurazione della servlet
     *
     * @throws  ServletException  sollevata in caso il valore di configurazione sia errato.Gli unici valori ammessi sono
     *                            <code>true</code> e <code>false</code>.
     */
    private void initOutputValidation(ServletConfig config)
        throws ServletException
    {
        // impostazione validazione XML di risposta
        String execValidation = config.getInitParameter(PNAME_SERVLET_VALIDATION);

        if (execValidation != null)
        {
            if (execValidation.equals("true"))
            {
                validation = true;
            }
            else
            {
                if (execValidation.equals("false"))
                {
                    validation = false;
                }
                else
                {
                    throw new ServletException(
                        "Validazione risposte del servizio non corretta. Specificare il parametro '" +
                        PNAME_SERVLET_VALIDATION + "' con un valore ammissibile (true/false)");
                }
            }
        }
    }

    /**
     * Configura i parametri per la gestione della sicurezza.
     *
     * @param   config  la configurazione della servlet
     *
     * @throws  ServletException  se la configurazione non e' corretta o manca di dati essenziali.
     */
    private void initSecurity(ServletConfig config)
        throws ServletException
    {
        srmApplicationId = config.getInitParameter(PNAME_SRM_APPLICATION_NAME);

        if ((srmApplicationId == null) || ("".equals(srmApplicationId)))
        {
            logger.debug("Parametro " + PNAME_SRM_APPLICATION_NAME + " assente. Sicurezza SRM non funzionante.");
        }
        else
        {
            logger.debug("Parametro " + PNAME_SRM_APPLICATION_NAME + "=" + srmApplicationId +
                ". Sicurezza SRM abilitata.");
        }
    }
}