/*

* 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 <algorithm>

#include "cpixfstools.h"

#include "itk.h"

#include "cpixidxdb.h"

#include "config.h"

#include "suggestion.h"

#include "testutils.h"

#include "testcorpus.h"

#include "setupsentry.h"

/****

 * Simple test cases (one client)

 */

class SimpleSmsContext : public Itk::ITestContext

{

protected:

    //

    // protected members

    //

    SmsIdxUtil        * util_;

    cpix_Analyzer     * analyzer_;

    cpix_Query        * query_;

    cpix_Query        * termsQuery_;

    cpix_QueryParser  * queryParser_;

    LineTestCorpusRef   corpus_;

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"happy");

        if (cpix_Failed(queryParser_)

            || query_ == NULL)

            {

                ITK_PANIC("Could not parse query string");

            }

        // terms (suggestions) query using unified search API

        termsQuery_ = cpix_QueryParser_parse(queryParser_,

                                             L"$terms<50>(h*)");

        if (cpix_Failed(queryParser_)

            || termsQuery_ == NULL)

            {

                ITK_PANIC("Could not parse terms query string");

            }

        ss.setupComplete();

    }

    virtual void tearDown() throw()

    {

        cleanup();

    }

    virtual ~SimpleSmsContext()

    {

        cleanup();

    }

    //

    // public operations

    //

    SimpleSmsContext()

        : util_(NULL),

          analyzer_(NULL),

          query_(NULL),

          termsQuery_(NULL),

          queryParser_(NULL),

          corpus_(DEFAULT_TEST_CORPUS_PATH)

    {

        ;

    }

private:

    //

    // private methods

    //

    void cleanup()

    {

        delete util_;

        util_ = NULL;

        cpix_Analyzer_destroy(analyzer_);

        analyzer_ = NULL;

        cpix_Query_destroy(query_);

        query_ = NULL;

        cpix_Query_destroy(termsQuery_);

        termsQuery_ = NULL;

        cpix_QueryParser_destroy(queryParser_);

        queryParser_ = NULL;

    }

};

/********

 * Simple Indexing Test Sequence

 */

class SimpleIdxSeq : public SimpleSmsContext

{

public:

    void testAddSome(Itk::TestMgr * testMgr)

    {

        using namespace Itk;

        Timestamp

            start,

            end;

        getTimestamp(&start);

        for (size_t i = 0; i < 200; ++i) 

            {

                std::wstring

                    body = corpus_.item(i);

                util_->indexSms(i,

                                body.c_str(),

                                analyzer_,

                                testMgr);

                if ((i % 5) == 0)

                    {

                        ITK_DBGMSG(testMgr,

                                   ".");

                    }

            }

        getTimestamp(&end);

        long

            ms = getElapsedMs(&end,

                              &start);

        ITK_REPORT(testMgr,

                   "Adding 200 SMS",

                   "%d ms",

                   ms);

        util_->flush();

    }

    void testSearch(Itk::TestMgr * testMgr)

    {

        using namespace Itk;

        Timestamp

            start,

            end;

        getTimestamp(&start);

        cpix_Hits

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

                                       query_);

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

            {

                ITK_EXPECT(testMgr,

                           false,

                           "Failed to search index");

                cpix_ClearError(util_->idxDb());

            }

        else

            {

                util_->printHits(hits,

                                 testMgr);

            }

        getTimestamp(&end);

        cpix_Hits_destroy( hits );  

        long

            ms = getElapsedMs(&end,

                              &start);

        ITK_REPORT(testMgr,

                   "Searching 'happy' in 200 SMS idx",

                   "%d ms",

                   ms);

    }

    void testSuggest(Itk::TestMgr * testMgr)

    {

        using namespace Itk;

        Timestamp

            start,

            end;

        getTimestamp(&start);

        // getting terms (suggestions) using unified search API

        cpix_Hits

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

                                       termsQuery_);

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

            {

                ITK_EXPECT(testMgr,

                           false,

                           "Failed to get suggestions form the index");

                cpix_ClearError(util_->idxDb());

            }

        else

            {

                using namespace std;

                int32_t

                    hitCount = cpix_Hits_length(hits);

                if (cpix_Failed(hits))

                    {

                        ITK_EXPECT(testMgr,

                                   false,

                                   "Failed to get number of hits");

                        cpix_ClearError(hits);

                        return;

                    }

                cout << "Number of hits: " << hitCount << endl;

            }

        getTimestamp(&end);

        Suggestion::printSuggestions(hits,

                                     testMgr);

        cpix_Hits_destroy( hits );  

        long

            ms = getElapsedMs(&end,

                              &start);

        ITK_REPORT(testMgr,

                   "Suggesting 'h' in 200 SMS idx",

                   "%d ms",

                   ms);

    }

    void testDump(Itk::TestMgr  * testMgr,

                  const wchar_t * dumpQryStr)

    {

        using namespace Itk;

        cpix_Query

            * dumpQuery = cpix_QueryParser_parse(queryParser_,

                                                 dumpQryStr);

        ITK_EXPECT(testMgr,

                   cpix_Succeeded(queryParser_),

                   "Could not parse dump query string '%S'",

                   dumpQryStr);

        if (cpix_Failed(queryParser_))

            {

                return;

            }

        Timestamp

            start,

            end;

        getTimestamp(&start);

        cpix_Hits

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

                                       dumpQuery);

        getTimestamp(&end);

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

            {

                ITK_EXPECT(testMgr,

                           false,

                           "Failed to dump");

                cpix_ClearError(util_->idxDb());

            }

        else

            {

                util_->printHits(hits,

                                 testMgr);

            }

        long

            ms = getElapsedMs(&end,

                              &start);

        ITK_REPORT(testMgr,

                   "Dumping in 200 SMS idx",

                   "%d ms",

                   ms);

        cpix_Hits_destroy(hits);  

        cpix_Query_destroy(dumpQuery);

    }

    void testDump1(Itk::TestMgr * testMgr)

    {

        testDump(testMgr,

                  L"*");

    }

    void testDump2(Itk::TestMgr * testMgr)

    {

        testDump(testMgr,

                  L"$dump");

    }

    void testDump3(Itk::TestMgr * testMgr)

    {

        testDump(testMgr,

                  L"* AND _aggregate:happy");

    }

    void testDump4(Itk::TestMgr * testMgr)

    {

        testDump(testMgr,

                  L"$dump(_aggregate:happy)");

    }

    void testUpdate(Itk::TestMgr * testMgr)

    {

        using namespace Itk;

        Timestamp

            start,

            end;

        getTimestamp(&start);

        int32_t

            maxInsertBufSize = 32 * 1024;

        cpix_IdxDb_setMaxInsertBufSize(util_->idxDb(),

                                          maxInsertBufSize);

        ITK_EXPECT(testMgr,

                   cpix_Succeeded(util_->idxDb()),

                   "Failed to set max insert buffer size to %d",

                   maxInsertBufSize);

        util_->indexSms(23,

                        L"This UPDATED msg body does not have the h.appy word in it anymore",

                        analyzer_,

                        testMgr,

                        true); // update

        util_->indexSms(32,

                        L"This UPDATED msg body does have the happy word in it",

                        analyzer_,

                        testMgr,

                        true); // update

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

            {

                util_->indexSms(40 + i,

                                L"Just to update couple of times, to fill up the insert buffer in update state too. Garble, gobledegook.",

                                analyzer_,

                                testMgr,

                                true); // update

            }

        getTimestamp(&end);

        long

            ms = getElapsedMs(&end,

                              &start);

        ITK_REPORT(testMgr,

                   "Updating 2 docs in 200 SMS idx",

                   "%d ms",

                   ms);

        util_->flush();

    }

};

#define SUITE "partsms"

Itk::TesterBase * CreateSimpleIdxSequence()

{

    using namespace Itk;

#define SEQUENCE "simpleidx"

    SimpleIdxSeq

        * simpleIdxSeq = new SimpleIdxSeq;

    ContextTester

        * simpleIdxer = new ContextTester(SEQUENCE,

                                          simpleIdxSeq);

#define TEST "addSome"

    simpleIdxer->add(TEST,

                     simpleIdxSeq,

                     &SimpleIdxSeq::testAddSome,

                     TEST);

#undef TEST

#define TEST "search"

    simpleIdxer->add(TEST,

                     simpleIdxSeq,

                     &SimpleIdxSeq::testSearch,

                     TEST);

#undef TEST

#define TEST "suggest"

    simpleIdxer->add(TEST,

                     simpleIdxSeq,

                     &SimpleIdxSeq::testSuggest,

                     TEST);

#undef TEST

#define TEST "dump1"

    simpleIdxer->add(TEST,

                     simpleIdxSeq,

                     &SimpleIdxSeq::testDump1,

                     TEST);

#undef TEST

#define TEST "dump2"

    simpleIdxer->add(TEST,

                     simpleIdxSeq,

                     &SimpleIdxSeq::testDump2,

                     TEST);

#undef TEST

#define TEST "dump3"

    simpleIdxer->add(TEST,

                     simpleIdxSeq,

                     &SimpleIdxSeq::testDump3,

                     TEST);

#undef TEST

#define TEST "dump4"

    simpleIdxer->add(TEST,

                     simpleIdxSeq,

                     &SimpleIdxSeq::testDump4,

                     TEST);

#undef TEST

#define TEST "update"

    simpleIdxer->add(TEST,

                     simpleIdxSeq,

                     &SimpleIdxSeq::testUpdate,

                     TEST);

#undef TEST

#define TEST "search2"

    simpleIdxer->add(TEST,

                     simpleIdxSeq,

                     &SimpleIdxSeq::testSearch,       // Same test func with 

                     TEST);  // different name! :-)

#undef TEST

#define TEST "suggest2"

    simpleIdxer->add(TEST,

                     simpleIdxSeq,

                     &SimpleIdxSeq::testSuggest,

                     TEST);

#undef TEST

    return simpleIdxer;

#undef SEQUENCE

}