/*

* 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 "testutils.h"

#include "testcorpus.h"

#include "config.h"

#include "itk.h"

#include "setupsentry.h"

#include "std_log_result.h"

#include <iostream>

#include "cpixsearch.h"

namespace

{

    const MVFTest FilesAndVols[] = {

        {

            FILE_TEST_CORPUS_PATH "\\en\\1.txt",

            "@c:root file",

            CPIX_TEST_INDEVICE_INDEXDB_PHMEM CPIX_FILE_IDXDB "_\\c",

        },

        {

            FILE_TEST_CORPUS_PATH "\\en\\2.txt",

            "@d:root file",

            CPIX_TEST_INDEVICE_INDEXDB_PHMEM CPIX_FILE_IDXDB "_\\d",

        },

        {

            FILE_TEST_CORPUS_PATH "\\en\\3.txt",

            "@e:root file",

            CPIX_TEST_INDEVICE_INDEXDB_PHMEM CPIX_FILE_IDXDB "_\\e",

        },

        {

            FILE_TEST_CORPUS_PATH "\\en\\4.txt",

            "@f:root file",

            CPIX_TEST_INDEVICE_INDEXDB_PHMEM CPIX_FILE_IDXDB "_\\f",

        },

        {

            NULL,

            NULL,

            NULL

        },

    };

}

class PrematureQryContext : public Itk::ITestContext

{

private:

    cpix_IdxDb         * idxDb_;

    cpix_IdxSearcher   * idxSearcher_;

    cpix_Analyzer      * analyzer_;

    cpix_QueryParser   * queryParser_;

    cpix_Query         * query_;

public:

    //

    // from interface Itk::ITestContext

    //

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

    {

        SetupSentry

            ss(*this);

        cpix_Result

            result;

        cpix_IdxDb_dbgScrapAll(&result);

        if (cpix_Failed(&result))

            {

                ITK_PANIC("Could not dbg scrapp all indexes");

            }

        analyzer_ = cpix_CreateSimpleAnalyzer(&result);

        if (cpix_Failed(&result))

            {

                ITK_PANIC("Could not create analyzer instance");

            }

        queryParser_ = cpix_QueryParser_create(&result,

                                               LCPIX_DEFAULT_FIELD,

                                               analyzer_);

        if (cpix_Failed(&result))

            {

                ITK_PANIC("Could not create query parser");

            }

        query_ = cpix_QueryParser_parse(queryParser_,

                                        L"ha*");

        if (cpix_Failed(queryParser_))

            {

                ITK_PANIC("Could not create query");

            }

        for (const MVFTest * test = FilesAndVols;

             test->qualifiedBaseAppClass_ != NULL;

             ++test)

            {

                bool

                    isThere = Cpt::directoryexists(test->idxDbPath_);

                if (isThere)

                    {

                        int

                            result = Cpt::removeall(test->idxDbPath_);

                        if (result != 0)

                            {

                                ITK_PANIC("Could not purge index path %s",

                                          test->idxDbPath_);

                            }

                    }

            }

        ss.setupComplete();

    }    

    virtual void tearDown() throw()

    {

        cleanup();

    }

    //

    // lifetime mgmt

    //

    virtual ~PrematureQryContext()

    {

        cleanup();

    }

    PrematureQryContext()

        : idxDb_(NULL),

          idxSearcher_(NULL),

          analyzer_(NULL),

          queryParser_(NULL),

          query_(NULL)

    {

        ;

    }

    //

    // test functions

    //

    void testBeforeVolDefs(Itk::TestMgr * mgr)

    {

        char *xml_file = (char*)__FUNCTION__;

        assert_failed = 0;

        printf("Before volume definitions\n");

        qry(mgr,

            false);

        testResultXml(xml_file);

    }

    void testBeforeContentDefs(Itk::TestMgr * mgr)

    {

        printf("Defining volumes\n");

        char *xml_file = (char*)__FUNCTION__;

        assert_failed = 0;

        cpix_Result

            result;

        for (const MVFTest * test = FilesAndVols;

             test->qualifiedBaseAppClass_ != NULL;

             ++test)

            {

                cpix_IdxDb_defineVolume(&result,

                                        test->qualifiedBaseAppClass_,

                                        test->idxDbPath_);

                ITK_ASSERT(mgr,

                           cpix_Succeeded(&result),

                           "Failed to define volume %s/%s",

                           test->qualifiedBaseAppClass_,

                           test->idxDbPath_);

            }

        printf("Defined volumes, but there are no indexes created yet\n");

        qry(mgr,

            true);

        testResultXml(xml_file);

    }

    void testReady(Itk::TestMgr * mgr)

    {

        printf("Defining contents\n");

        char *xml_file = (char*)__FUNCTION__;

        assert_failed = 0;

        const MVFTest

            * mvfTest = FilesAndVols;

        for (; mvfTest->qualifiedBaseAppClass_ != NULL; ++mvfTest)

            {

                using namespace std;

                printf("Creating volume %s ...\n",

                       mvfTest->qualifiedBaseAppClass_);

                {

                    auto_ptr<VolumeFileIdxUtil>

                        vfiUtil(new VolumeFileIdxUtil(mvfTest));

                    vfiUtil->init();

                    vfiUtil->indexFile(mvfTest->textFilePath_,

                                       analyzer_,

                                       mgr);

                    vfiUtil->flush();

                }

                printf("... created volume %s\n",

                       mvfTest->qualifiedBaseAppClass_);

            }

        qry(mgr,

            true);

        testResultXml(xml_file);

    }

private:

    void cleanup()

    {

        cpix_IdxDb_releaseDb(idxDb_);

        idxDb_ = NULL;

        cpix_IdxSearcher_releaseDb(idxSearcher_);

        idxSearcher_ = NULL;

        cpix_Query_destroy(query_);

        query_ = NULL;

        cpix_QueryParser_destroy(queryParser_);

        queryParser_ = NULL;

        cpix_Analyzer_destroy(analyzer_);

        analyzer_ = NULL;

    }

    void qryIdx(Itk::TestMgr * mgr,

                bool           shouldSucceed)

    {

        printf("Trying to search with cpix_IdxDb instance\n");

        cpix_Result

            result;

        bool

            succeeded;

        if (idxDb_ == NULL)

            {

                idxDb_ = cpix_IdxDb_openDb(&result,

                                           "@c:root file",

                                           cpix_IDX_OPEN);

                succeeded = cpix_Succeeded(&result);

                if (!succeeded)

                    {

                        goto exit;

                    }

            }

        cpix_Hits

            * hits = cpix_IdxDb_search(idxDb_,

                                       query_);

        succeeded = cpix_Succeeded(idxDb_);

        if (!succeeded)

            {

                goto exit;

            }

        PrintHits(hits,

                  mgr);

        cpix_Hits_destroy(hits);

    exit:

        ITK_EXPECT(mgr,

                   (shouldSucceed && succeeded) 

                   || (!shouldSucceed && !succeeded),

                   "Querying idx should %s have succeeded and it did %s",

                   shouldSucceed ? "" : "not",

                   succeeded ? "" : "not");

        assert_failed = 1;

    }

    void qrySearcher(Itk::TestMgr * mgr,

                     bool           shouldSucceed)

    {

        printf("Trying to search with cpix_IdxSearcher instance\n");

        cpix_Result

            result;

        bool

            succeeded;

        if (idxSearcher_ == NULL)

            {

                idxSearcher_ = cpix_IdxSearcher_openDb(&result,

                                                       "root");

                succeeded = cpix_Succeeded(&result);

                if (!succeeded)

                    {

                        goto exit;

                    }

            }

        cpix_Hits

            * hits = cpix_IdxSearcher_search(idxSearcher_,

                                             query_);

        succeeded = cpix_Succeeded(idxSearcher_);

        if (!succeeded)

            {

                goto exit;

            }

        PrintHits(hits,

                  mgr);

        cpix_Hits_destroy(hits);

    exit:

        ITK_EXPECT(mgr,

                   (shouldSucceed && succeeded) 

                   || (!shouldSucceed && !succeeded),

                   "Querying searcher should %s have succeeded and it did %s",

                   shouldSucceed ? "" : "not",

                   succeeded ? "" : "not");

        assert_failed = 1;

    }

    void qry(Itk::TestMgr * mgr,

             bool           shouldSucceed)

    {

        qryIdx(mgr,

               shouldSucceed);

        qrySearcher(mgr,

                    shouldSucceed);

    }

};

Itk::TesterBase * CreatePrematureQryTests()

{

    using namespace Itk;

    PrematureQryContext

        * pqc = new PrematureQryContext();

    ContextTester

        * contextTester = new ContextTester("prematureqry",

                                            pqc);

#define TEST "beforeVolDefs"

    contextTester->add(TEST,

                       pqc,

                       &PrematureQryContext::testBeforeVolDefs,

                       TEST);

#undef TEST

#define TEST "beforeContentDefs"

    contextTester->add(TEST,

                       pqc,

                       &PrematureQryContext::testBeforeContentDefs,

                       TEST);

#undef TEST

#define TEST "ready"

    contextTester->add(TEST,

                       pqc,

                       &PrematureQryContext::testReady,

                       TEST);

#undef TEST

    return contextTester;

}