#include <string>
#include <vector>
#include <stdexcept>
#include <expat.h>
#include "xmlrulereader.h"
#include "rule.h"
#include "stringset.h"

using namespace std;

RuleData::RuleData (
    boost::shared_ptr<StringSet<char> > dictionaryParameter,
    boost::shared_ptr<StringSet<char> > passiveDictionaryParameter,
    boost::shared_ptr<vector<boost::shared_ptr<Rule> > > ruleVectorParameter ) :
        dictionary ( dictionaryParameter ),
        passiveDictionary ( passiveDictionaryParameter ),
        ruleVector ( ruleVectorParameter )
{
    dictionaryFound = false;
    initialiseAttributes();
    ruleCount = 0;
}

RuleData::~RuleData()
{ }

XmlRuleReader::XmlRuleReader (
    boost::shared_ptr<StringSet<char> > dictionaryParameter,
    boost::shared_ptr<StringSet<char> > passiveDictionaryParameter,
    boost::shared_ptr<vector<boost::shared_ptr<Rule> > > ruleVectorParameter ) :
        ud ( new RuleData (
                 dictionaryParameter,
                 passiveDictionaryParameter,
                 ruleVectorParameter ) )
{
    ud->setState ( STATE_UNKNOWN );
    ud->p = p;

    XML_SetUserData ( p, ud.get() );
    XML_SetElementHandler ( p, start, end );
    XML_SetCharacterDataHandler ( p, characterdata );
}

XmlRuleReader::~XmlRuleReader()
{}

int XmlRuleReader::getRuleCount()
{
    return ud->ruleCount;
}

string XmlRuleReader::getIncorrectPatternReport()
{
    return ud->incorrectPatternReport;
}

void XmlRuleReader::getExcludeVector ( vector<string> &v )
{
    v = ud->excludeVector;
}

void XmlRuleReader::getIncludeVector ( vector<string> &v )
{
    v = ud->includeVector;
}

void XMLCALL XmlRuleReader::start (
    void *data,
    const XML_Char *el,
    const XML_Char **attr )
{
    RuleData *ud;
    ud = ( RuleData * ) data;

    if ( !strcmp ( el, "rule" ) )
        ud->setState ( STATE_IN_RULE );
    else if ( !strcmp ( el, "term" ) )
    {
        ud->setState ( STATE_IN_TERM );
        while ( *attr )
        {
            if ( !strcmp ( *attr, "passive" ) && !strcmp ( * ( attr + 1 ), "true" ) )
                ud->passive = true;
            attr += 2;
        }
    }
    else if ( !strcmp ( el, "find" ) )
    {
        while ( *attr )
        {
            if ( !strcmp ( *attr, "matchcase" ) && !strcmp ( * ( attr + 1 ), "true" ) )
                ud->matchcase = true;
            else if ( !strcmp ( *attr, "cipher" ) && !strcmp ( * ( attr + 1 ), "true" ) )
                ud->cipher = true;
            attr += 2;
        }
        ud->setState ( STATE_IN_FIND );
    }
    else if ( !strcmp ( el, "replace" ) )
    {
        while ( *attr )
        {
            if ( !strcmp ( *attr, "adjustcase" ) && !strcmp ( * ( attr + 1 ), "true" ) )
                ud->adjustcase = true;
            else if ( !strcmp ( *attr, "tentative" ) && !strcmp ( * ( attr + 1 ), "true" ) )
                ud->tentative = true;
            attr += 2;
        }
        ud->setState ( STATE_IN_REPLACE );
    }
    else if ( !strcmp ( el, "report" ) )
        ud->setState ( STATE_IN_REPORT );
    else if ( !strcmp ( el, "exclude" ) )
        ud->setState ( STATE_IN_EXCLUDE );
    else if ( !strcmp ( el, "include" ) )
        ud->setState ( STATE_IN_INCLUDE );
    else if ( !strcmp ( el, "title" ) )
        ud->setState ( STATE_IN_TITLE );
    else
        ud->setState ( STATE_UNKNOWN );
}

void XMLCALL XmlRuleReader::end ( void *data, const XML_Char *el )
{
    RuleData *ud;
    ud = ( RuleData * ) data;

    if ( !strcmp ( el, "term" ) )
    {
        if ( ud->term != "" )
        {
            ud->dictionary->insert ( ud->term );
            ud->dictionaryFound = true;
            if ( ud->passive )
            {
                ud->passiveDictionary->insert ( ud->term );
                ud->passive = false;
            }

            ud->term = "";
        }
        ud->setState ( STATE_UNKNOWN );
    }
    // handle end of rule
    else if ( !strcmp ( el, "rule" ) )
    {
        try
        {
            boost::shared_ptr<Rule> rule ( new Rule (
                                               ud->find,
                                               ud->matchcase,
                                               ud->replace ) );

            string report = ud->title;
            if ( ud->report != "" )
            {
                report += ": ";
                report += ud->report;
            }
            rule->setReport ( report );

            rule->setTentativeAttribute ( ud->tentative );
            rule->setAdjustCaseAttribute ( ud->adjustcase );
            ud->ruleVector->push_back ( rule );
            ++ ( ud->ruleCount );

            ud->find = "";
            ud->replace = "";
            ud->report = "";
            ud->setState ( STATE_UNKNOWN );
            ud->initialiseAttributes();
        }
        catch ( exception& e )
        {
            ud->incorrectPatternReport = "Cannot compile: " +
                                         ud->find +
                                         "\r\nError: " +
                                         e.what();
            XML_StopParser ( ud->p, XML_FALSE );
        }
    }
    else if ( !strcmp ( el, "find" ) )
        ud->setState ( STATE_UNKNOWN );
    else if ( !strcmp ( el, "replace" ) )
        ud->setState ( STATE_UNKNOWN );
    else if ( !strcmp ( el, "report" ) )
        ud->setState ( STATE_UNKNOWN );

    // handle excludes/includes
    else if ( !strcmp ( el, "exclude" ) )
    {
        ud->excludeVector.push_back ( ud->exclude );
        ud->exclude = "";
        ud->setState ( STATE_UNKNOWN );
    }
    else if ( !strcmp ( el, "include" ) )
    {
        ud->includeVector.push_back ( ud->include );
        ud->include = "";
        ud->setState ( STATE_UNKNOWN );
    }
    else if ( !strcmp ( el, "title" ) )
        ud->setState ( STATE_UNKNOWN );

    // count each dictionary as one rule
    else if ( !strcmp ( el, "dictionary" ) )
    {
        if ( ud->dictionaryFound )
            ++ ( ud->ruleCount );
    }
}

void XMLCALL XmlRuleReader::characterdata (
    void *data,
    const XML_Char *s,
    int len )
{
    RuleData *ud;
    ud = ( RuleData * ) data;

    switch ( ud->getState() )
    {
    case STATE_IN_FIND:
        ud->find.append ( s, len );
        break;
    case STATE_IN_REPLACE:
        ud->replace.append ( s, len );
        break;
    case STATE_IN_REPORT:
        ud->report.append ( s, len );
        break;
    case STATE_IN_EXCLUDE:
        ud->exclude.append ( s, len );
        break;
    case STATE_IN_INCLUDE:
        ud->include.append ( s, len );
        break;
    case STATE_IN_TITLE:
        ud->title.append ( s, len );
        break;
    case STATE_IN_TERM:
        ud->term.append ( s, len );
        break;
    default:
        break;
    }
}

void RuleData::initialiseAttributes()
{
    matchcase = adjustcase = tentative = passive = false;
}