/*

* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*

*/

#include <wchar.h>

#include <stddef.h>

#include <iostream>

#include "cpixidxdb.h"

#include "itk.h"

#include "config.h"

#include "testutils.h"

#include "setupsentry.h"

// internal (inc/private) headers from cpix - that is why these tests

// are whitebox tests

#include "cpixtools.h"

#include "iidxdb.h"

#include "iqrytype.h"

#include "cpixexc.h"

#include "cpixhits.h"

#include "idxdbdelta.h"

#include "std_log_result.h"

void TestBaseAppClassCollision(Itk::TestMgr * testMgr)

{

    cpix_Result

        result;

    char *xml_file = (char*)__FUNCTION__;

    assert_failed = 0;

    cpix_IdxDb_defineVolume(&result,

                            SMS_QBASEAPPCLASS,

                            NULL);

    if(!cpix_Succeeded(&result))

        assert_failed = 1;        

    ITK_ASSERT(testMgr,

               cpix_Succeeded(&result),

               "Definition of volume (%s, %s) failed.",

               SMS_QBASEAPPCLASS,

               "<default>");

    cpix_IdxDb_defineVolume(&result,

                            SMS_QBASEAPPCLASS,

                            NULL);

    if(!cpix_Succeeded(&result))

        assert_failed = 1; 

    ITK_ASSERT(testMgr,

               cpix_Succeeded(&result),

               "Re-definition of identical volume (%s, %s) failed.",

               SMS_QBASEAPPCLASS,

               "<default>");

    const char

        * dummyPath = "\\dummy\\path";

    cpix_IdxDb_defineVolume(&result,

                            SMS_QBASEAPPCLASS,

                            dummyPath);

    if(!cpix_Succeeded(&result))

        assert_failed = 1; 

    ITK_ASSERT(testMgr,

               cpix_Failed(&result),

               "Volume (%s, %s) definition should have failed.",

               SMS_QBASEAPPCLASS,

               dummyPath);

    cpix_IdxDb_undefineVolume("@0:root foo bar");

    testResultXml(xml_file);

}

#define DUMMY_QBASEAPPCLASS "@0:root dummy"

#define DUMMY2_QBASEAPPCLASS "@0:root dummy2"

#define DUMMY_IDXDBPATH     "c:\\Data\\indexing\\indexdb\\root\\dummy"

void TestIdxDbPathCollision(Itk::TestMgr * testMgr)

{

    cpix_Result

        result;

    char *xml_file = (char*)__FUNCTION__;

    assert_failed = 0;

    cpix_IdxDb_defineVolume(&result,

                      DUMMY_QBASEAPPCLASS,

                      DUMMY_IDXDBPATH);

    if(!cpix_Succeeded(&result))

        assert_failed = 1;

    ITK_ASSERT(testMgr,

               cpix_Succeeded(&result),

               "Defining volume %s, %s failed.",

               DUMMY_QBASEAPPCLASS,

               DUMMY_IDXDBPATH);

    cpix_IdxDb_defineVolume(&result,

                      DUMMY2_QBASEAPPCLASS,

                      DUMMY_IDXDBPATH);

    if(!cpix_Succeeded(&result))

        assert_failed = 1;

    ITK_ASSERT(testMgr,

               cpix_Failed(&result),

               "Defining volume %s, %s should have failed.",

               DUMMY2_QBASEAPPCLASS,

               DUMMY_IDXDBPATH);

    testResultXml(xml_file);

}

void TestScrapAll(Itk::TestMgr * testMgr)

{

    cpix_Result

        result;

    char *xml_file = (char*)__FUNCTION__;

    assert_failed = 0;

    cpix_IdxDb_defineVolume(&result,

                            SMS_QBASEAPPCLASS,

                            NULL);

    if (cpix_Succeeded(&result))

        {

            cpix_IdxDb

                * idxDb = cpix_IdxDb_openDb(&result,

                                            SMS_QBASEAPPCLASS,

                                            cpix_IDX_CREATE);

            if (cpix_Succeeded(&result))

                {

            assert_failed = 1;

                    cpix_IdxDb_releaseDb(idxDb);

                }

        }

    ITK_ASSERT(testMgr,

               cpix_Succeeded(&result),

               "Definition and creation of IdxDb (%s, %s) failed",

               SMS_QBASEAPPCLASS,

               "<default>");

    cpix_IdxDb_dbgScrapAll(&result);

    cpix_IdxDb

        * idxDb = cpix_IdxDb_openDb(&result,

                                    SMS_QBASEAPPCLASS,

                                    cpix_IDX_OPEN);

    if (cpix_Succeeded(&result))

        {

            cpix_IdxDb_releaseDb(idxDb);

        }

    else

        {

            assert_failed = 1;

        }

    ITK_ASSERT(testMgr,

               cpix_Failed(&result),

               "Opening IdxDb(%s) should have failed now.",

               SMS_QBASEAPPCLASS);

    testResultXml(xml_file);

}

const wchar_t * QryStrings[] = {

    // should pass:

    L"$foo",

    L"$bar<1.2,'blabla',3>",

    L" $ bar < 1.2 , 'blabla' , 3 > ",

    L"$barf(inner query)",

    L" $ barf ( inner query ) ",

    L"$barfology<'bloblo',3.1415>(inner query)",

    L" $ barfology < 'bloblo' , 3.1415 > ( inner query ) ",

    L"some query",

    L"*",

    L"* AND some more criteria", // special case: "innery query" is the whole

    // should fail:

    L"$barf<1.23(blo)",

    L"$farb<1.23>(blo",

    L"$farb<1.23>(blo ) oops more data",

    // end of test data

    NULL

};

void TestUnifiedSearchParse(Itk::TestMgr * )

{

    using namespace std;

    char *xml_file = (char*)__FUNCTION__;

    assert_failed = 0;

    printf("Whitebox testing parsing of unified search syntax\n\n");

    const wchar_t

        ** p = QryStrings;

    for (; *p != NULL; ++p)

        {

            printf("Trying to parse %S:\n",

                   *p);

            try {

                Cpix::QryCall

                    qc(*p);

                printf("\to qry type id: %S\n",

                       qc.qryTypeId_.c_str());

                printf("\to qry arguments: ");

                list<wstring>::const_iterator

                    i = qc.args_.begin(),

                    end = qc.args_.end();

                for (; i != end; ++i)

                    {

                        printf("%S ",

                               i->c_str());

                    }

                printf("\n");

                printf("\to inner qry: '%S'\n",

                       qc.innerQryStr_.c_str());

            } catch (CpixExc & cpixExc) {

                assert_failed = 1;

                printf("Failed to parse: %S\n",

                       cpixExc.wWhat());

            } catch (...) {

                assert_failed = 1;

                printf("Failed t parse: for unknown reasons\n");

            }

        }

    testResultXml(xml_file);

}

class PageContext : public Itk::ITestContext

{

private:

    //

    // private members

    //

    SmsIdxUtil         * util_;

    cpix_Analyzer      * analyzer_;

    cpix_Query         * query_;

    cpix_QueryParser   * queryParser_;

    size_t               pageSize_;

    size_t               expectedHitCount_;

public:

    //

    // from interface Itk::ITestContext

    //

    virtual void setup() throw (Itk::PanicExc)

    {

        SetupSentry

            ss(*this);

        util_ = new SmsIdxUtil;

        util_->init();

        cpix_Result

            result;

        analyzer_ = cpix_CreateSimpleAnalyzer(&result);

        if (analyzer_ == NULL)

            {

                ITK_PANIC("Could not create analyzer");

            }

        queryParser_ = cpix_QueryParser_create(&result,

                                               LBODY_FIELD,

                                               analyzer_);

        if (queryParser_ == NULL)

            {

                ITK_PANIC("Could not create query parser");

            }

        query_ = cpix_QueryParser_parse(queryParser_,

                                        L"abc");

        if (cpix_Failed(queryParser_) || query_ == NULL)

            {

                ITK_PANIC("Could not parse query string");

            }

        ss.setupComplete();

    }

    virtual void tearDown() throw ()

    {

        cleanup();

    }

    virtual ~PageContext()

    {

        cleanup();

    }

    //

    // public operations

    //

    PageContext()

        : util_(NULL),

          analyzer_(NULL),

          query_(NULL),

          queryParser_(NULL),

          pageSize_(Cpix::IdxDbMgr::instance()->getClHitsPageSize())

    {

        expectedHitCount_ = 4 * pageSize_ - 3;

    }

    void testAddSome(Itk::TestMgr  * mgr)

    {

        char *xml_file = (char*)__FUNCTION__;

        assert_failed = 0;

        std::wstring

            firstBody,

            secondBody;

        for (int i = 0; i < expectedHitCount_; ++i)

            {

                generateTwoSmsBodies(i,

                                     firstBody,

                                     secondBody);

                util_->indexSms(2*i,

                                firstBody.c_str(),

                                analyzer_,

                                mgr);

                util_->indexSms(2*i + 1,

                                secondBody.c_str(),

                                analyzer_,

                                mgr);

                if ((i % 5) == 0)

                    {

                        ITK_DBGMSG(mgr,

                                   ".");

                    }

            }

        util_->flush();

        testResultXml(xml_file);

    }

    void testSearchPages(Itk::TestMgr * mgr)

    {

        cpix_Hits

            * hits = cpix_IdxDb_search(util_->idxDb(),

                                       query_);

        char *xml_file = (char*)__FUNCTION__;

        assert_failed = 0;

        if (cpix_Failed(util_->idxDb()))

            {

                ITK_EXPECT(mgr,

                           false,

                           "Failed to search index");

                cpix_ClearError(util_->idxDb());

                assert_failed = 1;

            }

        else

            {

                int32_t

                    hitsLength = cpix_Hits_length(hits);

                ITK_EXPECT(mgr,

                           expectedHitCount_ == hitsLength,

                           "Did not get expected hitcounts (%d), but %d",

                           expectedHitCount_,

                           hitsLength);

                if(expectedHitCount_ != hitsLength)

                    {

                    assert_failed = 1;

                    }

                printf("Got %d hits\n",

                       hitsLength);

                search(hits,

                       0,

                       2 * pageSize_,

                       mgr);

                search(hits,

                       3 * pageSize_,

                       4 * pageSize_,

                       mgr);

                search(hits,

                       0,

                       pageSize_,

                       mgr);

                search(hits,

                       2 * pageSize_,

                       4 * pageSize_,

                       mgr);

            }

        cpix_Hits_destroy( hits );  

        testResultXml(xml_file);

    }

private:

    //

    // private methods

    //

    void cleanup()

    {

        delete util_;

        util_ = NULL;

        cpix_Analyzer_destroy(analyzer_);

        analyzer_ = NULL;

        cpix_Query_destroy(query_);

        query_ = NULL;;

        cpix_QueryParser_destroy(queryParser_);

        queryParser_ = NULL;

    }

    void generateTwoSmsBodies(int            idx,

                              std::wstring & firstBody,

                              std::wstring & secondBody)

    {

        static wchar_t

            firstBuf[] =  L"hello abc                ",

            secondBuf[] = L"hola, xyz                ";

        //                            ^

        enum //                       |

        {    //                       |

            VARIANT_POS =             10

        };

        wchar_t

            * p1 = firstBuf + VARIANT_POS,

            * p2 = secondBuf + VARIANT_POS;

        static const int

            radix = 'z' - 'a' + 1;

        int

            length = sizeof(firstBuf) / sizeof(wchar_t) - VARIANT_POS;

        bool

            firstRun = true;

        while (length > 0)

            {

                if (!firstRun && idx == 0)

                    {

                        *p1 = L' ';

                        *p2 = L' ';

                        break;

                    }

                int

                    digit = idx % radix;

                wchar_t

                    charDigit = L'a' + digit;

                *p1 = charDigit;

                *p2 = charDigit;

                ++p1;

                ++p2;

                idx = idx / radix;

                firstRun = false;

            }

        firstBody = firstBuf;

        secondBody = secondBuf;

    }

    void search(cpix_Hits    * hits,

                int32_t        from,

                int32_t        to,

                Itk::TestMgr * mgr)

    {

        printf("Printing hit docs from hit doc idx %d to %d\n",

               from,

               to);

        for (int32_t hitDocIdx = from; hitDocIdx < to; ++hitDocIdx)

            {

                cpix_Document

                    doc;

                cpix_Hits_doc(hits,

                              hitDocIdx,

                              &doc);