//
//  ========================================================================
//  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.server;

import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.Writer;

import org.eclipse.jetty.http.HttpGenerator;
import org.eclipse.jetty.util.ByteArrayOutputStream2;
import org.eclipse.jetty.util.StringUtil;

/** OutputWriter.
 * A writer that can wrap a {@link AbstractHttpConnection.Output} stream and provide
 * character encodings.
 *
 * The UTF-8 encoding is done by this class and no additional 
 * buffers or Writers are used.
 * The UTF-8 code was inspired by http://javolution.org
 */
public final class HttpWriter extends Writer
{
	private static final int MAX_OUTPUT_CHARS = 512; 
	
	private static final int WRITE_CONV = 0;
	private static final int WRITE_ISO1 = 1;
	private static final int WRITE_UTF8 = 2;
	
	private final AbstractHttpConnection.Output _out;
	private int _writeMode;
	private int _surrogate;

	public HttpWriter(AbstractHttpConnection.Output out)
	{
		_out = out;
		_surrogate = 0; // AS lastUTF16CodePoint
	}

	public void setCharacterEncoding(String encoding)
	{
		if (encoding == null || StringUtil.__ISO_8859_1.equalsIgnoreCase(encoding))
		{
			_writeMode = WRITE_ISO1;
		}
		else if (StringUtil.__UTF8.equalsIgnoreCase(encoding))
		{
			_writeMode = WRITE_UTF8;
		}
		else
		{
			_writeMode = WRITE_CONV;
			if (_out._characterEncoding == null || !_out._characterEncoding.equalsIgnoreCase(encoding))
				_out._converter = null; // Set lazily in getConverter()
		}
		
		_out._characterEncoding = encoding;
		if (_out._bytes==null)
			_out._bytes = new ByteArrayOutputStream2(MAX_OUTPUT_CHARS);
	}

	@Override
	public void close() throws IOException
	{
		_out.close();
	}

	@Override
	public void flush() throws IOException
	{
		_out.flush();
	}

	@Override
	public void write (String s,int offset, int length) throws IOException
	{   
		while (length > MAX_OUTPUT_CHARS)
		{
			write(s, offset, MAX_OUTPUT_CHARS);
			offset += MAX_OUTPUT_CHARS;
			length -= MAX_OUTPUT_CHARS;
		}

		if (_out._chars==null)
		{
			_out._chars = new char[MAX_OUTPUT_CHARS]; 
		}
		char[] chars = _out._chars;
		s.getChars(offset, offset + length, chars, 0);
		write(chars, 0, length);
	}

	@Override
	public void write (char[] s,int offset, int length) throws IOException
	{              
		while (length > 0)
		{  
			_out._bytes.reset();
			int chars = length>MAX_OUTPUT_CHARS?MAX_OUTPUT_CHARS:length;
			
			switch (_writeMode)
			{
				case WRITE_CONV:
				{
					Writer converter = getConverter();
					converter.write(s, offset, chars);
					converter.flush();
				}
				break;

				case WRITE_ISO1:
				{
					byte[] buffer = _out._bytes.getBuf();
					int bytes = _out._bytes.getCount();
					
					if (chars>buffer.length-bytes)
						chars=buffer.length-bytes;

					for (int i = 0; i < chars; i++)
					{
						int c = s[offset+i];
						buffer[bytes++]=(byte)(c<256?c:'?'); // ISO-1 and UTF-8 match for 0 - 255
					}
					if (bytes>=0)
						_out._bytes.setCount(bytes);

					break;
				}

				case WRITE_UTF8:
				{
					byte[] buffer = _out._bytes.getBuf();
					int bytes = _out._bytes.getCount();

					if (bytes+chars>buffer.length)
						chars=buffer.length-bytes;

					for (int i = 0; i < chars; i++)
					{
						int code = s[offset+i];

						// Do we already have a surrogate?
						if(_surrogate==0)
						{
							// No - is this char code a surrogate?
							if(Character.isHighSurrogate((char)code))
							{
								_surrogate=code; // UCS-?
								continue;
							}                            
						}
						// else handle a low surrogate
						else if(Character.isLowSurrogate((char)code))
						{
							code = Character.toCodePoint((char)_surrogate, (char)code); // UCS-4
						}
						// else UCS-2
						else
						{
							code=_surrogate; // UCS-2
							_surrogate=0; // USED
							i--;
						}

						if ((code & 0xffffff80) == 0) 
						{
							// 1b
							if (bytes>=buffer.length)
							{
								chars=i;
								break;
							}
							buffer[bytes++]=(byte)(code);
						}
						else
						{
							if((code&0xfffff800)==0)
							{
								// 2b
								if (bytes+2>buffer.length)
								{
									chars=i;
									break;
								}
								buffer[bytes++]=(byte)(0xc0|(code>>6));
								buffer[bytes++]=(byte)(0x80|(code&0x3f));
							}
							else if((code&0xffff0000)==0)
							{
								// 3b
								if (bytes+3>buffer.length)
								{
									chars=i;
									break;
								}
								buffer[bytes++]=(byte)(0xe0|(code>>12));
								buffer[bytes++]=(byte)(0x80|((code>>6)&0x3f));
								buffer[bytes++]=(byte)(0x80|(code&0x3f));
							}
							else if((code&0xff200000)==0)
							{
								// 4b
								if (bytes+4>buffer.length)
								{
									chars=i;
									break;
								}
								buffer[bytes++]=(byte)(0xf0|(code>>18));
								buffer[bytes++]=(byte)(0x80|((code>>12)&0x3f));
								buffer[bytes++]=(byte)(0x80|((code>>6)&0x3f));
								buffer[bytes++]=(byte)(0x80|(code&0x3f));
							}
							else if((code&0xf4000000)==0)
							{
								// 5b
								if (bytes+5>buffer.length)
								{
									chars=i;
									break;
								}
								buffer[bytes++]=(byte)(0xf8|(code>>24));
								buffer[bytes++]=(byte)(0x80|((code>>18)&0x3f));
								buffer[bytes++]=(byte)(0x80|((code>>12)&0x3f));
								buffer[bytes++]=(byte)(0x80|((code>>6)&0x3f));
								buffer[bytes++]=(byte)(0x80|(code&0x3f));
							}
							else if((code&0x80000000)==0)
							{
								// 6b
								if (bytes+6>buffer.length)
								{
									chars=i;
									break;
								}
								buffer[bytes++]=(byte)(0xfc|(code>>30));
								buffer[bytes++]=(byte)(0x80|((code>>24)&0x3f));
								buffer[bytes++]=(byte)(0x80|((code>>18)&0x3f));
								buffer[bytes++]=(byte)(0x80|((code>>12)&0x3f));
								buffer[bytes++]=(byte)(0x80|((code>>6)&0x3f));
								buffer[bytes++]=(byte)(0x80|(code&0x3f));
							}
							else
							{
								buffer[bytes++]=(byte)('?');
							} 

							_surrogate=0; // USED

							if (bytes==buffer.length)
							{
								chars=i+1;
								break;
							}
						}
					}
					_out._bytes.setCount(bytes);
					break;
				}
				default:
					throw new IllegalStateException();
			}
			
			_out._bytes.writeTo(_out);
			length-=chars;
			offset+=chars;
		}
	}

	private Writer getConverter() throws IOException
	{
		if (_out._converter == null)
			_out._converter = new OutputStreamWriter(_out._bytes, _out._characterEncoding);
		return _out._converter;
	}   
}