/**
 * @file httpheaders.cpp
 * @brief Implementation of the HTTPHeaders class
 *
 * $LicenseInfo:firstyear=2012&license=viewerlgpl$
 * Second Life Viewer Source Code
 * Copyright (C) 2012-2013, Linden Research, Inc.
 *
 * This library is free software; you can 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 only.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
 * $/LicenseInfo$
 */

#include "httpheaders.h"

#include "llstring.h"


namespace LLCore
{


HttpHeaders::HttpHeaders()
{}


HttpHeaders::~HttpHeaders()
{}


void
HttpHeaders::clear()
{
    mHeaders.clear();
}


void HttpHeaders::append(const std::string & name, const std::string & value)
{
    mHeaders.push_back(value_type(name, value));
}


void HttpHeaders::append(const char * name, const char * value)
{
    mHeaders.push_back(value_type(name, value));
}


void HttpHeaders::appendNormal(const char * header, size_t size)
{
    std::string name;
    std::string value;

    int col_pos(0);
    for (; col_pos < size; ++col_pos)
    {
        if (':' == header[col_pos])
            break;
    }

    if (col_pos < size)
    {
        // Looks like a header, split it and normalize.
        // Name is everything before the colon, may be zero-length.
        name.assign(header, col_pos);

        // Value is everything after the colon, may also be zero-length.
        const size_t val_len(size - col_pos - 1);
        if (val_len)
        {
            value.assign(header + col_pos + 1, val_len);
        }

        // Clean the strings
        LLStringUtil::toLower(name);
        LLStringUtil::trim(name);
        LLStringUtil::trimHead(value);
    }
    else
    {
        // Uncertain what this is, we'll pack it as
        // a name without a value.  Won't clean as we don't
        // know what it is...
        name.assign(header, size);
    }

    mHeaders.push_back(value_type(name, value));
}


// Find from end to simulate a tradition of using single-valued
// std::map for this in the past.
const std::string * HttpHeaders::find(const std::string &name) const
{
    const_reverse_iterator iend(rend());
    for (const_reverse_iterator iter(rbegin()); iend != iter; ++iter)
    {
        if ((*iter).first == name)
        {
            return &(*iter).second;
        }
    }
    return NULL;
}

void HttpHeaders::remove(const char *name)
{
    remove(std::string(name));
}

void HttpHeaders::remove(const std::string &name)
{
    iterator iend(end());
    for (iterator iter(begin()); iend != iter; ++iter)
    {
        if ((*iter).first == name)
        {
            mHeaders.erase(iter);
            return;
        }
    }
}


// Standard Iterators
HttpHeaders::iterator HttpHeaders::begin()
{
    return mHeaders.begin();
}


HttpHeaders::const_iterator HttpHeaders::begin() const
{
    return mHeaders.begin();
}


HttpHeaders::iterator HttpHeaders::end()
{
    return mHeaders.end();
}


HttpHeaders::const_iterator HttpHeaders::end() const
{
    return mHeaders.end();
}


// Standard Reverse Iterators
HttpHeaders::reverse_iterator HttpHeaders::rbegin()
{
    return mHeaders.rbegin();
}


HttpHeaders::const_reverse_iterator HttpHeaders::rbegin() const
{
    return mHeaders.rbegin();
}


HttpHeaders::reverse_iterator HttpHeaders::rend()
{
    return mHeaders.rend();
}


HttpHeaders::const_reverse_iterator HttpHeaders::rend() const
{
    return mHeaders.rend();
}


// Return the raw container to the caller.
//
// To be used FOR UNIT TESTS ONLY.
//
HttpHeaders::container_t & HttpHeaders::getContainerTESTONLY()
{
    return mHeaders;
}


}   // end namespace LLCore