/**
 * @file lltextparser.cpp
 *
 * $LicenseInfo:firstyear=2001&license=viewerlgpl$
 * Second Life Viewer Source Code
 * Copyright (C) 2010, 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 "linden_common.h"

#include "lltextparser.h"

#include "llsd.h"
#include "llsdserialize.h"
#include "llerror.h"
#include "lluuid.h"
#include "llstring.h"
#include "message.h"
#include "llmath.h"
#include "v4color.h"
#include "lldir.h"

//
// Member Functions
//

LLTextParser::LLTextParser()
:   mLoaded(false)
{}


S32 LLTextParser::findPattern(const std::string &text, LLSD highlight)
{
    if (!highlight.has("pattern")) return -1;

    std::string pattern=std::string(highlight["pattern"]);
    std::string ltext=text;

    if (!(bool)highlight["case_sensitive"])
    {
        ltext   = utf8str_tolower(text);
        pattern= utf8str_tolower(pattern);
    }

    size_t found=std::string::npos;

    switch ((S32)highlight["condition"])
    {
        case CONTAINS:
            found = ltext.find(pattern);
            break;
        case MATCHES:
            found = (! ltext.compare(pattern) ? 0 : std::string::npos);
            break;
        case STARTS_WITH:
            found = (! ltext.find(pattern) ? 0 : std::string::npos);
            break;
        case ENDS_WITH:
            S32 pos = ltext.rfind(pattern);
            if (pos >= 0 && (ltext.length()-pattern.length()==pos)) found = pos;
            break;
    }
    return found;
}

LLSD LLTextParser::parsePartialLineHighlights(const std::string &text, const LLColor4 &color, EHighlightPosition part, S32 index)
{
    loadKeywords();

    //evil recursive string atomizer.
    LLSD ret_llsd, start_llsd, middle_llsd, end_llsd;

    for (S32 i=index;i<mHighlights.size();i++)
    {
        S32 condition = mHighlights[i]["condition"];
        if ((S32)mHighlights[i]["highlight"]==PART && condition!=MATCHES)
        {
            if ( (condition==STARTS_WITH && part==START) ||
                 (condition==ENDS_WITH   && part==END)   ||
                  condition==CONTAINS    || part==WHOLE )
            {
                S32 start = findPattern(text,mHighlights[i]);
                if (start >= 0 )
                {
                    S32 end =  std::string(mHighlights[i]["pattern"]).length();
                    S32 len = text.length();
                    EHighlightPosition newpart;
                    if (start==0)
                    {
                        start_llsd[0]["text"] =text.substr(0,end);
                        start_llsd[0]["color"]=mHighlights[i]["color"];

                        if (end < len)
                        {
                            if (part==END   || part==WHOLE) newpart=END; else newpart=MIDDLE;
                            end_llsd=parsePartialLineHighlights(text.substr( end ),color,newpart,i);
                        }
                    }
                    else
                    {
                        if (part==START || part==WHOLE) newpart=START; else newpart=MIDDLE;

                        start_llsd=parsePartialLineHighlights(text.substr(0,start),color,newpart,i+1);

                        if (end < len)
                        {
                            middle_llsd[0]["text"] =text.substr(start,end);
                            middle_llsd[0]["color"]=mHighlights[i]["color"];

                            if (part==END   || part==WHOLE) newpart=END; else newpart=MIDDLE;

                            end_llsd=parsePartialLineHighlights(text.substr( (start+end) ),color,newpart,i);
                        }
                        else
                        {
                            end_llsd[0]["text"] =text.substr(start,end);
                            end_llsd[0]["color"]=mHighlights[i]["color"];
                        }
                    }

                    S32 retcount=0;

                    //FIXME These loops should be wrapped into a subroutine.
                    for (LLSD::array_iterator iter = start_llsd.beginArray();
                         iter != start_llsd.endArray();++iter)
                    {
                        LLSD highlight = *iter;
                        ret_llsd[retcount++]=highlight;
                    }

                    for (LLSD::array_iterator iter = middle_llsd.beginArray();
                         iter != middle_llsd.endArray();++iter)
                    {
                        LLSD highlight = *iter;
                        ret_llsd[retcount++]=highlight;
                    }

                    for (LLSD::array_iterator iter = end_llsd.beginArray();
                         iter != end_llsd.endArray();++iter)
                    {
                        LLSD highlight = *iter;
                        ret_llsd[retcount++]=highlight;
                    }

                    return ret_llsd;
                }
            }
        }
    }

    //No patterns found.  Just send back what was passed in.
    ret_llsd[0]["text"] =text;
    LLSD color_sd = color.getValue();
    ret_llsd[0]["color"]=color_sd;
    return ret_llsd;
}

bool LLTextParser::parseFullLineHighlights(const std::string &text, LLColor4 *color)
{
    loadKeywords();

    for (S32 i=0;i<mHighlights.size();i++)
    {
        if ((S32)mHighlights[i]["highlight"]==ALL || (S32)mHighlights[i]["condition"]==MATCHES)
        {
            if (findPattern(text,mHighlights[i]) >= 0 )
            {
                LLSD color_llsd = mHighlights[i]["color"];
                color->setValue(color_llsd);
                return TRUE;
            }
        }
    }
    return FALSE;   //No matches found.
}

std::string LLTextParser::getFileName()
{
    std::string path=gDirUtilp->getExpandedFilename(LL_PATH_PER_SL_ACCOUNT, "");

    if (!path.empty())
    {
        path = gDirUtilp->getExpandedFilename(LL_PATH_PER_SL_ACCOUNT, "highlights.xml");
    }
    return path;
}

void LLTextParser::loadKeywords()
{
    if (mLoaded)
    {// keywords already loaded
        return;
    }
    std::string filename=getFileName();
    if (!filename.empty())
    {
        llifstream file;
        file.open(filename.c_str());
        if (file.is_open())
        {
            LLSDSerialize::fromXML(mHighlights, file);
        }
        file.close();
        mLoaded = true;
    }
}

bool LLTextParser::saveToDisk(LLSD highlights)
{
    mHighlights=highlights;
    std::string filename=getFileName();
    if (filename.empty())
    {
        LL_WARNS() << "LLTextParser::saveToDisk() no valid user directory." << LL_ENDL;
        return FALSE;
    }
    llofstream file;
    file.open(filename.c_str());
    LLSDSerialize::toPrettyXML(mHighlights, file);
    file.close();
    return TRUE;
}