/*
 * Copyright 2003 Federal Chancellery Austria
 * MOA-SPSS has been developed in a cooperation between BRZ, the Federal
 * Chancellery Austria - ICT staff unit, and Graz University of Technology.
 *
 * Licensed under the EUPL, Version 1.1 or - as soon they will be approved by
 * the European Commission - subsequent versions of the EUPL (the "Licence");
 * You may not use this work except in compliance with the Licence.
 * You may obtain a copy of the Licence at:
 * http://www.osor.eu/eupl/
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the Licence is distributed on an "AS IS" basis,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the Licence for the specific language governing permissions and
 * limitations under the Licence.
 *
 * This product combines work with different licenses. See the "NOTICE" text
 * file for details on the various modules and licenses.
 * The "NOTICE" text file is part of the distribution. Any derivative works
 * that you distribute must include a readable copy of the "NOTICE" text file.
 */

package at.gv.egovernment.moa.spss.server.transaction;

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.security.cert.X509Certificate;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Vector;

import javax.activation.DataSource;

import org.w3c.dom.Element;

import at.gv.egovernment.moa.spss.MOAApplicationException;
import at.gv.egovernment.moa.spss.server.config.ConfigurationProvider;
import at.gv.egovernment.moaspss.logging.Logger;
import iaik.xml.crypto.utils.URI;

/**
 * Contains information about the current request.
 *
 * @author Stefan Knirsch
 * @author Patrick Peck
 */
public class TransactionContext {

  /** The client certificate. */
  private X509Certificate[] clientCertificate = null;
  /** The transaction ID. */
  private String transactionID = null;
  /** The name of the request. */
  private String requestName = null;
  /** The SOAP embedded request */
  private Element request;
  /** The response which is to embed by SOAP */
  private Element response;
  /** The map pointing to SOAP attachments needed by the request. */
  private HashMap attachments = null;
  /** The map containing cashed entities used in DataObjectFactory. */
  private HashMap resolvedEntities = null;
  /** The configuration to use throughout the request. */
  private ConfigurationProvider configuration = null;

  /**
   * Create a <code>TransactionContext</code> object.
   *
   * @param transactionID     A unique ID for this
   *                          <code>TransactionContext</code>.
   * @param clientCertificate The client certificate chain.
   * @param configuration     The MOA configuration to use for this transaction.
   */
  public TransactionContext(
      String transactionID,
      X509Certificate[] clientCertificate,
      ConfigurationProvider configuration) {

    this.transactionID = transactionID;
    this.clientCertificate = clientCertificate;
    this.configuration = configuration;
  }

  /**
   * Create a <code>TransactionContext</code> object.
   *
   * @param transactionID     A unique ID for this
   *                          <code>TransactionContext</code>.
   * @param clientCertificate The client certificate chain.
   * @param configuration     The MOA configuration to use for this transaction.
   * @param attachments       to use for this transaction.
   */
  public TransactionContext(
      String transactionID,
      X509Certificate[] clientCertificate,
      ConfigurationProvider configuration,
      Element request,
      HashMap attachments) {

    this.transactionID = transactionID;
    this.clientCertificate = clientCertificate;
    this.configuration = configuration;
    this.request = request;
    this.attachments = attachments;
  }

  /**
   * Returns the client certificate.
   *
   * @return The client certificate chain, if SSL client authentication has been
   *         configured in the web server and has been used by the client. The 0th
   *         element of the array contains the client certificate.
   *         <code>null</code> otherwise.
   */
  public X509Certificate[] getClientCertificate() {
    return clientCertificate;
  }

  /**
   * Returns the unique transaction ID.
   *
   * @return The transaction ID.
   */
  public String getTransactionID() {
    return transactionID;
  }

  /**
   * Returns the name of the request.
   *
   * @return The name of the request.
   */
  public String getRequestName() {
    return requestName;
  }

  /**
   * Sets the name of the request.
   *
   * @param requestName The request name to set.
   */
  public void setRequestName(String requestName) {
    this.requestName = requestName;
  }

  /**
   * Sets the the request.
   *
   * @param request The request to set.
   */
  public void setRequest(Element request) {
    this.request = request;
  }

  /**
   * Returns the request.
   *
   * @return The request.
   */
  public Element getRequest() {
    return request;
  }

  /**
   * Sets the the response.
   *
   * @param response The response to set.
   */
  public void setResponse(Element response) {
    this.response = response;
  }

  /**
   * Returns the response.
   *
   * @return The response.
   */
  public Element getResponse() {
    return response;
  }

  /**
   * Adds an attachment to the transactions list of SOAP attachments.
   *
   * @param referenceId Identification value for the SOAP attachment.
   * @param contentType MIME type of the SOAP attachment.
   * @param is          Handle to the ManagedMemoryDataSource of the SOAP
   *                    attachment.
   */
  public void addAttachment(String referenceId, String contentType, DataSource is) {
    if (this.attachments == null) {
      this.attachments = new HashMap();
    }
    final Vector entry = new Vector(2);
    entry.add(contentType);
    entry.add(is);
    this.attachments.put(referenceId, entry);
  }

  /**
   * Adds an attachment to the transactions list of SOAP attachments.
   *
   * @param referenceId Identification value for the SOAP attachment.
   * @param contentType MIME type of the SOAP attachment.
   * @param is          Handle to the InputStream of the SOAP attachment.
   * @param filename    Filename of the temporary file the InputStream belongs to
   */
  public void addAttachment(String referenceId, String contentType, InputStream is, String filename) {
    if (this.attachments == null) {
      this.attachments = new HashMap();
    }
    final Vector entry = new Vector(3);
    entry.add(contentType);
    entry.add(is);
    entry.add(filename);
    this.attachments.put(referenceId, entry);
  }

  /**
   * Returns the ManagedMemoryDataSource to a specific SOAP attachment identified
   * by referenceId.
   *
   * @param referenceId Identification value for the SOAP attachment.
   */
  public DataSource getAttachment(String referenceId) {
    if (attachments == null) {
      return null;
    }
    final Vector entry = (Vector) attachments.get(referenceId);
    if (entry == null) {
      return null;
    }
    final Object object = entry.get(1);
    if (object instanceof DataSource) {
      return (DataSource) object;
    } else {
      return null;
    }
  }

  /**
   * Returns the InputStream to a specific SOAP attachment identified by uri.
   *
   * @param uri Identification value for the SOAP attachment.
   */
  public InputStream getAttachmentInputStream(URI uri) throws MOAApplicationException {
    if (attachments == null) {
      return null;
    }
    final String referenceId = uri.getPath();
    final Vector entry = (Vector) attachments.get(referenceId);
    if (entry == null) {
      return null;
    }

    InputStream attachmentIs = null;
    final Object object = entry.get(1);

    if (object instanceof DataSource) {
      try {
        attachmentIs = ((DataSource) object).getInputStream();
      } catch (final IOException e) {
        throw new MOAApplicationException("2208", new Object[] { uri }, e);
      }
    } else {
      attachmentIs = (InputStream) object;
    }
    return attachmentIs;
    // If we would return the whole mmds: return (ManagedMemoryDataSource)
    // entry.get(1);
  }

  /**
   * Returns the content type to a specific SOAP attachment identified by
   * referenceId.
   *
   * @param referenceId Identification value for the SOAP attachment.
   */
  public String getAttachmentContentType(String referenceId) {
    final Vector entry = (Vector) attachments.get(referenceId);
    if (entry == null) {
      return null;
    }
    return (String) entry.get(0);
  }

  /**
   * Delete the temporary attachment files.
   */
  public void cleanAttachmentCache() {
    if (null == attachments) {
      return;
    }
    final Iterator iterator = attachments.entrySet().iterator();
    while (iterator.hasNext()) {
      final Entry hmEntry = (Entry) iterator.next();
      final Vector entry = (Vector) hmEntry.getValue();
      final Object object = entry.get(1);
      if (object instanceof DataSource) {
        final DataSource mmds = (DataSource) object;
        try {
          if (mmds != null) {
            final InputStream is = mmds.getInputStream();
            if (is != null) {
              is.close();
            }
// not available in Axis 1.0 to 1.1
//	          File f = mmds.getDiskCacheFile();
//	          if (f!=null) f.delete();	   
            if (mmds instanceof DeleteableDataSource) {
              ((DeleteableDataSource) mmds).delete();
            }
            // mmds..delete();
          }
        } catch (final IOException e) {
          // ok to do nothing here
        }
      } else if (object instanceof InputStream) {
        final InputStream is = (InputStream) object;
        try {
          if (is != null) {
            is.close();
          }
          final String tempFile = (String) entry.get(2);
          if (tempFile != null) {
            final File f = new File(tempFile);
            f.delete();
          }
        } catch (final IOException e) {
          // ok to do nothing here
        }
      }
    }
  }

  /**
   * Returns the <code>ConfigurationProvider</code> associated with this
   * transaction.
   *
   * @return The ConfigurationProvider associated with this transaction.
   */
  public ConfigurationProvider getConfiguration() {
    return configuration;
  }

  /**
   * Search an uri content in cashed map.
   *
   * @param uri The value to look for.
   * @return If found the cached entity, <code>null<code> otherwise.
   */
  public Vector FindResolvedEntity(String uri) {
    if (resolvedEntities == null) {
      return null;
    }
    return (Vector) resolvedEntities.get(uri);
  }

  /**
   * Get a new InputStream of a cached entity.
   *
   * @param uri The value to look for.
   * @return A new InputStream of the cached entity.
   */
  public InputStream ResolveURI(String uri) {
    InputStream is = null;
    final Vector entity = FindResolvedEntity(uri);
    if (entity != null) {
      final byte[] contentBytes = (byte[]) entity.get(0);
      if (contentBytes != null) {
        is = new ByteArrayInputStream(contentBytes);
      }
    }
    return is;
  }

  /**
   * Put a read entity (supplement, detached content, data object) on transactions
   * entity cash, to prevent repeated reading on slower channels.
   *
   * @param uri          A transaction-wide unique URI used as key of the entity
   *                     cash table.
   * @param contentBytes The cached content belonging to the uri.
   * @param contentType  If known, the MIME-type of the cashed content.
   */
  public void PutResolvedEntity(String uri, byte[] contentBytes, String contentType) {
    Logger.trace("    storing uri content of uri \"" + uri + "\" for future references");
    if (resolvedEntities == null) {
      resolvedEntities = new HashMap();
    }
    final Vector entity = new Vector();
    entity.add(contentBytes);
    entity.add(contentType);
    resolvedEntities.put(uri, entity);
  }
}