// PPUrl.cpp: implementation of the CPPUrl class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "PPUrl.h"
#include "passportexception.h"
#include "pputils.h"
#include "pphandlerbase.h"

#define LONG_DIGITS     10

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CPPUrl::CPPUrl(LPCSTR pszUrl)
{
    m_pszQuestion = NULL;
    Set(pszUrl);
}

BOOL CPPUrl::GetQParamQuick(LPCSTR qsStart, LPCSTR name, UINT nameStrLen, LPCSTR& qpStart, LPCSTR& qpEnd)
{
   _ASSERT(nameStrLen >= 2); // = sign is required
   _ASSERT(name[nameStrLen - 1] == '=');   // high perf
   _ASSERT(name[nameStrLen] != '?');   // high perf
   _ASSERT(name[nameStrLen] != '&');   // high perf
   _ASSERT(strlen(name) == nameStrLen); // high perf

   if (!qsStart) return FALSE;
   
   LPCSTR p = qsStart;

   while(p = strstr(p, name))
   {
      if (p == qsStart || *(p - 1) == '&')
      {
         qpStart = p + nameStrLen;
         break;
      }

      p += nameStrLen;
   }
   
   if (qpStart)
   {
      qpEnd = (LPSTR)strchr(qpStart, '&');
      return TRUE;
   }
   return FALSE;
}

BOOL CPPUrl::GetQParamQuick(LPCSTR qsStart, LPCSTR name, UINT nameStrLen, INT& value)
{
   LPCSTR qpS = NULL;
   LPCSTR qpE = NULL;

   if(GetQParamQuick(qsStart, name, nameStrLen, qpS, qpE))
   {
      char qpEChar;
      if (qpE != NULL)
      {
         qpEChar = *(LPSTR)qpE;
         *(LPSTR)qpE = 0;
      }

      value = atoi(qpS);

      if (qpE != NULL)
         *(LPSTR)qpE  = qpEChar;
         
      return TRUE;
   }
   return FALSE;
}
 

void CPPUrl::Set(LPCSTR pszUrl)
{
    if (NULL != pszUrl)
    {
        CPPQueryString::Set(pszUrl);
        m_pszQuestion = strchr(m_pszBegin, '?');
    }
}

void CPPUrl::Set(LPCWSTR pwszUrl)
{
    if (NULL != pwszUrl)
    {
        CPPQueryString::Set(pwszUrl);
        m_pszQuestion = strchr(m_pszBegin, '?');
    }
}

void CPPUrl::Reinit()
{
    if (NULL == m_psz)
    {
        CPPQueryString::Reinit();
        m_pszQuestion = strchr(m_pszBegin, '?');
    }
}

void CPPQueryString::Set(LPCSTR lpsz)
{
    if (NULL != lpsz)
    {
        long len = lstrlenA(lpsz);
        if (len > (signed) (ATL_URL_MAX_URL_LENGTH-1))
        {
            throw CPassportException(__FILE__";url length exceeded max",
                                     __LINE__,
                                     E_FAIL,
                                     len, 
                                     ATL_URL_MAX_URL_LENGTH);
        }

        UnlockData();

        m_pszBegin = m_psz = LockData();
        lstrcpynA(m_psz, lpsz, ATL_URL_MAX_URL_LENGTH); 
        m_psz += len; 
    }
}

void CPPQueryString::Set(LPCWSTR lpwsz)
{
    if (NULL != lpwsz)
    {
        long len = lstrlenW(lpwsz);
        long lIndex = len;
        if (len > (signed) (ATL_URL_MAX_URL_LENGTH-1))
        {
            throw CPassportException(__FILE__";url length exceeded max",
                                     __LINE__,
                                     E_FAIL,
                                     len, 
                                     ATL_URL_MAX_URL_LENGTH);
        }

        UnlockData();       // balanced the last LockBuffer;

        m_pszBegin = m_psz = LockData();
        for (;lIndex>0;lIndex--)
        {
            *m_psz++ = (char) *lpwsz++;     // lpcwstr must be true ASCII) !!
        }
        *m_psz = 0;
    }
}

void CPPQueryString::Reinit()
{
    if (NULL == m_psz)
    {
        m_pszBegin = m_psz = LockData();
        m_psz += lstrlenA(m_psz); 
    }
}

void CPPQueryString::Uninit(bool bUnlock)
{
    if (bUnlock)
    {
        UnlockData();
    }
    else
    {
        // to deal with anomalies of CString class that doesn't respect preallocate
        // during operator=, we need to remain locked when casting to CString *
        if (!m_bLockedCString)
            LockData();
    }

    if (NULL != m_psz)
    {
        m_pszBegin = m_psz = NULL;
    }
}

#define TOHEX(a) ((a)>=10 ? 'a'+(a)-10 : '0'+(a))

void CPPQueryString::DoParamAdd(LPCWSTR pwszParamValue, bool fEncoding)
{
    long lleng = lstrlenW(pwszParamValue);
    long lStartStrLen = (long) (m_psz - m_pszBegin);

    if (lleng == 0)
    { 
        return; 
    }

    if (lStartStrLen >= (signed) (ATL_URL_MAX_URL_LENGTH-lleng-1))
    {
         throw CPassportException(  __FILE__";url length exceeded max",
                                    __LINE__,
                                    E_FAIL,
                                    lleng, 
                                    ATL_URL_MAX_URL_LENGTH);
    }
    
    if (!fEncoding)
    {
        while (*pwszParamValue)
        {
            *m_psz++ = (char) *pwszParamValue;  // we know this cast is safe for non-unicode wchar
            pwszParamValue++;
        }
    }
    else
    {
        long        lIndex = 0;
        char        ch;
        long        lEncodedLen = lleng;  // assume no encoding happens
        UINT        uiValue;

        while (lIndex < lleng)
        {
            ch = (char)pwszParamValue[lIndex];  // we know this cast is safe for non-unicode wchar      
            if ( AtlIsUnsafeUrlChar(ch) )
            {
                if (ch == ' ')
                {
                    *m_psz++ = '+';
                }
                else
                {
                    // size of encoding increased by two
                    lEncodedLen +=2;
                    // check to see if we are still within the limit
                    if (lStartStrLen + lEncodedLen >= (signed) (ATL_URL_MAX_URL_LENGTH - 1))
                    {
                        throw CPassportException(   __FILE__";url length exceeded max",
                                                    __LINE__,
                                                    E_FAIL,
                                                    lEncodedLen, 
                                                    ATL_URL_MAX_URL_LENGTH);
                    }
                    //output the percent, followed by the hex value of the character
                    *m_psz++ = '%';
                    uiValue = ch >> 4;
                    *m_psz++ = TOHEX(uiValue);
                    uiValue = ch & 0x0f;
                    *m_psz++ = TOHEX(uiValue);
                }
            }
            else //safe character
            {
                *m_psz++ = ch;
            }
            ++lIndex;
        }
    }
    *m_psz = 0;
}


void CPPQueryString::DoParamAdd(LPCSTR pszParamValue, bool fEncoding)
{
    long lleng = lstrlenA(pszParamValue);
    long lStartStrLen = (long) (m_psz - m_pszBegin);

    if (lleng == 0)
    { 
        return; 
    }

    if (lStartStrLen >= (signed) (ATL_URL_MAX_URL_LENGTH-lleng-1))
    {
        throw CPassportException(__FILE__";url length exceeded max",
                                 __LINE__,
                                 E_FAIL,
                                 lleng, 
                                 ATL_URL_MAX_URL_LENGTH);
    }
    
    if (!fEncoding)
    {
        lstrcpynA(m_psz, pszParamValue, lleng+1);
        m_psz += lleng;
    }
    else
    {
        long        lIndex = 0;
        char        ch;
        long        lEncodedLen = lleng;  // assume no encoding happens
        UINT        uiValue;

        while (lIndex < lleng)
        {
            ch = pszParamValue[lIndex];        
            if ( AtlIsUnsafeUrlChar(ch) )
            {
                if (ch == ' ')
                {
                    *m_psz++ = '+';
                }
                else
                {
                    // size of encoding increased by two
                    lEncodedLen +=2;
                    // check to see if we are still within the limit
                    if (lStartStrLen + lEncodedLen >= (signed) (ATL_URL_MAX_URL_LENGTH - 1))
                    {
                        throw CPassportException(   __FILE__";url length exceeded max",
                                                    __LINE__,
                                                    E_FAIL,
                                                    lEncodedLen, 
                                                    ATL_URL_MAX_URL_LENGTH);
                    }
                    //output the percent, followed by the hex value of the character
                    *m_psz++ = '%';
                    uiValue = ch >> 4;
                    *m_psz++ = TOHEX(uiValue);
                    uiValue = ch & 0x0f;
                    *m_psz++ = TOHEX(uiValue);
                }
            }
            else //safe character
            {
                *m_psz++ = ch;
            }
            ++lIndex;
        }
    }
    *m_psz = 0;
}


void CPPQueryString::AddQueryParam(LPCSTR pszParamName, LPCWSTR pwszParamValue, bool bTrueUnicode, bool fEncoding)
{
    Reinit();
    if (NULL == pszParamName)
    {
        ATLASSERT(FALSE);
        //*** assert/exception.
    }

    long lleng = lstrlenA(pszParamName);
    // 3 for '?' or '&', '=' and NULL
    if ((m_psz-m_pszBegin) >= (signed) (ATL_URL_MAX_URL_LENGTH-lleng-3))
    {
         throw CPassportException(  __FILE__";url length exceeded max",
                                    __LINE__,
                                    E_FAIL,
                                    lleng, 
                                    ATL_URL_MAX_URL_LENGTH);
    }
    if (m_psz > m_pszBegin && '?' != *(m_psz-1) && '&' != *(m_psz-1))
    {
        *m_psz++ = '&';
        *m_psz = 0;
    }

    lstrcpynA(m_psz, pszParamName, lleng+1);
    m_psz += lleng;
    *m_psz++ = '=';
    *m_psz = 0;

    if (NULL != pwszParamValue)
    {
        if (!bTrueUnicode)
        {
            DoParamAdd(pwszParamValue, fEncoding);
        }
        else
        {
            CStringA cszA;
            ::Unicode2Mbcs(pwszParamValue, 1252 /*ANSI codepage*/,  true, cszA);
            DoParamAdd(cszA, fEncoding);
        }
    }
}

void CPPQueryString::AddQueryParam(LPCSTR pszParamName, LPCSTR pszParamValue, bool fEncoding)
{
    Reinit();
    if (NULL == pszParamName)
    {
        //*** assert/exception.
    }
    long lleng = lstrlenA(pszParamName);
    // 3 for '?' or '&', '=' and NULL
    if ((m_psz-m_pszBegin) >= (signed) (ATL_URL_MAX_URL_LENGTH-lleng-3))
    {
         throw CPassportException(  __FILE__";url length exceeded max",
                                    __LINE__,
                                    E_FAIL,
                                    lleng, 
                                    ATL_URL_MAX_URL_LENGTH);
    }
    if (m_psz > m_pszBegin && '?' != *(m_psz-1) && '&' != *(m_psz-1))
    {
        *m_psz++ = '&';
        *m_psz = 0;
    }

    lstrcpynA(m_psz, pszParamName, lleng+1);
    m_psz += lleng;
    *m_psz++ = '=';
    *m_psz = 0;

    if (NULL != pszParamValue)
    {
        DoParamAdd(pszParamValue, fEncoding);
    }
}

bool CPPQueryString::StripQueryParam(LPCSTR pszParamName)
{
    ATLASSERT(pszParamName);
    Reinit();
    bool fIncremented;

    if (m_pszBegin == m_psz)
    {
        // No string, so everything is already stripped
        return false;
    }

    long lleng = lstrlenA(pszParamName);
    char *pszIndex = m_pszBegin;
    while (*pszIndex)
    {
        // Is this the beginning of a new parameter?
        if ((*pszIndex == '?') || (*pszIndex == '&') || (pszIndex == m_pszBegin))
        {
            // move past '?' or '&'
            if ((*pszIndex == '?') || (*pszIndex == '&'))
            {
                fIncremented = true;
                ++pszIndex;
            }
            else
            {
                fIncremented = false;
            }
            
            // is this the param we are looking for?
            if (strnicmp(pszIndex, pszParamName, lleng) == 0)
            {
                // make sure it is an exact match
                if (pszIndex[lleng] == '=')
                {
                    // find the end of the param value
                    char *pszEnd = pszIndex + lleng + 1;
                    while ((*pszEnd != '&') && *pszEnd)
                    {
                        ++pszEnd;
                    }
                    // Was this the last param
                    if (!*pszEnd)
                    {
                        // if previously incremented, back up one
                        if (fIncremented)
                        {
                            --pszIndex;
                        }
                    }
                    else
                    {
                        // need to move params on end
                        ++pszEnd; // move past '&'
                        while (*pszEnd)
                        {
                            *pszIndex = *pszEnd;
                            ++pszIndex;
                            ++pszEnd;
                        }
                    }

                    // null terminate and exit
                    *pszIndex = '\0';
                    m_psz = pszIndex;
                    return true;
                }
            }

            // if this was not incremented, make sure it gets incremented
            if (!fIncremented)
            {
                ++pszIndex;
            }
        }
        else
        {
            ++pszIndex;
        }
    }

    return false;
}

void CPPUrl::AddQueryParam(LPCSTR pszParamName, long lValue)
{
    Reinit();
    char szLong[LONG_DIGITS + 1];
    ltoa(lValue, szLong, 10);
    AddQueryParam(pszParamName, szLong, false);
}

void CPPUrl::AddQueryParam(LPCSTR pszParamName, LPCSTR pszParamValue, bool fEncoding)
{
    Reinit();
    if (!m_pszQuestion)
    {
        // 2 for '?', and NULL
        if ((m_psz-m_pszBegin) >= (signed) (ATL_URL_MAX_URL_LENGTH-2))
        {
            throw CPassportException(__FILE__";url too long",__LINE__,E_FAIL);
        }
        m_pszQuestion = m_psz;
        *m_psz++ = '?';
        *m_psz = 0;
    }
    CPPQueryString::AddQueryParam(pszParamName, pszParamValue, fEncoding);
}

void CPPUrl::AddQueryParam(LPCSTR pszParamName, LPCWSTR pwszParamValue, bool bTrueUnicode, bool fEncoding)
{
    Reinit();
    if (!m_pszQuestion)
    {
        // 2 for '?', and NULL
        if ((m_psz-m_pszBegin) >= (signed) (ATL_URL_MAX_URL_LENGTH-2))
        {
            throw CPassportException(__FILE__";url too long",__LINE__,E_FAIL);
        }
        m_pszQuestion = m_psz;
        *m_psz++ = '?';
        *m_psz = 0;
    }
    CPPQueryString::AddQueryParam(pszParamName, pwszParamValue, bTrueUnicode, fEncoding);
}

void CPPUrl::AppendQueryString(LPCSTR pszQueryString)
{
    if (NULL == pszQueryString)
        return;
    
    Reinit();
    long lLeng = lstrlenA(pszQueryString);
    if (!m_pszQuestion)
        lLeng++;

    if ((m_psz-m_pszBegin) >= (signed) (ATL_URL_MAX_URL_LENGTH-1-lLeng))
    {
        ATLASSERT(FALSE);
        throw CPassportException(__FILE__";url too long",__LINE__,E_FAIL);
    }
    if (!m_pszQuestion)
    {
        m_pszQuestion = m_psz;
        *m_psz++ = '?';
        lLeng--;
    }

    lstrcpyA(m_psz, pszQueryString);
    m_psz += lLeng;
}

//pszQueryString doesn't contain leading '?' or '&'
void CPPUrl::InsertBQueryString(LPCSTR pszQueryString)
{
    Reinit();
    if (!m_pszQuestion)
    {
        AppendQueryString(pszQueryString);
    }
    else
    {
        long lLeng = lstrlenA(pszQueryString);
        if ((m_psz-m_pszBegin) >= (signed) (ATL_URL_MAX_URL_LENGTH-1-lLeng-1))
        {
            ATLASSERT(FALSE);
            throw CPassportException(__FILE__";url too long",__LINE__,E_FAIL);
        }
        memmove(m_pszQuestion+1+lLeng+1, m_pszQuestion+1, m_psz-m_pszQuestion-1);
        memmove(m_pszQuestion+1, pszQueryString, lLeng);
        *(m_pszQuestion+1+lLeng) = '&';
        m_psz += lLeng+1;
        *m_psz = '\0';
    }
}

void CPPUrl::MakeSecure()
{
    Reinit();

    if (0 == _strnicmp(m_pszBegin, "http:", 5))     // at least it's a http protocol url
    {
        // make sure there is room for one more char
        if ((m_psz-m_pszBegin) >= (signed) (ATL_URL_MAX_URL_LENGTH-1))
        {
            ATLASSERT(FALSE);
            throw CPassportException(__FILE__";url too long",__LINE__,E_FAIL);
        }
        memmove(m_pszBegin+5, m_pszBegin+4, m_psz-m_pszBegin-4);
        m_pszBegin[4] = 's';
        *(++m_psz) = 0;
        if (m_pszQuestion)
        {
            m_pszQuestion++;
        }
    }
}
void CPPUrl::MakeNonSecure()
{
    Reinit();

    if (0 == _strnicmp(m_pszBegin, "https:", 6))        // at least it's a http protocol url
    {
        memmove(m_pszBegin+4, m_pszBegin+5, m_psz-m_pszBegin-5);
        *(--m_psz) = 0;
        if (m_pszQuestion)
        {
            m_pszQuestion--;
        }
    }
}

void CPPUrl::ReplaceQueryParam(LPCSTR pszParamName, LPCSTR pszParamValue)
{
    if (!pszParamName)
    {
        //todo -- badbad
    }
    Reinit();
    long nlen = lstrlenA(pszParamName);

    char *psz = StrStrA(m_pszBegin, pszParamName);
    while (psz != NULL && (psz==m_pszBegin || (*(psz-1) != '?' && *(psz-1) != '&') ||
            (*(psz+nlen) != '=' && *(psz+nlen) != '&'))) // not a query parameter
    {
        psz = strstr(psz+nlen, pszParamName);
    }
    if (NULL == psz)
        AddQueryParam(pszParamName, pszParamValue);
    else
    {
        //todo*** figure out the old value length
        psz += lstrlenA(pszParamName);
        long nold = 0;
        if (pszParamValue)
            nlen = lstrlenA(pszParamValue);
        else
            nlen = 0;

        if (*psz != '=')
        {
            ATLASSERT(*psz == '&');
            memmove(psz+1+nlen, psz, lstrlenA(psz));
            *psz = '=';
            if (nlen)
                memcpy(psz+1, pszParamValue, nlen);
        }
        else
        {
            char *pszNext = StrStrA(psz, "&");
            if (NULL == pszNext)
                nold = lstrlenA(psz+1);
            else
                nold = (long) (pszNext-psz-1);
            memmove(psz+1+nlen, psz+1+nold, lstrlenA(psz+1+nold));
            if (nlen)
                memcpy(psz+1, pszParamValue, nlen);
        }
    }
}

void CPPUrl::MakeFullUrl(LPCSTR pszUrlPath, bool bSecure)
{
    Reinit();
    CPassportHandlerBase* p = CPassportHandlerBase::GetPPHandler();
    ATLASSERT( p != NULL && "this method is limited to a handler.");

    CStringA cszA;
    if (bSecure)
    {
        lstrcpyA(m_pszBegin, "https://");
        m_psz = m_pszBegin + 8;
    }
    else
    {
        lstrcpyA(m_pszBegin, "http://");
        m_psz = m_pszBegin + 7;
    }

    p->GetAServerVariable("SERVER_NAME", cszA);
    lstrcpyA(m_psz, cszA);
    m_psz += cszA.GetLength();
    
    *(m_psz++) = '/';
    *m_psz = '\0';
    
    long len = lstrlenA(pszUrlPath);
    if (len)
    {
        if ((m_psz-m_pszBegin) >= (signed) (ATL_URL_MAX_URL_LENGTH-1-len))
        {
            ATLASSERT(FALSE);
            throw CPassportException(__FILE__";url too long",__LINE__,E_FAIL);
        }
        lstrcpyA(m_psz, pszUrlPath);
        m_pszQuestion = strchr(m_psz, '?');
        m_psz += len;
    }
    else
    {
        m_pszQuestion = NULL;
    }
}

void CPPUrl::ReplacePath(LPCSTR pszUrlPath)
{
    Reinit();
    m_psz = StrStrA(m_pszBegin, "://");
    if (NULL == m_psz)
    {
        ATLASSERT(FALSE);       // not good -- it was not a url to begin with
        throw CPassportException(__FILE__, __LINE__, E_INVALIDARG, 0, 0, 0);
    }
    m_psz += 3;

    m_psz = StrStrA(m_psz, "/");
    if (NULL == m_psz)
    {
        // url contained host name only.  Append first path separator, and then
        // new path.
        m_psz = m_pszBegin + lstrlenA(m_pszBegin);
        *(m_psz++) = '/';        
    }
    else
    {
        m_psz++;
    }

    long len = lstrlenA(pszUrlPath);
    if ((m_psz-m_pszBegin) >= (signed) (ATL_URL_MAX_URL_LENGTH-1-len))
    {
        ATLASSERT(FALSE);
        throw CPassportException(__FILE__";url too long",__LINE__,E_FAIL);
    }
    lstrcpyA(m_psz, pszUrlPath);
    m_psz += len;
    m_pszQuestion = strchr(m_pszBegin, '?');
}


CPPUrl & CPPUrl::operator += (LPCSTR pcszAppend)
{
    Reinit();

    long lLeng = lstrlenA(pcszAppend);
    if ((m_psz-m_pszBegin) >= (signed) (ATL_URL_MAX_URL_LENGTH-lLeng))
    {
        ATLASSERT(FALSE);
        throw CPassportException(__FILE__";url too long",__LINE__,E_FAIL);
    }
    lstrcpynA(m_psz, pcszAppend, lLeng+1);
    m_psz += lLeng;
    m_pszQuestion = strchr(m_pszBegin, '?');
    return *this;
}