/*

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

#include "cpixtools.h"

#include "itk.h"

#include "cpixidxdb.h"

#include "cpixsearch.h"

#include "config.h"

#include "testutils.h"

#include "setupsentry.h"

#include "std_log_result.h"

const Volume Volumes[] = {

    { "@fin:root maps city",

      MAPS_TEST_CORPUS_PATH "\\root\\maps\\city\\fin"

    },

    { "@0:root maps country",

      MAPS_TEST_CORPUS_PATH "\\root\\maps\\country"

    },

    { "@fin:root maps street",

      MAPS_TEST_CORPUS_PATH "\\root\\maps\\street\\fin"

    },

    { NULL,

      NULL

    },

};

#define VATTUNIEMENRANTA_2_GPS L"60.154023,24.887724"

const wchar_t * MapsSearchTerms[] = {

    // country: FIN

    L"soome",

    L"finsko",

    L"suomi",

    // country: HUN

    L"unkari",

    L"hungary",

    // cities

    L"espoo",

    L"kirkkonummi",

    L"lammi",

    L"lahti",

    L"oulu",

    L"tampere",

    // streets

    L"lehdontie",

    L"sentinoja",

    L"karvosentie",

    L"kivitie",

    L"ludvig filipintie",

    // specific ordered results

    L"Revontulentie", // 1st result "Revontulentie,  Kuusamo, Distance 677.39km", 

    // 2nd result "Revontulentie, Salla, Distance 756.83km", (more results follow)

    L"Revontulentie Salla", // 1st result "Revontulentie, Salla, Distance 756.83km"

    NULL

};

class MapsContext : public Itk::ITestContext

{

private:

    //

    // private members

    //

    cpix_Analyzer    * analyzer_;

    cpix_QueryParser * queryParser_;

    cpix_IdxSearcher * idxSearcher_;

public:

    //

    // from ITestContext

    //

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

    {

        cpix_Result

            result;

        SetupSentry

            ss(*this);

        analyzer_ = cpix_CreateSimpleAnalyzer(&result);

        if (analyzer_ == NULL)

            {

                ITK_PANIC("Could not create analyzer");

            }

        queryParser_ = cpix_QueryParser_create(&result,

                                               LCPIX_DEFAULT_FIELD,

                                               analyzer_);

        if (queryParser_ == NULL)

            {

                ITK_PANIC("Could not create query parser");

            }

        ss.setupComplete();

    }

    virtual void tearDown() throw()

    {

        cleanup();

    }

    MapsContext()

        : analyzer_(NULL),

          queryParser_(NULL),

          idxSearcher_(NULL)

    {

        ;

    }

    ~MapsContext()

    {

        cleanup();

    }

    static void printHit(cpix_Document  * doc,

                         Itk::TestMgr   * testMgr)

    {

        using namespace std;

        fprintf(stdout,

                "NEXT ADDRESS:\n");

        cpix_DocFieldEnum

            * dfe = cpix_Document_fields(doc);

        if (cpix_Succeeded(doc))

            {

                cpix_Field

                    field;

                while (cpix_DocFieldEnum_hasMore(dfe))

                    {

                        cpix_DocFieldEnum_next(dfe,

                                               &field);

                        const wchar_t

                            * name = cpix_Field_name(&field);

                        fprintf(stdout,

                                " o %S: ",

                                name);

                        bool

                            binary = static_cast<bool>(cpix_Field_isBinary(&field));

                        fprintf(stdout,

                                "%S\n",

                                (binary ? 

                                 L"(binary)" 

                                 : cpix_Field_stringValue(&field)

                                 )

                                );

                    }

                cpix_DocFieldEnum_destroy(dfe);

            }

        else

            {

                wchar_t

                    report[128];

                cpix_Error_report(doc->err_,

                                  report,

                                  sizeof(report)/sizeof(wchar_t));

                ITK_EXPECT(testMgr,

                           false,

                           "Could not create doc field enum: %S",

                           report);

                cpix_ClearError(doc);

            }

    }

    void testLoadMaps(Itk::TestMgr * testMgr)

    {

        char *xml_file = (char *)__FUNCTION__;

        assert_failed = 0;

        cpix_Result

            result;

        cpix_IdxDb_dbgScrapAll(&result);

        ITK_ASSERT(testMgr,

                   cpix_Succeeded(&result),

                   "Could not reset qbac-path registry");

        if(!cpix_Succeeded(&result))

            {

        assert_failed = 1;    

            }

        const Volume

            *p = Volumes;

        for (; p->qbac_ != NULL; ++p)

            {

                cpix_IdxDb_defineVolume(&result,

                                        p->qbac_,

                                        p->path_);

                ITK_ASSERT(testMgr,

                           cpix_Succeeded(&result),

                           "Could not define volume '%s'",

                           p->qbac_);

                if(!cpix_Succeeded(&result))

                    {

                    assert_failed = 1;    

                    }

            }

        idxSearcher_ = cpix_IdxSearcher_openDb(&result,

                                               "root maps");

        ITK_ASSERT(testMgr,

                   cpix_Succeeded(&result),

                   "Could not create searcher for 'root maps'");

        if(!cpix_Succeeded(&result))

            {

            assert_failed = 1;    

            }

        testResultXml(xml_file);

    }

    void testSearchMaps(Itk::TestMgr * testMgr)

    {

        printf("Testing searching maps index\n");

        char *xml_file = (char *)__FUNCTION__;

        assert_failed = 0;

        const wchar_t

            ** p = MapsSearchTerms;

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

            {

                printf("\n\nSearching for '%S':\n",

                       *p);

                std::wstring

                    addressQryStr(L"$address<" VATTUNIEMENRANTA_2_GPS L">(");

                addressQryStr += *p;

                addressQryStr += L")";

                cpix_Query

                    * query = cpix_QueryParser_parse(queryParser_,

                                                     addressQryStr.c_str());

                ITK_EXPECT(testMgr,

                           cpix_Succeeded(queryParser_),

                           "Could not query parse %S",

                           *p);

                if (cpix_Failed(queryParser_))

                    {

                        continue;

                    }

                cpix_Hits

                    * hits = cpix_IdxSearcher_search(idxSearcher_,

                                                     query);

                if (cpix_Succeeded(idxSearcher_))

                    {

                        CustomPrintHits(hits,

                                        testMgr,

                                        &printHit);

                        cpix_Hits_destroy(hits);

                    }

                else

                    {

                        ITK_EXPECT(testMgr,

                                   false,

                                   "Failed to do address search");

                        assert_failed = 1;

                    }

                cpix_Query_destroy(query);

            }

        testResultXml(xml_file);

    }

private:

    void cleanup()

    {

        cpix_Analyzer_destroy(analyzer_);

        analyzer_ = NULL;

        cpix_QueryParser_destroy(queryParser_);

        queryParser_ = NULL;

        cpix_IdxSearcher_releaseDb(idxSearcher_);

        idxSearcher_ = NULL;

    }

};

Itk::TesterBase * CreateMapsTests()

{

    using namespace Itk;

    MapsContext

        * mapsContext = new MapsContext;

    ContextTester

        * contextTester = new ContextTester("maps",

                                            mapsContext);

#define TEST "loadMaps"

    contextTester->add(TEST,

                       mapsContext,

                       &MapsContext::testLoadMaps);

#undef TEST

#define TEST "searchMaps"

    contextTester->add(TEST,

                       mapsContext,

                       &MapsContext::testSearchMaps,

                       TEST);

#undef TEST 

    // TODO add more tests to suite

    return contextTester;

}