/**
 * Copyright © 2001 The JA-SIG Collaborative.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. Redistributions of any form whatsoever must retain the following
 *    acknowledgment:
 *    "This product includes software developed by the JA-SIG Collaborative
 *    (http://www.jasig.org/)."
 *
 * THIS SOFTWARE IS PROVIDED BY THE JA-SIG COLLABORATIVE "AS IS" AND ANY
 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE JA-SIG COLLABORATIVE OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */

package org.jasig.portal.channels;

import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.net.URLConnection;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

import org.jasig.portal.ChannelCacheKey;
import org.jasig.portal.ChannelRuntimeData;
import org.jasig.portal.ChannelRuntimeProperties;
import org.jasig.portal.ChannelStaticData;
import org.jasig.portal.GeneralRenderingException;
import org.jasig.portal.IMultithreadedCacheable;
import org.jasig.portal.IMultithreadedChannel;
import org.jasig.portal.PortalEvent;
import org.jasig.portal.PortalException;
import org.jasig.portal.ResourceMissingException;
import org.jasig.portal.i18n.LocaleManager;
import org.jasig.portal.security.LocalConnectionContext;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.jasig.portal.utils.DTDResolver;
import org.jasig.portal.utils.ResourceLoader;
import org.jasig.portal.utils.XSLT;
import org.w3c.dom.Document;
import org.xml.sax.ContentHandler;
import org.jasig.portal.utils.DocumentFactory;
import org.w3c.dom.Element;
import org.apache.xml.serialize.XMLSerializer;
import java.io.PrintWriter;
import java.io.FileOutputStream;


/**
 * <p>A channel which transforms XML for rendering in the portal.</p>
 *
 * <p>Static channel parameters to be supplied:
 *
 *  1) "xmlUri" - a URI representing the source XML document
 *  2) "sslUri" - a URI representing the corresponding .ssl (stylesheet list) file
 *  3) "upc_localConnContext" - The class name of the ILocalConnectionContext 
 *      implementation. Use when local data needs to be sent with the request for the URL.
 * </p>
 * <p>This channel is intended to be used as one that can be selectively edited according to
 * permissions in order to display a customized message from select faculty/staff members.</p>
 * @author rtwigg@uccs.edu, adapted from CGenericXSLT.java
 * @version $Revision: 2.4.1 $
 */
public class CDeptMsg implements IMultithreadedChannel, IMultithreadedCacheable
{
    private static final Log log = LogFactory.getLog(CDeptMsg.class);
    Map stateTable;
    static final String systemCacheId="org.jasig.portal.channels.CDeptMsg"; // to prepend to the system-wide cache key
    boolean refresh;

  // state class
  private class CState
  {
    private String xmlUri;
    private String sslUri;
    private Map params;
    private long cacheTimeout;
    private ChannelRuntimeData runtimeData;
    private LocalConnectionContext localConnContext;
    private String action;
   

    public CState()
    {
      xmlUri = sslUri = action = null;
      params = new HashMap();
      runtimeData = null;
      localConnContext = null;
    }
    
    public String toString()
    {
       StringBuffer str = new StringBuffer();
       str.append("xmlUri = "+xmlUri+"\n");
       str.append("sslUri = "+sslUri+"\n");
       if (params != null) {
          str.append("params = "+params.toString()+"\n");
       }
       return str.toString();
    }
  }
  
  public CDeptMsg()
  {
    stateTable = Collections.synchronizedMap(new HashMap());
  }

  public void setStaticData (ChannelStaticData sd, String uid) throws ResourceMissingException
  {
    CState state = new CState();
    state.xmlUri = sd.getParameter("xmlUri");
    state.sslUri = sd.getParameter("sslUri");
    state.action="view";
    refresh=false;

    String cacheTimeout = sd.getParameter("cacheTimeout");

    String connContext = sd.getParameter ("upc_localConnContext");
    if (connContext != null)
    {
      try
      {
        state.localConnContext = (LocalConnectionContext) Class.forName(connContext).newInstance();
        state.localConnContext.init(sd);
      }
      catch (Exception e)
      {
        log.error( "CDeptMsg: Cannot initialize ILocalConnectionContext: " + e);
      }
    }

    stateTable.put(uid,state);
  }


  public void setRuntimeData (ChannelRuntimeData rd, String uid) throws PortalException
  {
    CState state = (CState)stateTable.get(uid);

    if (state == null)
    {
      log.error("CDeptMsg:setRuntimeData() : attempting to access a non-established channel! setStaticData() has never been called on the =uid=\""+uid+"\"");
    }
    else
    {
      state.runtimeData=rd;

      String submit = rd.getParameter("form_submit");
      if (submit != null && submit.trim().equals("Save and Return")) 
      {
        state.action = "view";
        refresh=true;

        String xmlPath = null;
        try
        {
          if (state.localConnContext != null)
            xmlPath = ResourceLoader.getResourceAsFileString(this.getClass(), state.localConnContext.getDescriptor(state.xmlUri, rd));
          else
            xmlPath = ResourceLoader.getResourceAsFileString(this.getClass(), state.xmlUri);
        }
        catch (Exception e)
        {
          throw new ResourceMissingException (state.xmlUri, "", e.getMessage());
        }
        try
        {
          Document emptyDoc = DocumentFactory.getNewDocument();
          Element messageE = emptyDoc.createElement("message");

          Element fromNameE = emptyDoc.createElement("fromName");
          String new_fromName = rd.getParameter("form_fromName");
          if (new_fromName != null)
          {
            fromNameE.appendChild(emptyDoc.createTextNode(new_fromName));
          }
          messageE.appendChild(fromNameE);

          Element headlineE = emptyDoc.createElement("headline");
          String new_headline = rd.getParameter("form_headline");
          if (new_headline != null)
          {
            headlineE.appendChild(emptyDoc.createTextNode(new_headline));
          }
          messageE.appendChild(headlineE);


          Element bodyE = emptyDoc.createElement("body");

          String new_body = rd.getParameter("form_body");
          // create multiple paragraphs
          int i=0,start=0;
          for(;i<new_body.length();i++)
          {
            if ((int)new_body.charAt(i) == 10) // Linefeed
            { 
              int j; 
              for (j=i;j<new_body.length() && !(Character.isLetter(new_body.charAt(j)));j++); 
              Element paragraphE = emptyDoc.createElement("paragraph");
              paragraphE.appendChild(emptyDoc.createTextNode(new_body.substring(start,j-1)));
              bodyE.appendChild(paragraphE);
              start=i=j;
            }
          }
          //Capture final paragraph
          if (start<new_body.length())
          {
            Element paragraphE = emptyDoc.createElement("paragraph");                                      paragraphE.appendChild(emptyDoc.createTextNode(new_body.substring(start,new_body.length())));
            bodyE.appendChild(paragraphE);
          }
          messageE.appendChild(bodyE);
          emptyDoc.appendChild(messageE);

          PrintWriter out = new PrintWriter(new FileOutputStream(xmlPath));
          XMLSerializer serializer = new XMLSerializer(out,null);
          serializer.serialize(emptyDoc);
          out.flush();
          out.close();
        }
        catch (Exception e)
        {
            log.error( "CDeptMsg: Unable to save xml document " + e.getMessage());
        }
      }

      String about_ok = rd.getParameter("about_submit");
      if (about_ok != null && about_ok.trim().equals("OK")) 
      {
        state.action = "view";
        refresh=true;
      }

      String help_ok = rd.getParameter("help_submit");
      if (help_ok != null && help_ok.trim().equals("OK")) 
      {
        state.action = "view";
        refresh=true;
      }

      if (submit != null && submit.trim().equals("Cancel")) 
      {
        state.action = "view";
      }

      // grab the parameters and stuff them all into the state object        
      Enumeration enum = rd.getParameterNames();
      while (enum.hasMoreElements()) {
         String n = (String)enum.nextElement();
         if (rd.getParameter(n) != null) {
            state.params.put(n,rd.getParameter(n));
         }
      }
    }
  }

  public void receiveEvent (PortalEvent ev, String uid) 
  {
      CState state=(CState)stateTable.get(uid);

      if (ev.getEventNumber() == PortalEvent.SESSION_DONE)
      {
          // clean up
          stateTable.remove(uid);
      }

      if (ev.getEventNumber() == PortalEvent.EDIT_BUTTON_EVENT)
      {
        state.action="edit"; 
        refresh=true;
      }

      if (ev.getEventNumber() == PortalEvent.HELP_BUTTON_EVENT)
      {
        state.action="help";
        refresh=true;
      }

      if (ev.getEventNumber() == PortalEvent.ABOUT_BUTTON_EVENT)
      {
        state.action="about";
        refresh=true;
      }

  }

  public ChannelRuntimeProperties getRuntimeProperties (String uid)
  {
    ChannelRuntimeProperties rp=new ChannelRuntimeProperties();

    CState state=(CState)stateTable.get(uid);

    // determine if such channel is registered

    if (stateTable.get(uid) == null)
    {
      rp.setWillRender(false);
      log.error("CDeptMsg:getRuntimeProperties() : attempting to access a non-established channel! setStaticData() has never been called on the uid=\""+uid+"\"");
    }
    return rp;
  }

  public void renderXML(ContentHandler out,String uid) throws PortalException
  {
    CState state=(CState)stateTable.get(uid);

    refresh=false;
    if (state == null)
      log.error("CDeptMsg:renderXML() : attempting to access a non-established channel! setStaticData() has never been called on the uid=\""+uid+"\"");
    else
    {
      log.debug("CDeptMsg::renderXML() : state = " + state.toString() );

      String xml;
      Document xmlDoc, xmlClone;
      InputStream inputStream = null;

      try
      {
        DocumentBuilderFactory docBuilderFactory = DocumentBuilderFactory.newInstance();
        docBuilderFactory.setNamespaceAware(true);
        DocumentBuilder docBuilder = docBuilderFactory.newDocumentBuilder();
        DTDResolver dtdResolver = new DTDResolver();
        docBuilder.setEntityResolver(dtdResolver);

        URL url;
        if (state.localConnContext != null)
          url = ResourceLoader.getResourceAsURL(this.getClass(), state.localConnContext.getDescriptor(state.xmlUri, state.runtimeData));
        else
          url = ResourceLoader.getResourceAsURL(this.getClass(), state.xmlUri);

        URLConnection urlConnect = url.openConnection();

        if (state.localConnContext != null)
        {
          try
          {
            state.localConnContext.sendLocalData(urlConnect, state.runtimeData);
          }
          catch (Exception e)
          {
            log.error( "CDeptMsg: Unable to send data through " + state.runtimeData.getParameter("upc_localConnContext") + ": " + e.getMessage());
          }
        }
        inputStream = urlConnect.getInputStream();
        xmlDoc = docBuilder.parse(inputStream);

        // Clone the original document 
        xmlClone = (Document)xmlDoc.cloneNode(true);

      }
      catch (IOException ioe)
      {
        throw new ResourceMissingException (state.xmlUri, "", ioe.getMessage());
      }
      catch (Exception e)
      {
        throw new GeneralRenderingException("Problem parsing " + state.xmlUri + ": " + e);
      } finally {
        try {
          if (inputStream != null)
            inputStream.close();
        } catch (IOException ioe) {
          throw new PortalException("CDeptMsg:renderXML():: could not close InputStream");
        }
      }

      state.runtimeData.put("baseActionURL", state.runtimeData.getBaseActionURL());
      state.runtimeData.put("isRenderingAsRoot",       String.valueOf(state.runtimeData.isRenderingAsRoot()));

      // For edit, help and about events
      if (state.action != null)
        state.runtimeData.put("action", state.action);

      
      // OK, pass everything we got cached in params...
      if (state.params != null)
      {
         Iterator it = state.params.keySet().iterator();
         while (it.hasNext()) {
            String n = (String)it.next();
            if (state.params.get((Object)n) != null) {
               state.runtimeData.put(n,state.params.get((Object)n));
            }
         }
      }

      XSLT xslt = XSLT.getTransformer(this);
      xslt.setXML(xmlClone);
      xslt.setXSL(state.sslUri, state.runtimeData.getBrowserInfo());
      xslt.setTarget(out);
      xslt.setStylesheetParameters(state.runtimeData);
      xslt.transform();
    }
  }

  public ChannelCacheKey generateKey(String uid)
  {
    CState state = (CState)stateTable.get(uid);

    if (state == null)
    {
      log.error("CDeptMsg:generateKey() : attempting to access a non-established channel! setStaticData() has never been called on the uid=\""+uid+"\"");
      return null;
    }
    else
    {
      if (refresh == true)
      {
        return null;
      }
      else
      {
        ChannelCacheKey k = new ChannelCacheKey();
        k.setKey(this.getKey(state)+","+uid);
        k.setKeyScope(ChannelCacheKey.SYSTEM_KEY_SCOPE);
        k.setKeyValidity(new Long(System.currentTimeMillis()));
        return k;
      }
    }
  }

  public boolean isCacheValid(Object validity,String uid)
  {
    if (!(validity instanceof Long))
      return false;

    CState state = (CState)stateTable.get(uid);

    if (state == null)
    {
      log.error("CDeptMsg:isCacheValid() : attempting to access a non-established channel! setStaticData() has never been called on the uid=\""+uid+"\"");
      return false;
    }
    else
      return (System.currentTimeMillis() - ((Long)validity).longValue() < state.cacheTimeout*1000);
  }

  private String getKey(CState state)
  {
    // Maybe not the best way to generate a key, but it seems to work.
    // If you know a better way, please change it!
    StringBuffer sbKey = new StringBuffer(1024);
    sbKey.append(systemCacheId).append(": ");
    sbKey.append("xmluri:").append(state.xmlUri).append(", ");
    sbKey.append("sslUri:").append(state.sslUri).append(", ");

    String xslUriForKey = null;
    try {
        String sslUri = ResourceLoader.getResourceAsURLString(CDeptMsg.class, state.sslUri);
        xslUriForKey = XSLT.getStylesheetURI(sslUri, state.runtimeData.getBrowserInfo());
    } catch (Exception e) {
      xslUriForKey = "Not attainable: " + e;
    }

    sbKey.append("locales:").append(LocaleManager.stringValueOf(state.runtimeData.getLocales()));
    sbKey.append("xslUri:").append(xslUriForKey).append(", ");
    sbKey.append("cacheTimeout:").append(state.cacheTimeout).append(", ");
    sbKey.append("isRenderingAsRoot:").append(state.runtimeData.isRenderingAsRoot()).append(", ");

    // If a local connection context is configured, include its descriptor in the key
    if (state.localConnContext != null)
      sbKey.append("descriptor:").append(state.localConnContext.getDescriptor(state.xmlUri, state.runtimeData)).append(", ");    

    sbKey.append("params:").append(state.params.toString());
    return sbKey.toString();
  }
}