//
//  ========================================================================
//  Copyright (c) 1995-2014 Mort Bay Consulting Pty. Ltd.
//  ------------------------------------------------------------------------
//  All rights reserved. This program and the accompanying materials
//  are made available under the terms of the Eclipse Public License v1.0
//  and Apache License v2.0 which accompanies this distribution.
//
//      The Eclipse Public License is available at
//      http://www.eclipse.org/legal/epl-v10.html
//
//      The Apache License v2.0 is available at
//      http://www.opensource.org/licenses/apache2.0.php
//
//  You may elect to redistribute this code under either of these licenses.
//  ========================================================================
//

package org.eclipse.jetty.util;

import static org.eclipse.jetty.util.TypeUtil.convertHexDigit;

import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.StringWriter;
import java.io.UnsupportedEncodingException;
import java.util.Iterator;
import java.util.Map;

import org.eclipse.jetty.util.Utf8Appendable.NotUtf8Exception;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/* ------------------------------------------------------------ */
/** Handles coding of MIME  "x-www-form-urlencoded".
 * <p>
 * This class handles the encoding and decoding for either
 * the query string of a URL or the _content of a POST HTTP request.
 *
 * <h4>Notes</h4>
 * The UTF-8 charset is assumed, unless otherwise defined by either
 * passing a parameter or setting the "org.eclipse.jetty.util.UrlEncoding.charset"
 * System property.
 * <p>
 * The hashtable either contains String single values, vectors
 * of String or arrays of Strings.
 * <p>
 * This class is only partially synchronised.  In particular, simple
 * get operations are not protected from concurrent updates.
 *
 * @see java.net.URLEncoder
 */
public class UrlEncoded extends MultiMap implements Cloneable
{
	private static final Logger LOG = LoggerFactory.getLogger(UrlEncoded.class);

	public static final String ENCODING = System.getProperty("org.eclipse.jetty.util.UrlEncoding.charset",StringUtil.__UTF8);

	/* ----------------------------------------------------------------- */
	public UrlEncoded(UrlEncoded url)
	{
		super(url);
	}
	
	/* ----------------------------------------------------------------- */
	public UrlEncoded()
	{
		super(6);
	}
	
	/* ----------------------------------------------------------------- */
	public UrlEncoded(String s)
	{
		super(6);
		decode(s,ENCODING);
	}
	
	/* ----------------------------------------------------------------- */
	public UrlEncoded(String s, String charset)
	{
		super(6);
		decode(s,charset);
	}
	
	/* ----------------------------------------------------------------- */
	public void decode(String query)
	{
		decodeTo(query,this,ENCODING,-1);
	}
	
	/* ----------------------------------------------------------------- */
	public void decode(String query,String charset)
	{
		decodeTo(query,this,charset,-1);
	}
	
	/* -------------------------------------------------------------- */
	/** Encode Hashtable with % encoding.
	 */
	public String encode()
	{
		return encode(ENCODING,false);
	}
	
	/* -------------------------------------------------------------- */
	/** Encode Hashtable with % encoding.
	 */
	public String encode(String charset)
	{
		return encode(charset,false);
	}
	
	/* -------------------------------------------------------------- */
	/** Encode Hashtable with % encoding.
	 * @param equalsForNullValue if True, then an '=' is always used, even
	 * for parameters without a value. e.g. "blah?a=&b=&c=".
	 */
	public synchronized String encode(String charset, boolean equalsForNullValue)
	{
		return encode(this,charset,equalsForNullValue);
	}
	
	/* -------------------------------------------------------------- */
	/** Encode Hashtable with % encoding.
	 * @param equalsForNullValue if True, then an '=' is always used, even
	 * for parameters without a value. e.g. "blah?a=&b=&c=".
	 */
	public static String encode(MultiMap map, String charset, boolean equalsForNullValue)
	{
		if (charset==null)
			charset=ENCODING;

		StringBuilder result = new StringBuilder(128);

		Iterator iter = map.entrySet().iterator();
		while(iter.hasNext())
		{
			Map.Entry entry = (Map.Entry)iter.next();

			String key = entry.getKey().toString();
			Object list = entry.getValue();
			int s=LazyList.size(list);

			if (s==0)
			{
				result.append(encodeString(key,charset));
				if(equalsForNullValue)
					result.append('=');
			}
			else
			{
				for (int i=0;i<s;i++)
				{
					if (i>0)
						result.append('&');
					Object val=LazyList.get(list,i);
					result.append(encodeString(key,charset));

					if (val!=null)
					{
						String str=val.toString();
						if (str.length()>0)
						{
							result.append('=');
							result.append(encodeString(str,charset));
						}
						else if (equalsForNullValue)
							result.append('=');
					}
					else if (equalsForNullValue)
						result.append('=');
				}
			}
			if (iter.hasNext())
				result.append('&');
		}
		return result.toString();
	}



	/* -------------------------------------------------------------- */
	/** Decoded parameters to Map.
	 * @param content the string containing the encoded parameters
	 */
	public static void decodeTo(String content, MultiMap map, String charset)
	{
		decodeTo(content,map,charset,-1);
	}
	
	/* -------------------------------------------------------------- */
	/** Decoded parameters to Map.
	 * @param content the string containing the encoded parameters
	 */
	public static void decodeTo(String content, MultiMap map, String charset, int maxKeys)
	{
		if (charset==null)
			charset=ENCODING;

		synchronized(map)
		{
			String key = null;
			String value = null;
			int mark=-1;
			boolean encoded=false;
			for (int i=0;i<content.length();i++)
			{
				char c = content.charAt(i);
				switch (c)
				{
				  case '&':
					  int l=i-mark-1;
					  value = l==0?"":
						  (encoded?decodeString(content,mark+1,l,charset):content.substring(mark+1,i));
					  mark=i;
					  encoded=false;
					  if (key != null)
					  {
						  map.add(key,value);
					  }
					  else if (value!=null&&value.length()>0)
					  {
						  map.add(value,"");
					  }
					  key = null;
					  value=null;
					  if (maxKeys>0 && map.size()>maxKeys)
						  throw new IllegalStateException("Form too many keys");
					  break;
				  case '=':
					  if (key!=null)
						  break;
					  key = encoded?decodeString(content,mark+1,i-mark-1,charset):content.substring(mark+1,i);
					  mark=i;
					  encoded=false;
					  break;
				  case '+':
					  encoded=true;
					  break;
				  case '%':
					  encoded=true;
					  break;
				}                
			}
			
			if (key != null)
			{
				int l=content.length()-mark-1;
				value = l==0?"":(encoded?decodeString(content,mark+1,l,charset):content.substring(mark+1));
				map.add(key,value);
			}
			else if (mark<content.length())
			{
				key = encoded
					?decodeString(content,mark+1,content.length()-mark-1,charset)
					:content.substring(mark+1);
				if (key != null && key.length() > 0)
				{
					map.add(key,"");
				}
			}
		}
	}

	/* -------------------------------------------------------------- */
	/** Decoded parameters to Map.
	 * @param raw the byte[] containing the encoded parameters
	 * @param offset the offset within raw to decode from
	 * @param length the length of the section to decode
	 * @param map the {@link MultiMap} to populate
	 */
	public static void decodeUtf8To(byte[] raw,int offset, int length, MultiMap map)
	{
		decodeUtf8To(raw,offset,length,map,new Utf8StringBuilder());
	}

	/* -------------------------------------------------------------- */
	/** Decoded parameters to Map.
	 * @param raw the byte[] containing the encoded parameters
	 * @param offset the offset within raw to decode from
	 * @param length the length of the section to decode
	 * @param map the {@link MultiMap} to populate
	 * @param buffer the buffer to decode into
	 */
	public static void decodeUtf8To(byte[] raw,int offset, int length, MultiMap map,Utf8StringBuilder buffer)
	{
		synchronized(map)
		{
			String key = null;
			String value = null;

			// TODO cache of parameter names ???
			int end=offset+length;
			for (int i=offset;i<end;i++)
			{
				byte b=raw[i];
				try
				{
					switch ((char)(0xff&b))
					{
						case '&':
							value = buffer.length()==0?"":buffer.toString();
							buffer.reset();
							if (key != null)
							{
								map.add(key,value);
							}
							else if (value!=null&&value.length()>0)
							{
								map.add(value,"");
							}
							key = null;
							value=null;
							break;

						case '=':
							if (key!=null)
							{
								buffer.append(b);
								break;
							}
							key = buffer.toString();
							buffer.reset();
							break;

						case '+':
							buffer.append((byte)' ');
							break;

						case '%':
							if (i+2<end)
							{
								if ('u'==raw[i+1])
								{
									i++;
									if (i+4<end)
										buffer.getStringBuilder().append(Character.toChars((convertHexDigit(raw[++i])<<12) +(convertHexDigit(raw[++i])<<8) + (convertHexDigit(raw[++i])<<4) +convertHexDigit(raw[++i])));
									else
									{
										buffer.getStringBuilder().append(Utf8Appendable.REPLACEMENT);
										i=end;
									}
								}
								else
									buffer.append((byte)((convertHexDigit(raw[++i])<<4) + convertHexDigit(raw[++i])));
							}
							else
							{
								buffer.getStringBuilder().append(Utf8Appendable.REPLACEMENT);
								i=end;
							}
							break;
							
						default:
							buffer.append(b);
							break;
					}
				}
				catch(NotUtf8Exception e)
				{
					LOG.warn(e.toString());
					LOG.debug("",e);
				}
			}
			
			if (key != null)
			{
				value = buffer.length()==0?"":buffer.toReplacedString();
				buffer.reset();
				map.add(key,value);
			}
			else if (buffer.length()>0)
			{
				map.add(buffer.toReplacedString(),"");
			}
		}
	}

	/* -------------------------------------------------------------- */
	/** Decoded parameters to Map.
	 * @param in InputSteam to read
	 * @param map MultiMap to add parameters to
	 * @param maxLength maximum number of keys to read or -1 for no limit
	 */
	public static void decode88591To(InputStream in, MultiMap map, int maxLength, int maxKeys)
	throws IOException
	{
		synchronized(map)
		{
			StringBuffer buffer = new StringBuffer();
			String key = null;
			String value = null;
			
			int b;

			// TODO cache of parameter names ???
			int totalLength=0;
			while ((b=in.read())>=0)
			{
				switch ((char) b)
				{
					case '&':
						value = buffer.length()==0?"":buffer.toString();
						buffer.setLength(0);
						if (key != null)
						{
							map.add(key,value);
						}
						else if (value!=null&&value.length()>0)
						{
							map.add(value,"");
						}
						key = null;
						value=null;
						if (maxKeys>0 && map.size()>maxKeys)
							throw new IllegalStateException("Form too many keys");
						break;
						
					case '=':
						if (key!=null)
						{
							buffer.append((char)b);
							break;
						}
						key = buffer.toString();
						buffer.setLength(0);
						break;
						
					case '+':
						buffer.append(' ');
						break;
						
					case '%':
						int code0=in.read();
						if ('u'==code0)
						{
							int code1=in.read();
							if (code1>=0)
							{
								int code2=in.read();
								if (code2>=0)
								{
									int code3=in.read();
									if (code3>=0)
										buffer.append(Character.toChars((convertHexDigit(code0)<<12)+(convertHexDigit(code1)<<8)+(convertHexDigit(code2)<<4)+convertHexDigit(code3)));
								}
							}
						}
						else if (code0>=0)
						{
							int code1=in.read();
							if (code1>=0)
								buffer.append((char)((convertHexDigit(code0)<<4)+convertHexDigit(code1)));
						}
						break;
					 
					default:
						buffer.append((char)b);
					break;
				}
				if (maxLength>=0 && (++totalLength > maxLength))
					throw new IllegalStateException("Form too large");
			}
			
			if (key != null)
			{
				value = buffer.length()==0?"":buffer.toString();
				buffer.setLength(0);
				map.add(key,value);
			}
			else if (buffer.length()>0)
			{
				map.add(buffer.toString(), "");
			}
		}
	}
	
	/* -------------------------------------------------------------- */
	/** Decoded parameters to Map.
	 * @param in InputSteam to read
	 * @param map MultiMap to add parameters to
	 * @param maxLength maximum number of keys to read or -1 for no limit
	 */
	public static void decodeUtf8To(InputStream in, MultiMap map, int maxLength, int maxKeys)
	throws IOException
	{
		synchronized(map)
		{
			Utf8StringBuilder buffer = new Utf8StringBuilder();
			String key = null;
			String value = null;
			
			int b;
			
			// TODO cache of parameter names ???
			int totalLength=0;
			while ((b=in.read())>=0)
			{
				try
				{
					switch ((char) b)
					{
						case '&':
							value = buffer.length()==0?"":buffer.toString();
							buffer.reset();
							if (key != null)
							{
								map.add(key,value);
							}
							else if (value!=null&&value.length()>0)
							{
								map.add(value,"");
							}
							key = null;
							value=null;
							if (maxKeys>0 && map.size()>maxKeys)
								throw new IllegalStateException("Form too many keys");
							break;

						case '=':
							if (key!=null)
							{
								buffer.append((byte)b);
								break;
							}
							key = buffer.toString();
							buffer.reset();
							break;

						case '+':
							buffer.append((byte)' ');
							break;

						case '%':
							int code0=in.read();
							if ('u'==code0)
							{
								int code1=in.read();
								if (code1>=0)
								{
									int code2=in.read();
									if (code2>=0)
									{
										int code3=in.read();
										if (code3>=0)
											buffer.getStringBuilder().append(Character.toChars((convertHexDigit(code0)<<12)+(convertHexDigit(code1)<<8)+(convertHexDigit(code2)<<4)+convertHexDigit(code3)));
									}
								}
							}
							else if (code0>=0)
							{
								int code1=in.read();
								if (code1>=0)
									buffer.append((byte)((convertHexDigit(code0)<<4)+convertHexDigit(code1)));
							}
							break;
						  
						default:
							buffer.append((byte)b);
							break;
					}
				}
				catch(NotUtf8Exception e)
				{
					LOG.warn(e.toString());
					LOG.debug("",e);
				}
				if (maxLength>=0 && (++totalLength > maxLength))
					throw new IllegalStateException("Form too large");
			}
			
			if (key != null)
			{
				value = buffer.length()==0?"":buffer.toString();
				buffer.reset();
				map.add(key,value);
			}
			else if (buffer.length()>0)
			{
				map.add(buffer.toString(), "");
			}
		}
	}
	
	/* -------------------------------------------------------------- */
	public static void decodeUtf16To(InputStream in, MultiMap map, int maxLength, int maxKeys) throws IOException
	{
		InputStreamReader input = new InputStreamReader(in,StringUtil.__UTF16);
		StringWriter buf = new StringWriter(8192);
		IO.copy(input,buf,maxLength);
		
		decodeTo(buf.getBuffer().toString(),map,StringUtil.__UTF16,maxKeys);
	}
	
	/* -------------------------------------------------------------- */
	/** Decoded parameters to Map.
	 * @param in the stream containing the encoded parameters
	 */
	public static void decodeTo(InputStream in, MultiMap map, String charset, int maxLength, int maxKeys)
	throws IOException
	{
		//no charset present, use the configured default
		if (charset==null) 
		{
		   charset=ENCODING;
		}
			
		if (StringUtil.__UTF8.equalsIgnoreCase(charset))
		{
			decodeUtf8To(in,map,maxLength,maxKeys);
			return;
		}
		
		if (StringUtil.__ISO_8859_1.equals(charset))
		{
			decode88591To(in,map,maxLength,maxKeys);
			return;
		}

		if (StringUtil.__UTF16.equalsIgnoreCase(charset)) // Should be all 2 byte encodings
		{
			decodeUtf16To(in,map,maxLength,maxKeys);
			return;
		}
		

		synchronized(map)
		{
			String key = null;
			String value = null;
			
			int c;
			
			int totalLength = 0;
			ByteArrayOutputStream2 output = new ByteArrayOutputStream2();
			
			int size=0;
			
			while ((c=in.read())>0)
			{
				switch ((char) c)
				{
					case '&':
						size=output.size();
						value = size==0?"":output.toString(charset);
						output.setCount(0);
						if (key != null)
						{
							map.add(key,value);
						}
						else if (value!=null&&value.length()>0)
						{
							map.add(value,"");
						}
						key = null;
						value=null;
						if (maxKeys>0 && map.size()>maxKeys)
							throw new IllegalStateException("Form too many keys");
						break;
					case '=':
						if (key!=null)
						{
							output.write(c);
							break;
						}
						size=output.size();
						key = size==0?"":output.toString(charset);
						output.setCount(0);
						break;
					case '+':
						output.write(' ');
						break;
					case '%':
						int code0=in.read();
						if ('u'==code0)
						{
							int code1=in.read();
							if (code1>=0)
							{
								int code2=in.read();
								if (code2>=0)
								{
									int code3=in.read();
									if (code3>=0)
										output.write(new String(Character.toChars((convertHexDigit(code0)<<12)+(convertHexDigit(code1)<<8)+(convertHexDigit(code2)<<4)+convertHexDigit(code3))).getBytes(charset));
								}
							}
							
						}
						else if (code0>=0)
						{
							int code1=in.read();
							if (code1>=0)
								output.write((convertHexDigit(code0)<<4)+convertHexDigit(code1));
						}
						break;
					default:
						output.write(c);
					break;
				}
				
				totalLength++;
				if (maxLength>=0 && totalLength > maxLength)
					throw new IllegalStateException("Form too large");
			}

			size=output.size();
			if (key != null)
			{
				value = size==0?"":output.toString(charset);
				output.setCount(0);
				map.add(key,value);
			}
			else if (size>0)
				map.add(output.toString(charset),"");
		}
	}
	
	/* -------------------------------------------------------------- */
	/** Decode String with % encoding.
	 * This method makes the assumption that the majority of calls
	 * will need no decoding.
	 */
	public static String decodeString(String encoded,int offset,int length,String charset)
	{
		if (charset==null || StringUtil.isUTF8(charset))
		{
			Utf8StringBuffer buffer=null;

			for (int i=0;i<length;i++)
			{
				char c = encoded.charAt(offset+i);
				if (c<0||c>0xff)
				{
					if (buffer==null)
					{
						buffer=new Utf8StringBuffer(length);
						buffer.getStringBuffer().append(encoded,offset,offset+i+1);
					}
					else
						buffer.getStringBuffer().append(c);
				}
				else if (c=='+')
				{
					if (buffer==null)
					{
						buffer=new Utf8StringBuffer(length);
						buffer.getStringBuffer().append(encoded,offset,offset+i);
					}
					
					buffer.getStringBuffer().append(' ');
				}
				else if (c=='%')
				{
					if (buffer==null)
					{
						buffer=new Utf8StringBuffer(length);
						buffer.getStringBuffer().append(encoded,offset,offset+i);
					}
					
					if ((i+2)<length)
					{
						try
						{
							if ('u'==encoded.charAt(offset+i+1))
							{
								if((i+5)<length)
								{
									int o=offset+i+2;
									i+=5;
									String unicode = new String(Character.toChars(TypeUtil.parseInt(encoded,o,4,16)));
									buffer.getStringBuffer().append(unicode); 
								}
								else
								{
									i=length;
									buffer.getStringBuffer().append(Utf8Appendable.REPLACEMENT); 
								}
							}
							else
							{
								int o=offset+i+1;
								i+=2;
								byte b=(byte)TypeUtil.parseInt(encoded,o,2,16);
								buffer.append(b);
							}
						}
						catch(NotUtf8Exception e)
						{
							LOG.warn(e.toString());
							LOG.debug("",e);
						}
						catch(NumberFormatException nfe)
						{
							LOG.debug("",nfe);
							buffer.getStringBuffer().append(Utf8Appendable.REPLACEMENT);  
						}
					}
					else
					{
						buffer.getStringBuffer().append(Utf8Appendable.REPLACEMENT); 
						i=length;
					}
				}
				else if (buffer!=null)
					buffer.getStringBuffer().append(c);
			}

			if (buffer==null)
			{
				if (offset==0 && encoded.length()==length)
					return encoded;
				return encoded.substring(offset,offset+length);
			}

			return buffer.toReplacedString();
		}
		else
		{
			StringBuffer buffer=null;

			try
			{
				for (int i=0;i<length;i++)
				{
					char c = encoded.charAt(offset+i);
					if (c<0||c>0xff)
					{
						if (buffer==null)
						{
							buffer=new StringBuffer(length);
							buffer.append(encoded,offset,offset+i+1);
						}
						else
							buffer.append(c);
					}
					else if (c=='+')
					{
						if (buffer==null)
						{
							buffer=new StringBuffer(length);
							buffer.append(encoded,offset,offset+i);
						}
						
						buffer.append(' ');
					}
					else if (c=='%')
					{
						if (buffer==null)
						{
							buffer=new StringBuffer(length);
							buffer.append(encoded,offset,offset+i);
						}

						byte[] ba=new byte[length];
						int n=0;
						while(c>=0 && c<=0xff)
						{
							if (c=='%')
							{   
								if(i+2<length)
								{
									try
									{
										if ('u'==encoded.charAt(offset+i+1))
										{
											if (i+6<length)
											{
												int o=offset+i+2;
												i+=6;
												String unicode = new String(Character.toChars(TypeUtil.parseInt(encoded,o,4,16)));
												byte[] reencoded = unicode.getBytes(charset);
												System.arraycopy(reencoded,0,ba,n,reencoded.length);
												n+=reencoded.length;
											}
											else
											{
												ba[n++] = (byte)'?';
												i=length;
											}
										}
										else
										{
											int o=offset+i+1;
											i+=3;
											ba[n]=(byte)TypeUtil.parseInt(encoded,o,2,16);
											n++;
										}
									}
									catch(NumberFormatException nfe)
									{   
										LOG.trace("",nfe);
										ba[n++] = (byte)'?';
									}
								}
								else
								{
									ba[n++] = (byte)'?';
									i=length;
								}
							}
							else if (c=='+')
							{
								ba[n++]=(byte)' ';
								i++;
							}
							else
							{
								ba[n++]=(byte)c;
								i++;
							}
							
							if (i>=length)
								break;
							c = encoded.charAt(offset+i);
						}

						i--;
						buffer.append(new String(ba,0,n,charset));

					}
					else if (buffer!=null)
						buffer.append(c);
				}

				if (buffer==null)
				{
					if (offset==0 && encoded.length()==length)
						return encoded;
					return encoded.substring(offset,offset+length);
				}

				return buffer.toString();
			}
			catch (UnsupportedEncodingException e)
			{
				throw new RuntimeException(e);
			}
		}
		
	}
	
	/* ------------------------------------------------------------ */
	/** Perform URL encoding.
	 * @param string 
	 * @return encoded string.
	 */
	public static String encodeString(String string)
	{
		return encodeString(string,ENCODING);
	}
	
	/* ------------------------------------------------------------ */
	/** Perform URL encoding.
	 * @param string 
	 * @return encoded string.
	 */
	public static String encodeString(String string,String charset)
	{
		if (charset==null)
			charset=ENCODING;
		byte[] bytes=null;
		try
		{
			bytes=string.getBytes(charset);
		}
		catch(UnsupportedEncodingException e)
		{
			// LOG.warn(LogSupport.EXCEPTION,e);
			bytes=string.getBytes();
		}
		
		int len=bytes.length;
		byte[] encoded= new byte[bytes.length*3];
		int n=0;
		boolean noEncode=true;
		
		for (int i=0;i<len;i++)
		{
			byte b = bytes[i];
			
			if (b==' ')
			{
				noEncode=false;
				encoded[n++]=(byte)'+';
			}
			else if (b>='a' && b<='z' ||
					 b>='A' && b<='Z' ||
					 b>='0' && b<='9')
			{
				encoded[n++]=b;
			}
			else
			{
				noEncode=false;
				encoded[n++]=(byte)'%';
				byte nibble= (byte) ((b&0xf0)>>4);
				if (nibble>=10)
					encoded[n++]=(byte)('A'+nibble-10);
				else
					encoded[n++]=(byte)('0'+nibble);
				nibble= (byte) (b&0xf);
				if (nibble>=10)
					encoded[n++]=(byte)('A'+nibble-10);
				else
					encoded[n++]=(byte)('0'+nibble);
			}
		}

		if (noEncode)
			return string;
		
		try
		{    
			return new String(encoded,0,n,charset);
		}
		catch(UnsupportedEncodingException e)
		{
			// LOG.warn(LogSupport.EXCEPTION,e);
			return new String(encoded,0,n);
		}
	}


	/* ------------------------------------------------------------ */
	/** 
	 */
	@Override
	public Object clone()
	{
		return new UrlEncoded(this);
	}
}