// This Source Code is in the Public Domain per: http://litesoft.org/License.txt
package org.litesoft.util;

import java.io.*;
import java.net.*;

import org.litesoft.commonfoundation.typeutils.*;

import java.util.*;

import org.litesoft.commonfoundation.typeutils.Objects;

public class UrlFormatHelper
{
    private String mUrlBase;
    private Map<String, String[]> mParameters;

    public String getUrlBase()
    {
        return mUrlBase;
    }

    public Map<String, String[]> getParameters()
    {
        return mParameters;
    }

    private UrlFormatHelper( String pUrlBase, Map<String, String[]> pParameters )
    {
        mUrlBase = pUrlBase;
        mParameters = pParameters;
    }

    /**
     * Probably has a problem with keys with multiple values!
     */
    public static UrlFormatHelper decode( String pEncodedUrl )
    {
        String zUrlBase = null;
        Map<String, String[]> zParameters = new HashMap<String, String[]>();
        if ( null != (pEncodedUrl = Strings.noEmpty( pEncodedUrl )) )
        {
            int at = pEncodedUrl.indexOf( '?' );
            if ( at == -1 )
            {
                zUrlBase = pEncodedUrl;
            }
            else
            {
                zUrlBase = pEncodedUrl.substring( 0, at );
                String[] zParams = Strings.parseChar( pEncodedUrl.substring( at + 1 ).trim(), '&' );
                for ( String zParam : zParams )
                {
                    if ( (zParam = zParam.trim()).length() != 0 )
                    {
                        String zKey = null;
                        String zValue = zParam;
                        if ( -1 != (at = zParam.indexOf( '=' )) )
                        {
                            zKey = zParam.substring( 0, at ).trim();
                            zValue = zParam.substring( at + 1 ).trim();
                        }
                        decodeAndAddTo( zValue, zKey, zParameters );
                    }
                }
            }
        }
        return new UrlFormatHelper( zUrlBase, zParameters );
    }

    public static String encode( String pUrlBase, String... pKeyValueParameterPairs )
    {
        if ( !Objects.isNullOrEmpty( pKeyValueParameterPairs ) )
        {
            if ( (pKeyValueParameterPairs.length & 1) != 0 )
            {
                throw new IllegalArgumentException(
                        "Attempt to urlEncode Key Value Parameter Pairs that were NOT Key/Value pairs" );
            }

            StringBuilder sb = new StringBuilder();

            for ( int i = 0; i < pKeyValueParameterPairs.length; i += 2 )
            {
                String zKey = Strings.noEmpty( pKeyValueParameterPairs[i] );
                String zValue = encode( pKeyValueParameterPairs[i + 1] );

                if ( zKey == null )
                {
                    throw new IllegalArgumentException(
                            "urlEncode null key[" + i + "], with UrlBase: " + pUrlBase );
                }
                if ( zValue != null )
                {
                    if ( sb.length() != 0 )
                    {
                        sb.append( '&' );
                    }
                    sb.append( zKey ).append( '=' ).append( zValue );
                }
            }
            if ( sb.length() != 0 )
            {
                return pUrlBase + "?" + sb;
            }
        }
        return pUrlBase;
    }

    private static void decodeAndAddTo( String pValue, String pKey, Map<String, String[]> pParameters )
    {
        String zDecoded = pValue;
        if ( (pValue.length() != 0) )
        {
            try
            {
                zDecoded = URLDecoder.decode( pValue, "UTF-8" );
            }
            catch ( UnsupportedEncodingException e )
            {
                throw new RuntimeException( e );
            }
        }
        String[] zCurValues = pParameters.get( pKey );
        if ( zCurValues == null )
        {
            pParameters.put( pKey, new String[]{zDecoded} );
        }
        else
        {
            pParameters.put( pKey, Strings.appendString( zCurValues, zDecoded ) );
        }
    }

    private static String encode( String pField )
    {
        try
        {
            return (null != (pField = Strings.noEmpty( pField ))) ? //
                   URLEncoder.encode( pField, "UTF8" ) : null;
        }
        catch ( UnsupportedEncodingException e )
        {
            throw new RuntimeException( e );
        }
    }
}