//
// SwitchRMI  Framework
// Copyright (c) 2000-2002 by Michael J. Henderson & Associates.
//
// Michael Henderson
// http://switchrmi.sf.net
// mailto:mikehenderson@dunelm.org.uk
//
// This library is free software.
//
// You may redistribute it and/or modify it under the terms of the GNU
// Lesser General Public License as published by the Free Software Foundation.
//
// Version 2.1 of the license should be included with this distribution in
// the file LICENSE, as well as License.html. If the license is not
// included with this distribution, you may find a copy at the FSF web
// site at 'www.gnu.org' or 'www.fsf.org', or you may write to the
// Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139 USA.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied waranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// $Id: UrlInfo.java,v 1.1 2002/11/11 22:19:48 mikehenderson Exp $
package com.mjh.util;

import java.net.*;

import java.util.*;

import org.apache.log4j.Logger;

public class UrlInfo
{
    private static final Logger log = Logger.getLogger(UrlInfo.class.getName());
    private String url;
    private String protocol;
    private String host;
    private int port;
    private String path;
    private String query;
    private Map params;

    public UrlInfo(String url, String[] requiredParameters)
            throws MalformedURLException
    {
        this(url);

        if ((requiredParameters != null) && (requiredParameters.length > 0))
        {
            if (params == null)
            {
                throw new MalformedURLException("Missing Required Parameters");
            }
            else
            {
                for (int i = 0; i < requiredParameters.length; i++)
                {
                    if (params.get(requiredParameters[i]) == null)
                    {
                        throw new MalformedURLException(
                                "Missing Required Parameter: "
                                + requiredParameters[i]);
                    }
                }
            }
        }
    }

    public UrlInfo(String url)
            throws MalformedURLException
    {
        if (url == null)
        {
            throw new MalformedURLException("Null Pointer Not Allowed");
        }

        this.url = url;
        parse();
    }

    public String getUrl()
    {
        return url;
    }

    public String getProtocol()
    {
        return protocol;
    }

    public String getHost()
    {
        return host;
    }

    public int getPort()
    {
        return port;
    }

    public String getPath()
    {
        return path;
    }

    public String getQuery()
    {
        return query;
    }

    public Map getParameters()
    {
        return params;
    }

    public String getParameterValue(String name)
    {
        return (String) params.get(name);
    }

    private void parse() throws MalformedURLException
    {
        boolean debug = log.isDebugEnabled();
        int index = url.indexOf(':');

        if (index == -1)
        {
            throw new MalformedURLException("Unable to find protocol in URL");
        }

        protocol = url.substring(0, index);
        index++;

        if (debug)
        {
            log.debug("1 url.charAt(" + index + ") = " + url.charAt(index));
        }

        int length = url.length();

        while ((url.charAt(index) == '/') && (index < length))
        {
            if (debug)
            {
                log.debug("2 url.charAt(" + index + ") = " + url.charAt(index));
            }

            index++;
        }

        if (debug)
        {
            log.debug("3 url.charAt(" + index + ") = " + url.charAt(index));
        }

        if (index == length)
        {
            throw new MalformedURLException("Missing Host");
        }

        int hostStartIndex = index;
        String hostPort = url.substring(hostStartIndex);

        if (debug)
        {
            log.debug("hostPort = " + hostPort);
        }

        int hostEndIndex = hostPort.indexOf('/');

        if (hostEndIndex == -1)
        {
            hostEndIndex = hostPort.length();
        }

        hostPort = hostPort.substring(0, hostEndIndex);

        if (debug)
        {
            log.debug("hostPort = " + hostPort);
        }

        String portS = null;

        index = hostPort.indexOf(':');
        host = hostPort;

        if (index > 0)
        {
            portS = hostPort.substring(index + 1, host.length());

            Integer portNumber = null;

            try
            {
                portNumber = new Integer(portS);
            }
            catch (Exception ex)
            {
                throw new MalformedURLException("Invalid Port Number in URL");
            }

            port = portNumber.intValue();

            if (debug)
            {
                log.debug("port = " + port);
            }

            host = hostPort.substring(0, index);

            if (debug)
            {
                log.debug("host = " + host);
            }
        }

        int pathStartIndex = hostStartIndex + hostPort.length();
        int queryIndex = url.indexOf('?');
        int pathEndIndex = (queryIndex == -1) ? url.length() : queryIndex;

        path = url.substring(pathStartIndex, pathEndIndex);

        if (debug)
        {
            log.debug("path = " + path);
        }

        String query = null;

        if (queryIndex != -1)
        {
            query = url.substring(queryIndex + 1, url.length());

            if (debug)
            {
                log.debug("query = " + query);
            }

            params = parseQuery(query);

            if (debug)
            {
                log.debug("params = " + params);
            }
        }
    }

    private static Map parseQuery(String query)
                           throws MalformedURLException
    {
        HashMap map = new HashMap();
        StringTokenizer st = new StringTokenizer(query, "&");

        while (st.hasMoreTokens())
        {
            String paramValue = st.nextToken();
            int index = paramValue.indexOf('=');

            if (index == -1)
            {
                throw new MalformedURLException("Bad Query String at: "
                                                + paramValue);
            }

            String name = paramValue.substring(0, index);
            String value = paramValue.substring(index + 1, paramValue.length());

            map.put(name, value);
        }

        return map;
    }
}