///////////////////////////////////////////////////////////////////////////////
//
//  Microsoft Research Singularity
//
//  Copyright (c) Microsoft Corporation.  All rights reserved.
//
///////////////////////////////////////////////////////////////////////////////

/*
 * This helper class assists in forming HTTP requests and retrieving the
 * resulting data.
 */

using System;
using System.Collections;
using System.Collections.Specialized;
using System.Diagnostics;
using System.Globalization;
using System.Net;
using System.Net.Sockets;
using System.Text;

public class HttpRequest
{
    private string fRequestUri, fHost, fResource, fMethod, fContentType;
    private int fHostPort;
    private byte[] fRequestData;
    private Hashtable fRequestHeaders;
    private long fTimeout; // Zero for infinite

    // CONSTANTS
    private static string proxyHost = null;
    private static int proxyPort = 0;
    const int readIncrementSize = 1024 * 2; // 2Kbytes
    const int bodySizeGuess = 5 * 1024; // 5KBytes

    public static void ConfigureProxy(string host, int port)
    {
        proxyHost = host;
        proxyPort = port;
    }

    public HttpRequest(string! uri)
    {
        fRequestUri = uri;

        // Parse the URI into a host-part and a path-part.
        const string httpPrefix = "http://";
        if (!uri.StartsWith(httpPrefix))
        {
            throw new ArgumentException("URI must begin with 'http://'");
        }

        int startIndex = httpPrefix.Length;
        int firstSlash = uri.IndexOf('/',startIndex);

        string fHost;
        if (firstSlash != -1)
        {
            fHost = uri.Substring(startIndex, firstSlash - startIndex);
            fResource = uri.Substring(firstSlash);
        }
        else
        {
            // Host is the entire Uri
            fHost = uri.Substring(startIndex);
            fResource = String.Empty;
        }

        int firstColon = fHost.IndexOf(':');

        if (firstColon != -1)
        {
            fHostPort = Int32.Parse(fHost.Substring(firstColon + 1));
        }
        else
        {
            fHostPort = 80; // default
        }

        this.fRequestHeaders = new Hashtable();
        this.fMethod = "GET";
        this.fHost = fHost;
    }

    public void AddHeader(string! headerName, string headerValue)
    {
        fRequestHeaders[headerName] = headerValue;
    }

    public string Method
    {
        get { return fMethod; }
        set { fMethod = value; }
    }

    public string ContentType
    {
        get { return fContentType; }
        set { fContentType = value; }
    }

    public byte[] RequestData
    {
        get { return fRequestData; }
        set { fRequestData = value; }
    }

    public long Timeout
    {
        get { return fTimeout; }
        set { fTimeout = value; }
    }

    public string Resource
    {
        get { return fResource; }
    }

    // Perform the HTTP hit and return the result!
    public HttpResponse GetResponse()
    {
        //
        // Step 1: Connect to the remote server
        //
        Socket httpSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream,
            ProtocolType.Tcp);

        string serverName, requestUri;
        int serverPort;

        if (proxyPort > 0)
        {
            serverName = proxyHost;
            serverPort = proxyPort;
            requestUri = fRequestUri; // Use the full URI
        }
        else
        {
            serverName = fHost;
            serverPort = fHostPort;
            requestUri = fResource; // Use just the resource
        }

        IPAddress serverAddress;

        try
        {
            serverAddress = IPAddress.Parse(serverName);
        }
        catch(Exception)
        {
            // Hostname didn't parse as an IP address; try to resolve it
            IPHostEntry! entry = (!)Dns.Resolve(serverName);
            IPAddress[]! addresses = (!)entry.AddressList;

            if (addresses.Length == 0)
            {
                throw new Exception("Couldn't resolve host name");
            }

            serverAddress = addresses[0];
        }

        IPEndPoint serverEndpoint = new IPEndPoint(serverAddress, serverPort);

        // Connect to the remote server
        httpSocket.Connect(serverEndpoint);

        //
        // Step 2: Formulate and transmit the request line and any supporting data
        //
        // Send the request line
        string requestLine = fMethod + " " + requestUri + " HTTP/1.1\r\nHost: " +
            fHost + "\r\nConnection: Close\r\n";

        // Send an indication of the request data content type and size, if appropriate
        if (fRequestData != null)
        {
            requestLine += "Content-Length: " + fRequestData.Length + "\r\n" +
                "Content-Type: " + fContentType + "\r\n";
        }

        // Add any user-specified headers
        foreach (string! headerName in fRequestHeaders.Keys)
        {
            requestLine += headerName + ": " + fRequestHeaders[headerName] + "\r\n";
        }

        requestLine += "\r\n";
        byte[] requestBytes = Encoding.ASCII.GetBytes(requestLine);
        httpSocket.Send(requestBytes);

        // Send any request data
        if (fRequestData != null)
        {
            httpSocket.Send(fRequestData);
        }

        // Signal we're done sending
        httpSocket.Shutdown(SocketShutdown.Send);

        //
        // Step 3: Parse the response line and headers
        //

        // Pump the response into an HttpHeadersParser
        ByteBuffer scratchBuffer = new ByteBuffer();
        HttpHeadersParser headerParser = new HttpHeadersParser(scratchBuffer);
        bool doneWithout100Continue = false, doneWithHeaders = false;
        int nextWritePos = 0;
        HttpResponse response = null;

        do
        {
            while(!doneWithHeaders)
            {
                // Make 2K available for each read
                scratchBuffer.EnsureSize(nextWritePos + readIncrementSize);
                int numReadBytes = httpSocket.Receive(scratchBuffer.UnderlyingBuffer, nextWritePos,
                    scratchBuffer.Size - nextWritePos, SocketFlags.None);

                if (numReadBytes == 0)
                {
                    // We ran out of data before we finished parsing headers.
                    throw new Exception("Unexpected end of data");
                }

                nextWritePos += numReadBytes;

                if (headerParser.Pump(nextWritePos))
                {
                    // Finished parsing headers!
                    response = headerParser.GetResponse();
                    doneWithHeaders = true;
                }
            }

            if (response == null)
            {
                throw new Exception("HTTP response data unexpectedly null");
            }

            // Special case: if we see a 100-continue, we want to carefully start
            // over at the next chunk of data!
            if (response.StatusCode == 100)
            {
                // Switch to a new scratch buffer that will contain the data
                // following the 100-continue.
                int remainderBeginning = headerParser.BodyDataOffset;
                int remainderLength = nextWritePos - remainderBeginning;
                ByteBuffer newScratch = new ByteBuffer();
                ByteBuffer oldScratch = scratchBuffer;

                // Reset parsing by creating a new parser
                headerParser = new HttpHeadersParser(newScratch);

                // Switch over!
                scratchBuffer = newScratch;
                nextWritePos = remainderLength;

                if (remainderLength > 0)
                {
                    // Copy the beginning of the next data chunk into newScratch
                    newScratch.EnsureSize(remainderLength);
                    Buffer.BlockCopy(oldScratch.UnderlyingBuffer, remainderBeginning,
                        newScratch.UnderlyingBuffer, 0, remainderLength);

                    // Make sure the fragment we were already holding gets pumped in
                    if (headerParser.Pump(nextWritePos))
                    {
                        // Interestingly, we're already done
                        response = headerParser.GetResponse();
                        if (response == null)
                        {
                            throw new Exception("HTTP response data unexpectedly null");
                        }
                        Debug.Assert(response.StatusCode != 100);
                        doneWithout100Continue = true;
                    }
                    else
                    {
                        // Go back and carry on
                        doneWithHeaders = false;
                    }
                }
                else
                {
                    // The chunk we were chewing on exactly contained the 100-continue,
                    // so we definitely need to go back and read some more...
                    doneWithHeaders = false;
                }
            }
            else
            {
                // The response was not 100-continue, so we're all done
                doneWithout100Continue = true;
            }
        }
        while(!doneWithout100Continue);

        //
        // Step 4: Process the body data
        //
        // Now figure out how we're going to deal with the actual body
        // of the response. We almost certainly already have an initial
        // chunk of the body data in the scratchBuffer, since we read the
        // headers in 2K chunks
        //
        int bodyScratchBeginning = headerParser.BodyDataOffset;
        int scratchBodyLength = nextWritePos - bodyScratchBeginning;

        string transferEncoding = response.GetHeader("Transfer-Encoding");
        if (transferEncoding != null &&
            transferEncoding.ToLower().Equals("chunked"))
        {
            // Chunked encoding is special: the beginning of the body data
            // already specifies some chunk information. Run this through our
            // chunk decoder to straighten it out.
            byte[] initialBodyChunk = scratchBuffer.TrimAndCopy(bodyScratchBeginning, scratchBodyLength);
            ChunkedEncodingParser chunkParser = new ChunkedEncodingParser(initialBodyChunk, httpSocket);
            ByteBuffer bodyData = chunkParser.Run();
            response.BodyData = bodyData.TrimAndCopy(bodyData.Size);
        }
        else
        {
            ByteBuffer bodyBuffer;

            // Non-chunked encoding. First, move the beginning of the body
            // data to a new ByteBuffer for sanity.
            // Separate out any initial body data into a new ByteBuffer, for sanity
            int bodySize = (response.ContentLength > 0) ? response.ContentLength : bodySizeGuess;

            // Hard to imagine how this would happen...
            if (bodySize < scratchBodyLength)
            {
                bodySize = scratchBodyLength;
            }

            bodyBuffer = new ByteBuffer(bodySize);
            Buffer.BlockCopy(scratchBuffer.UnderlyingBuffer, bodyScratchBeginning,
                bodyBuffer.UnderlyingBuffer, 0, scratchBodyLength);
            int nextBodyPos = scratchBodyLength;

            if (response.ContentLength > 0)
            {
                // Read until we've gotten exactly the expected number of bytes
                int bodyDataLeft = response.ContentLength - scratchBodyLength;

                while (bodyDataLeft > 0)
                {
                    int numReadBytes = httpSocket.Receive(bodyBuffer.UnderlyingBuffer, nextBodyPos,
                        bodyDataLeft, SocketFlags.None);

                    if (numReadBytes == 0)
                    {
                        throw new Exception("Connection closed unexpectedly");
                    }

                    nextBodyPos += numReadBytes;
                    bodyDataLeft -= numReadBytes;
                }
            }
            else
            {
                // No indicated ContentLength; Just read until the connection gets closed!
                int numReadBytes = 0;

                // Read until the remote side closes
                do
                {
                    bodyBuffer.EnsureSize(bodyBuffer.Size + readIncrementSize);
                    numReadBytes = httpSocket.Receive(bodyBuffer.UnderlyingBuffer, nextBodyPos,
                        bodyBuffer.Size - nextBodyPos, SocketFlags.None);
                    nextBodyPos += numReadBytes;
                }
                while (numReadBytes > 0);
            }

            response.BodyData = bodyBuffer.TrimAndCopy(nextBodyPos);
        }

        // All done!
        httpSocket.Close();

        return response;
    }

    private class HttpHeadersParser
    {
        // The buffer we are chewing on
        ByteBuffer fBuffer;

        // The response we are forming
        private HttpResponse fResponse;
        private int fContentLength;

        // Working state
        private State fState;
        private int fPosition;
        private int fBufferLimit; // One more than the last usable index in the buffer

        private enum State
        {
            BeforeStatusLine,
            ParsingHeaders,
            Complete
        }

        public HttpHeadersParser(ByteBuffer buffer)
        {
            fBuffer = buffer;
            fResponse = new HttpResponse();
        }

        public bool Pump(int newBufferLimit)
        {
            bool allDone = false, outOfRoom = false;

            while ((!allDone) && (!outOfRoom))
            {
                PumpInternal(newBufferLimit, out allDone, out outOfRoom);
            }

            return allDone;
        }

        private void PumpInternal(int newBufferLimit, out bool allDone, out bool outOfRoom)
        {
            fBufferLimit = newBufferLimit;

            if (fState == State.Complete)
            {
                // We've already completed
                allDone = true;
                outOfRoom = false;
                return;
            }

            int CRLFOffset = FindNextCRLF(fPosition, fBufferLimit);

            if (fState == State.BeforeStatusLine)
            {
                if (CRLFOffset != -1)
                {
                    HandleStatusLine(fPosition, CRLFOffset - fPosition);
                    fState = State.ParsingHeaders;
                    fPosition = CRLFOffset + 2;
                    allDone = false;
                    outOfRoom = false;
                    return;
                }
                else
                {
                    // We couldn't see another CRLF before the end of the
                    // usable part of the buffer, so we're out of room.
                    allDone = false;
                    outOfRoom = true;
                    return;
                }
            }
            else if (fState == State.ParsingHeaders)
            {
                // Special case: if the unprocessed part starts with CRLF it
                // means we are looking at the end of the headers, since we consume
                // the trailing CRLF on a single header line when parsing.
                if (CRLFOffset == fPosition)
                {
                    fState = State.Complete;
                    fPosition += 2;
                    allDone = true;
                    outOfRoom = false;
                    return;
                }
                else if (CRLFOffset != -1)
                {
                    HandleHeaderLine(fPosition, CRLFOffset - fPosition);
                    fPosition = CRLFOffset + 2;
                    allDone = false;
                    outOfRoom = false;
                    return;
                }
                else
                {
                    // We couldn't see another CRLF before the end of the
                    // usable part of the buffer, so we're out of room.
                    allDone = false;
                    outOfRoom = true;
                    return;
                }
            }

            // Someone must have added a state or mucked up the code
            allDone = false;
            outOfRoom = false;
            Debug.Assert(false);
        }

        public HttpResponse GetResponse()
        {
            if (fState == State.Complete)
            {
                return fResponse;
            }
            else
            {
                // Not allowed to have half-baked results!
                return null;
            }
        }

        public int BodyDataOffset
        {
            get
            {
                if (fState == State.Complete)
                {
                    return fPosition;
                }
                else
                {
                    // No answer if we're not done processing
                    return -1;
                }
            }
        }

        public int ContentLength
        {
            get
            {
                if (fState == State.Complete)
                {
                    return fContentLength;
                }
                else
                {
                    // Not available if we're not done processing
                    return -1;
                }
            }
        }

        private void HandleStatusLine(int startOffset, int length)
        {
            string status = Encoding.ASCII.GetString(fBuffer.UnderlyingBuffer, startOffset, length);
            const string HTTP11 = "HTTP/1.1 ";

            if (!status.StartsWith(HTTP11))
            {
                throw new Exception("Response was not HTTP/1.1");
            }

            int secondSpace = status.IndexOf(' ', HTTP11.Length);
            string statusString;

            if (secondSpace == -1)
            {
                // Assume this means there is a status code with no explanation string
                statusString = status.Substring(HTTP11.Length);
            }
            else
            {
                // Grab just the status code
                statusString = status.Substring(HTTP11.Length, secondSpace - HTTP11.Length);
            }

            int statusCode = Int32.Parse(statusString);
            fResponse.StatusCode = statusCode;
        }

        private void HandleHeaderLine(int startOffset, int length)
        {
            string header = Encoding.ASCII.GetString(fBuffer.UnderlyingBuffer, startOffset, length);
            int firstColon = header.IndexOf(':');

            if (firstColon == -1)
            {
                throw new Exception("Malformed header string");
            }

            string headerName = header.Substring(0, firstColon);
            string headerValue = header.Substring(firstColon + 1).Trim();

            if (headerName.ToLower().Equals("content-length"))
            {
                fContentLength = Int32.Parse(headerValue);
            }
            else
            {
                fResponse.AddHeader(headerName, headerValue);
            }
        }

        private int FindNextCRLF(int startOffset, int limitOffset)
        {
            int offset = startOffset;

            while (offset < limitOffset)
            {
                if (fBuffer[offset] == (byte)'\r')
                {
                    if ((offset + 1 < limitOffset) && (fBuffer[offset + 1] == (byte)'\n'))
                    {
                        return offset;
                    }
                }

                offset++;
            }

            return -1;
        }
    }

    private class ChunkedEncodingParser
    {
        // This buffer is what we start with; it has an initial
        // fragment of the body data
        private byte[] fInitialFragment;
        private int fFragmentOffset; // How far into fInitialFragment we are
        private Socket fSocket; // Socket to read additional data from
        private byte[] fSingleByte;

        public ChunkedEncodingParser(byte[] initialFragment, Socket readSocket)
        {
            fInitialFragment = initialFragment;
            fSocket = readSocket;
            fSingleByte = new byte[1];
        }

        public ByteBuffer! Run()
        {
            ByteBuffer bodyData = new ByteBuffer();
            int chunkSize = 0;

            while(true)
            {
                ByteBuffer! chunkLine = ReadToCRLF();
                string! chunkString = (!)Encoding.ASCII.GetString(chunkLine.UnderlyingBuffer, 0, chunkLine.Size);
                chunkString = (!)chunkString.Trim();
                int firstSemi = chunkString.IndexOf(';');

                if (firstSemi != -1)
                {
                    // Use only the portion before the semicolon
                    chunkSize = Int32.Parse(chunkString.Substring(0, firstSemi),
                        NumberStyles.AllowHexSpecifier);
                }
                else
                {
                    // No semicolon; use the entire line
                    chunkSize = Int32.Parse(chunkString, NumberStyles.AllowHexSpecifier);
                }

                if (chunkSize == 0)
                {
                    // We're done! Don't bother reading the trailer
                    return bodyData;
                }

                // Read in the amount indicated by the chunk header. It may take multiple passes
                // to do this.
                int writeOffset = bodyData.Size;
                bodyData.EnsureSize(bodyData.Size + chunkSize);

                while(chunkSize > 0)
                {
                    int numBytesRead = MassRead(bodyData.UnderlyingBuffer, writeOffset, chunkSize);
                    chunkSize -= numBytesRead;
                    writeOffset += numBytesRead;
                }

                // Peel off the CRLF that trails a chunk
                ByteBuffer emptyLine = ReadToCRLF();
                if (emptyLine.Size != 0)
                {
                    throw new Exception("Malformed HTTP/1.1 chunk -- no trailing lone CRLF");
                }
            }
        }

        private ByteBuffer! ReadToCRLF()
        {
            ByteBuffer retval = new ByteBuffer();
            InnerReadToCRLF(retval);
            return retval;
        }

        private void InnerReadToCRLF(ByteBuffer buffer) // buffer can be null
        {
            // Read characters into buffer until we see a CRLF (don't include)
            byte nextByte = GetNextByte();

            while(true)
            {
                if (nextByte == (byte)'\r')
                {
                    nextByte = GetNextByte();

                    if (nextByte == (byte)'\n')
                    {
                        // Done
                        return;
                    }
                    else
                    {
                        if (buffer != null)
                        { buffer.Add((byte)'\r'); }

                        // Don't read again; nextByte might
                        // be the first byte of CRLF.
                    }
                }
                else
                {
                    if (buffer != null)
                    { buffer.Add(nextByte); }
                    nextByte = GetNextByte();
                }
            }
        }

        private void DiscardToCRLF()
        {
            InnerReadToCRLF(null);
        }

        private byte GetNextByte()
        {
            if (fFragmentOffset < fInitialFragment.Length)
            {
                return fInitialFragment[fFragmentOffset++];
            }
            else
            {
                int received = fSocket.Receive(fSingleByte, 0, 1, SocketFlags.None);
                if (received == 1)
                {
                    return fSingleByte[0];
                }
                else
                {
                    throw new Exception("Connection closed unexpectedly");
                }
            }
        }

        private int MassRead(byte[] buffer, int offset, int maxLength)
        {
            if (fFragmentOffset < fInitialFragment.Length)
            {
                // Still data left in the original fragment; return as much
                // of that as possible.
                int initialFragmentLeft = fInitialFragment.Length - fFragmentOffset;
                int amountToUse = maxLength <= initialFragmentLeft ? maxLength : initialFragmentLeft;
                Buffer.BlockCopy(fInitialFragment, fFragmentOffset, buffer, offset, amountToUse);
                fFragmentOffset += amountToUse;
                return amountToUse;
            }
            else
            {
                // No data left in the initial fragment; read from the network.
                return fSocket.Receive(buffer, offset, maxLength, SocketFlags.None);
            }
        }
    }
}