/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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.felix.webconsole;


import java.io.IOException;
import java.lang.reflect.Array;
import java.net.URLDecoder;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import javax.servlet.ServletRequest;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.FileUploadBase;
import org.apache.commons.fileupload.FileUploadException;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.ServletFileUpload;
import org.apache.commons.fileupload.servlet.ServletRequestContext;
import org.json.JSONException;
import org.json.JSONWriter;


/**
 * The <code>WebConsoleUtil</code> provides various utility methods for use
 * by Web Console plugins.
 */
public final class WebConsoleUtil
{

    private WebConsoleUtil()
    {
        /* no instantiation */
    }

    /**
     * Returns the {@link VariableResolver} for the given request.
     * <p>
     * If no resolver has yet be created for the requests, an instance of the
     * {@link DefaultVariableResolver} is created with preset properties,
     * placed into the request and returned. The preset properties are
     * <code>appRoot</code> set to the value of the
     * {@link WebConsoleConstants#ATTR_APP_ROOT} request attribute and
     * <code>pluginRoot</code> set to the value of the
     * {@link WebConsoleConstants#ATTR_PLUGIN_ROOT} request attribute.
     * <p>
     * <b>Note</b>: An object not implementing the {@link VariableResolver}
     * interface already stored as the
     * {@link WebConsoleConstants#ATTR_CONSOLE_VARIABLE_RESOLVER} attribute
     * will silently be replaced by the {@link DefaultVariableResolver}
     * instance.
     *
     * @param request The request whose attribute is returned (or set)
     *
     * @return The {@link VariableResolver} for the given request.
     */
    public static VariableResolver getVariableResolver( final ServletRequest request )
    {
        final Object resolverObj = request.getAttribute( WebConsoleConstants.ATTR_CONSOLE_VARIABLE_RESOLVER );
        if ( resolverObj instanceof VariableResolver )
        {
            return ( VariableResolver ) resolverObj;
        }

        final DefaultVariableResolver resolver = new DefaultVariableResolver();
        // FIXME: don't we need a constant for the values below?
        resolver.put( "appRoot", request.getAttribute( WebConsoleConstants.ATTR_APP_ROOT ) ); //$NON-NLS-1$
        resolver.put( "pluginRoot", request.getAttribute( WebConsoleConstants.ATTR_PLUGIN_ROOT ) ); //$NON-NLS-1$
        setVariableResolver( request, resolver );
        return resolver;
    }


    /**
     * Sets the {@link VariableResolver} as the
     * {@link WebConsoleConstants#ATTR_CONSOLE_VARIABLE_RESOLVER}
     * attribute in the given request. An attribute of that name already
     * existing is silently replaced.
     *
     * @param request The request whose attribute is set
     * @param resolver The {@link VariableResolver} to place into the request
     */
    public static void setVariableResolver( final ServletRequest request, final VariableResolver resolver )
    {
        request.setAttribute( WebConsoleConstants.ATTR_CONSOLE_VARIABLE_RESOLVER, resolver );
    }


    /**
     * An utility method, that is used to filter out simple parameter from file
     * parameter when multipart transfer encoding is used.
     *
     * This method processes the request and sets a request attribute
     * {@link AbstractWebConsolePlugin#ATTR_FILEUPLOAD}. The attribute value is a {@link Map}
     * where the key is a String specifying the field name and the value
     * is a {@link org.apache.commons.fileupload.FileItem}.
     *
     * @param request the HTTP request coming from the user
     * @param name the name of the parameter
     * @return if not multipart transfer encoding is used - the value is the
     *  parameter value or <code>null</code> if not set. If multipart is used,
     *  and the specified parameter is field - then the value of the parameter
     *  is returned.
     */
    public static final String getParameter( HttpServletRequest request, String name )
    {
        // just get the parameter if not a multipart/form-data POST
        if ( !FileUploadBase.isMultipartContent( new ServletRequestContext( request ) ) )
        {
            return request.getParameter( name );
        }

        // check, whether we already have the parameters
        Map params = ( Map ) request.getAttribute( AbstractWebConsolePlugin.ATTR_FILEUPLOAD );
        if ( params == null )
        {
            // parameters not read yet, read now
            // Create a factory for disk-based file items
            DiskFileItemFactory factory = new DiskFileItemFactory();
            factory.setSizeThreshold( 256000 );

            // Create a new file upload handler
            ServletFileUpload upload = new ServletFileUpload( factory );
            upload.setSizeMax( -1 );

            // Parse the request
            params = new HashMap();
            try
            {
                List items = upload.parseRequest( request );
                for ( Iterator fiter = items.iterator(); fiter.hasNext(); )
                {
                    FileItem fi = ( FileItem ) fiter.next();
                    FileItem[] current = ( FileItem[] ) params.get( fi.getFieldName() );
                    if ( current == null )
                    {
                        current = new FileItem[]
                            { fi };
                    }
                    else
                    {
                        FileItem[] newCurrent = new FileItem[current.length + 1];
                        System.arraycopy( current, 0, newCurrent, 0, current.length );
                        newCurrent[current.length] = fi;
                        current = newCurrent;
                    }
                    params.put( fi.getFieldName(), current );
                }
            }
            catch ( FileUploadException fue )
            {
                // TODO: log
            }
            request.setAttribute( AbstractWebConsolePlugin.ATTR_FILEUPLOAD, params );
        }

        FileItem[] param = ( FileItem[] ) params.get( name );
        if ( param != null )
        {
            for ( int i = 0; i < param.length; i++ )
            {
                if ( param[i].isFormField() )
                {
                    return param[i].getString();
                }
            }
        }

        // no valid string parameter, fail
        return null;
    }

    /**
     * Utility method to handle relative redirects.
     * Some application servers like Web Sphere handle relative redirects differently
     * therefore we should make an absolute URL before invoking send redirect.
     *
     * @param request the HTTP request coming from the user
     * @param response the HTTP response, where data is rendered
     * @param redirectUrl the redirect URI.
     * @throws IOException If an input or output exception occurs
     * @throws IllegalStateException   If the response was committed or if a partial
     *  URL is given and cannot be converted into a valid URL
     */
    public static final void sendRedirect(final HttpServletRequest request,
                                final HttpServletResponse response,
                                String redirectUrl) throws IOException {
        // check for relative URL
        if ( !redirectUrl.startsWith("/") ) { //$NON-NLS-1$
            String base = request.getContextPath() + request.getServletPath() + request.getPathInfo();
            int i = base.lastIndexOf('/');
            if (i > -1) {
                base = base.substring(0, i);
            } else {
                i = base.indexOf(':');
                base = (i > -1) ? base.substring(i + 1, base.length()) : ""; //$NON-NLS-1$
            }
            if (!base.startsWith("/")) { //$NON-NLS-1$
                base = '/' + base;
            }
            redirectUrl = base + '/' + redirectUrl;

        }
        response.sendRedirect(redirectUrl);
    }

    /**
     * Sets response headers to force the client to not cache the response
     * sent back. This method must be called before the response is committed
     * otherwise it will have no effect.
     * <p>
     * This method sets the <code>Cache-Control</code>, <code>Expires</code>,
     * and <code>Pragma</code> headers.
     *
     * @param response The response for which to set the cache prevention
     */
    public static final void setNoCache(final HttpServletResponse response) {
        response.setHeader("Cache-Control", "no-cache"); //$NON-NLS-1$ //$NON-NLS-2$
        response.addHeader("Cache-Control", "no-store"); //$NON-NLS-1$ //$NON-NLS-2$
        response.addHeader("Cache-Control", "must-revalidate"); //$NON-NLS-1$ //$NON-NLS-2$
        response.addHeader("Cache-Control", "max-age=0"); //$NON-NLS-1$ //$NON-NLS-2$
        response.setHeader("Expires", "Thu, 01 Jan 1970 01:00:00 GMT"); //$NON-NLS-1$ //$NON-NLS-2$
        response.setHeader("Pragma", "no-cache"); //$NON-NLS-1$ //$NON-NLS-2$
    }

    /**
     * Escapes HTML special chars like: <>&\r\n and space
     *
     *
     * @param text the text to escape
     * @return the escaped text
     */
    public static final String escapeHtml(String text)
    {
        StringBuffer sb = new StringBuffer(text.length() * 4 / 3);
        synchronized (sb) // faster buffer operations
        {
            char ch, oldch = '_';
            for (int i = 0; i < text.length(); i++)
            {
                switch (ch = text.charAt(i))
                {
                    case '<':
                        sb.append("&lt;"); //$NON-NLS-1$
                        break;
                    case '>':
                        sb.append("&gt;"); //$NON-NLS-1$
                        break;
                    case '&':
                        sb.append("&amp;"); //$NON-NLS-1$
                        break;
                    case ' ':
                        sb.append("&nbsp;"); //$NON-NLS-1$
                        break;
                    case '\r':
                    case '\n':
                        if (oldch != '\r' && oldch != '\n') // don't add twice <br>
                            sb.append("<br/>\n"); //$NON-NLS-1$
                        break;
                    default:
                        sb.append(ch);
                }
                oldch = ch;
            }

            return sb.toString();
        }
    }

    /**
     * Retrieves a request parameter and converts it to int.
     *
     * @param request the HTTP request
     * @param name the name of the request parameter
     * @param _default the default value returned if the parameter is not set or is not a valid integer.
     * @return the request parameter if set and is valid integer, or the default value
     */
    public static final int getParameterInt(HttpServletRequest request, String name,
        int _default)
    {
        int ret = _default;
        String param = request.getParameter(name);
        try
        {
            if (param != null)
                ret = Integer.parseInt(param);
        }
        catch (NumberFormatException nfe)
        {
            // don't care, will return default
        }

        return ret;
    }

    /**
     * Writes a key-value pair in a JSON writer. Write is performed only if both key and
     * value are not null.
     *
     * @param jw the writer, where to write the data
     * @param key the key value, stored under 'key'
     * @param value the value stored under 'value'
     * @throws JSONException if the value cannot be serialized.
     */
    public static final void keyVal(JSONWriter jw, String key, Object value)
        throws JSONException
    {
        if (key != null && value != null)
        {
            jw.object();
            jw.key("key"); //$NON-NLS-1$
            jw.value(key);
            jw.key("value"); //$NON-NLS-1$
            jw.value(value);
            jw.endObject();
        }
    }


    /**
     * Decode the given value expected to be URL encoded.
     * <p>
     * This method first tries to use the Java 1.4 method
     * <code>URLDecoder.decode(String, String)</code> method and falls back to
     * the now deprecated <code>URLDecoder.decode(String, String)</code>
     * which uses the platform character set to decode the string. This is
     * because the platforms before 1.4 and most notably some OSGi Execution
     * Environments (such as Minimum EE) do not provide the newer method.
     *
     * @param value the value to decode
     * @return the decoded string
     */
    public static String urlDecode( final String value )
    {
        // shortcut for empty or missing values
        if ( value == null || value.length() == 0 )
        {
            return value;
        }

        try
        {
            return URLDecoder.decode( value, "UTF-8" ); //$NON-NLS-1$
        }
        catch ( Throwable t )
        {
            // expected NoSuchMethodError: if platform does not support it
            // expected UnsupportedEncoding (not really: UTF-8 is required)
            return URLDecoder.decode( value );
        }
    }

    /**
     * This method will stringify a Java object. It is mostly used to print the values
     * of unknown properties. This method will correctly handle if the passed object
     * is array and will property display it.
     *
     * If the value is byte[] the elements are shown as Hex
     *
     * @param value the value to convert
     * @return the string representation of the value
     */
    public static final String toString(Object value)
    {
        if (value == null)
        {
            return "n/a"; //$NON-NLS-1$
        }
        else if (value.getClass().isArray())
        {
            final StringBuffer sb = new StringBuffer();
            final int len = Array.getLength(value);
            synchronized (sb)
            { // it's faster to synchronize ALL loop calls
                sb.append('[');
                for (int i = 0; i < len; i++)
                {
                    final Object element = Array.get(value, i);
                    if (element instanceof Byte)
                    {
                        // convert byte[] to hex string
                        sb.append("0x"); //$NON-NLS-1$
                        final String x = Integer.toHexString(((Byte) element).intValue() & 0xff);
                        if (1 == x.length())
                        {
                            sb.append('0');
                        }
                        sb.append(x);
                    }
                    else
                    {
                        sb.append(toString(element));
                    }

                    if (i < len - 1)
                    {
                        sb.append(", "); //$NON-NLS-1$
                    }
                }
                return sb.append(']').toString();
            }
        }
        else
        {
            return value.toString();
        }

    }
}