/*
 * Copyright 2000-2004 The Apache Software Foundation.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.jetspeed.services.webpage;

// java.io
import java.io.IOException;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;

// java.util
import java.util.Iterator;
import java.util.Enumeration;
import java.util.HashMap;

// javax.servlet
import javax.servlet.http.*;

// java.net
import java.net.URL;
import java.net.URLConnection;
import java.net.HttpURLConnection;
import java.net.URLEncoder;

import org.apache.log4j.Logger;

/*
 * Abstract Base class for web page sessions.
 * Implements the primary dispatcher logic for getting and posting resources.
 *
 */

public abstract class AbstractSiteSession implements SiteSession
{    

    // the base url of the host being proxied
    protected String targetBase;

    // the base url the wps
    protected String proxyBase;

    // the cookies collection
    protected HashMap cookies = new HashMap();
        
    // counters
    protected int hitCount = 0;
    protected int cacheCount = 0;

    // the log file singleton instance
    static Logger log = Logger.getLogger(AbstractSiteSession.class);

    /**
     * Create a NetElementSession, which maintains sessions with one network element.
     * 
    * @param targetBase the target host's base URL
    * @param proxyBase the proxy server host URL base address.     
     */    
    public AbstractSiteSession(String targetBase, String proxyBase)
    {
        this.proxyBase  = proxyBase;
        this.targetBase = targetBase;
    }

    /**
     * Given a URL, returns the content from that URL in a string.  
     * All HTTP hyperlinks(HREFs) are rewritten as proxied-referenced hyperlinks.
     * All relative references to web resources (images, stylesheets, ...) are 
     * rewritten as absolute references, but are not proxied.
     * Determines if we are logged on to the target site. If not,
     * calls logon(), which is a implementation specific 'POST' exchange
     *
     * @see logon(String, HttpServletRequest, HttpServletResponse)     
     *
     * @param url the proxied resource address.
     * @param data the rundata
     *
     * @exception IOException a servlet exception.
     */    

    public void dispatch(String url, ProxyRunData data)
                 throws IOException
    {                    
        try 
        {
            Configuration config = Configuration.getInstance();
                
            log.debug("=== Dispatching =" + url);
            
            // open a pooled HTTP connection
            //URL u = new URL(url);
            URL u = new URL(null, url, new sun.net.www.protocol.http.Handler() );
            HttpURLConnection con = (HttpURLConnection)u.openConnection();  
    
            //if (con instanceof HttpURLConnection) 
            con.setDoInput(true);
            con.setDoOutput(true);
            con.setAllowUserInteraction(false);        
            con.setFollowRedirects(false);
    
            if (data.getPosting()) {
                con.setRequestMethod("POST");
            }
        
            // are there any cookies in our current session?
            if (cookies.isEmpty()) 
            {
                // there are no cookies, must be a new session, so lets logon
                    log.debug("... no session id provided. Logging on...");
    
                if (false == logon(data))
                    return;   
    
            }        
    
            // send the cookies (session ids) back to the NE
            Iterator it = cookies.values().iterator();
            Cookie cookie;
            while (it.hasNext()) {
                cookie = (Cookie)it.next();
                String sessionID = WebPageHelper.buildCookieString(cookie);
                con.setRequestProperty("Cookie", sessionID);
                log.debug("... Sending Session ID: " + sessionID );
            }            
    
            // we have to get the post parameters from the servlet container,
            // and then re-encode them. i wish i could find out how to keep
            // the servlet container from reading them, because now i have to
            // parse them out, and then re-encode
            if (data.getPosting()) {
    
                // get the post params 
                StringBuffer postParams = new StringBuffer();
                int count = 0;
                Enumeration e = data.getRequest().getParameterNames();
                while (e.hasMoreElements())
                {
    
                    String name = (String) e.nextElement();
                    if (name.equals(config.getSID()) ||
                        name.equals(config.getURL())) {
                        continue;
                    }                                      
    
                    String values[] = data.getRequest().getParameterValues(name);
                    if (values != null) 
                    {
                        for (int i = 0; i < values.length; i++) {
                            if (count > 0) {
                                postParams.append("&");
                            }
                            postParams.append(name);
                            postParams.append("=");
                            postParams.append(URLEncoder.encode(values[i]));
                            count++;
                        }
                    }
                }
                String  postString = postParams.toString();            
                con.setRequestProperty("Content-length", String.valueOf(postString.length()) );
                // write directly to the output stream            
                DataOutputStream dos = new DataOutputStream(con.getOutputStream());            
    
                log.debug("... POST: " + postString);
                dos.writeBytes(postString);
                dos.close();
            }
           
            int rc = con.getResponseCode();
    
            // Get the Session Information from Headers
            int contentType = WebPageHelper.getContentType(con.getHeaderField("content-type"), u.toString());
            String location = con.getHeaderField("Location");
            
            if ((rc == con.HTTP_MOVED_PERM || rc == con.HTTP_MOVED_TEMP) && null != location) 
            {
                log.debug("+++ REDIRECT = " + location);
                location = WebPageHelper.concatURLs(targetBase, location);
                dispatch(location , data);
                return;
            }
    
            // get cookies set from server
            String cookieString = con.getHeaderField("Set-Cookie");
            if (null != cookieString) 
            {
                log.debug("... new SessionID found: " + cookieString);
                WebPageHelper.parseCookies(cookieString, this);            
            }
    
            if (contentType == WebPageHelper.CT_IMAGE || 
                contentType == WebPageHelper.CT_BINARY ||
                contentType == WebPageHelper.CT_APPLICATION) {
                // wasn't in the cache, get it from host
                getBinaryContent(con, data.getResponse());
                return;
            }
        
            rewriteContent(data, con, contentType, url);
    
        }
        catch (IOException ex)
        {
            log.error("*** PROXY DISPATCH EXCEPTION = " + ex);
                throw ex;
        }

    }

    /**
     * Gets the HTML content from the URL Connection stream and returns it
     * in a string
     *
     * @param con The URLConnection to read from.
     * @param resource The full URL of the resource.
     * @return The HTML Content from the stream.
     *
     * @exception IOException a servlet exception.
     */
    public String getHTMLContent(URLConnection con, 
                                 ProxyRunData data,
                                 String resource) throws IOException 
    {

        int CAPACITY = 4096;

        InputStream is = con.getInputStream();
        ByteArrayOutputStream buffer = new ByteArrayOutputStream();
        
        Configuration config = Configuration.getInstance();
        FileOutputStream fos = null;
        boolean logging = config.getEnableContentLog();
        if (logging) 
        {
            if (data != null)
            {
                String fileName = data.getServlet().getServletContext().getRealPath(
                                        config.getLogLocation() );
                fos = new FileOutputStream(fileName, true);
                WebPageHelper.writeHeader(fos, resource);
            }
        }
        
        //now process the InputStream...
        
        byte[] bytes = new byte[CAPACITY];

        int readCount = 0;
        int total = 0;

        while( ( readCount = is.read( bytes )) > 0 ) 
        {                                        
            buffer.write( bytes, 0, readCount);
            if (logging)
            {
                fos.write( bytes, 0, readCount);
            }
            total += readCount;
        }     
        if (logging) 
        {
            fos.close();
        }
        is.close();

        return buffer.toString();
    }

    /**
     * Gets the HTML content from the URL Connection stream and writes it to respones
     *
     * @param con The URLConnection to read from.
     *
     * @exception IOException a servlet exception.
     */
    public void getBinaryContent(URLConnection con,
                                 HttpServletResponse response) throws IOException 
    {

        int CAPACITY = 4096;


        InputStream is = con.getInputStream();

       // FileOutputStream fos = new FileOutputStream("/test.fw", true);

        //now process the InputStream...
        
        byte[] bytes = new byte[CAPACITY];

        int readCount = 0;
        while( ( readCount = is.read( bytes )) > 0 ) {
                                        
            response.getOutputStream().write(bytes, 0, readCount);
            //fos.write( bytes, 0, readCount);
        }        
        
        //fos.close();
        is.close();

    }

    /**
      * Given a cookie, it first checks to see if that cookie is already
      * managed in this session. If it is, it means that the session has
      * timed out and that the network element has now created a new session.
      * In that case, replace the cookie, and re-establish the session (logon)
      * If its a new cookie, we will still need to logon, and and the cookie to
      * the managed cookies collection for this session.
      *
      * @param cookie new cookie returned from target server.
      * @return true when a new cookie added, false when updated.
      *
      */
    public boolean addCookieToSession(Cookie cookie)
    {
        boolean added = (null == cookies.get(cookie.getName()));
        cookies.put(cookie.getName(), cookie); // adds or updates        
        return added;
    }

    /*
     * Gets the hitcount for this session.
     *
     * @return the hitcount for this session.
     */
    public int getHitCount()
    {
        return hitCount;
    }

    /*
     * Increments the hitcount for this session.
     *
     */
    public void incHitCount()
    {
        hitCount++;
    }

    /*
     * Gets the cache count for this session.
     *
     * @return the cache count for this session.
     */
    public int getCacheCount()
    {
        return cacheCount;
    }

    /*
     * Increments the hitcount for this session.
     *
     */
    public void incCacheCount()
    {
        cacheCount++;
    }


}