/*

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

#include "idxutil.h"

#include "cpixtools.h"

std::wstring id2Wstr(int id)

{

    wchar_t

        buffer[32];

    snwprintf(buffer,

              sizeof(buffer)/sizeof(wchar_t),

              L"%d",

              id);

    return std::wstring(buffer);

}

int wstr2Id(const wchar_t * str)

{

    wchar_t

        * end = const_cast<wchar_t*>(str) + wcslen(str);

    return wcstol(str,

                  &end,

                  10);

}

IdxUtil::IdxUtil()

    : idxDb_(NULL),

      idxSearcher_(NULL),

      queryParser_(NULL),

      analyzer_(NULL),

      schemaId_(0),

      idx_(0)

{

    ;

}

void IdxUtil::init(bool create) throw (Itk::PanicExc)

{

    idx_ = 0;

    cpix_Result

        result;

    if (create)

        {

            cpix_IdxDb_defineVolume(&result,

                                    qualBaseAppClass(),

                                    idxDbPath());

            if (cpix_Succeeded(&result))

                {

                    idxDb_ = cpix_IdxDb_openDb(&result,

                                               qualBaseAppClass(),

                                               cpix_IDX_CREATE);

                }

        }

    else

        {

            idxDb_ = cpix_IdxDb_openDb(&result,

                                       qualBaseAppClass(),

                                       cpix_IDX_OPEN);

        }

    idxSearcher_ = cpix_IdxSearcher_openDb(&result,

                                           qualBaseAppClass());

    if (idxDb_ == NULL || idxSearcher_ == NULL)

        {

            wchar_t

                report[256];

            cpix_Error_report(result.err_,

                              report,

                              sizeof(report) / sizeof(wchar_t));

            ITK_PANIC("Could not create/open idx db/searcher '%s' for '%s': %S",

                      idxDbPath(),

                      qualBaseAppClass(),

                      report);

        }

    schemaId_ = addSchema();

    if (cpix_Failed(idxDb()))

        {

            cpix_IdxDb_releaseDb(idxDb_);

            ITK_PANIC("Could not add schema");

        }

    analyzer_ = cpix_CreateSimpleAnalyzer(&result);

    if (cpix_Failed(&result))

        {

            cpix_IdxDb_releaseDb(idxDb_);

            ITK_PANIC("Could not create simple analyzer");

        }

    queryParser_ = cpix_QueryParser_create(&result,

                                           LCPIX_DEFAULT_FIELD,

                                           analyzer_);

    if (cpix_Failed(&result))

        {

            cpix_IdxDb_releaseDb(idxDb_);

            cpix_Analyzer_destroy(analyzer_);

            ITK_PANIC("Could not create query parser");

        }

}

IdxUtil::~IdxUtil() throw ()

{

    cpix_IdxDb_releaseDb(idxDb_);

    idxDb_ = NULL;

    cpix_IdxSearcher_releaseDb(idxSearcher_);

    idxSearcher_ = NULL;

    cpix_QueryParser_destroy(queryParser_);

    queryParser_ = NULL;

    cpix_Analyzer_destroy(analyzer_);

    analyzer_ = NULL;

}

cpix_IdxDb * IdxUtil::idxDb()

{

    return idxDb_;

}

cpix_IdxSearcher * IdxUtil::idxSearcher()

{

    return idxSearcher_;

}

cpix_QueryParser * IdxUtil::queryParser()

{

    return queryParser_;

}

cpix_Analyzer * IdxUtil::analyzer()

{

    return analyzer_;

}

SchemaId IdxUtil::schemaId()

{

    return schemaId_;

}

void IdxUtil::indexItem(const char   * line,

                        Itk::TestMgr * testMgr)

{

    Cpt::auto_array<wchar_t>

        wline(new wchar_t[strlen(line) + 1]);

    mbstowcs(wline.get(),

             line,

             strlen(line) + 1);

    const wchar_t * fields[] =  { 

        wline.get(),

    };

    cpix_IdxDb_add2(idxDb(),

                    schemaId(),

                    id2Wstr(idx_).c_str(),   // doc uid

                    TEXTAPPCLASS,            // appclass

                    wline.get(),             // excerpt

                    NULL,                    // app id

                    fields,                  // fields

                    analyzer_);

    if (cpix_Failed(idxDb()))

        {

            ITK_ASSERT(testMgr,

                       false,

                       "Failed to index item %d",

                       idx_);

        }

    ++idx_;

}

void IdxUtil::updateItem(const char   * line,

                         Itk::TestMgr * testMgr)

{

    Cpt::auto_array<wchar_t>

        wline(new wchar_t[strlen(line) + 1]);

    mbstowcs(wline.get(),

             line,

             strlen(line) + 1);

    const wchar_t * fields[] =  { 

        wline.get(),

    };

    cpix_IdxDb_update2(idxDb(),

                       schemaId(),

                       id2Wstr(idx_).c_str(),   // doc uid

                       TEXTAPPCLASS,            // appclass

                       wline.get(),             // excerpt

                       NULL,                    // app id

                       fields,                  // fields

                       analyzer_);

    if (cpix_Failed(idxDb()))

        {

            ITK_ASSERT(testMgr,

                       false,

                       "Failed to update item %d",

                       idx_);

        }

    ++idx_;

}

void IdxUtil::flush() 

{

	cpix_IdxDb_flush( idxDb_ );

    if ( cpix_Failed( idxDb_ ) )

    {

		ITK_PANIC("Could not flush idx db '%s' for '%s'",

				  idxDbPath(),

				  qualBaseAppClass());

    }

}

int  IdxUtil::curIdx() const

{

    return idx_;

}

void IdxUtil::setCurIdx(int idx)

{

    idx_ = idx;

}

const char * IdxUtil::qualBaseAppClass() const

{

    return FILE_QBASEAPPCLASS;

}

const char * IdxUtil::idxDbPath() const

{

    // OBS return FILE_CLUCENE_DB;

    return NULL;

}

cpix_FieldDesc FileSchema[] = {

    {

        CONTENTS_FIELD,                             // name_

        cpix_STORE_NO | cpix_INDEX_TOKENIZED,       // cfg_

    }

};

SchemaId IdxUtil::addSchema() throw (Itk::PanicExc)

{

    return cpix_IdxDb_addSchema(idxDb(),

                                FileSchema,

                                sizeof(FileSchema)/sizeof(cpix_FieldDesc));

}

/***************************************************

 * PoiIdxUtil

 */

cpix_FieldDesc PoiSchema[] = {

    {

        L"gpslong",

        cpix_STORE_NO | cpix_INDEX_UNTOKENIZED,

    },

    {

        L"gpslat",

        cpix_STORE_NO | cpix_INDEX_UNTOKENIZED,

    },

    {

        L"whatnot",

        cpix_STORE_NO | cpix_INDEX_UNTOKENIZED,

    },

    {

        L"id-und",

        cpix_STORE_NO | cpix_INDEX_UNTOKENIZED,

    },

    {

        L"field01",

        cpix_STORE_NO | cpix_INDEX_TOKENIZED,

    },

    {

        L"field02",

        cpix_STORE_NO | cpix_INDEX_TOKENIZED,

    },

    {

        L"field03",

        cpix_STORE_NO | cpix_INDEX_TOKENIZED,

    },

    {

        L"field04",

        cpix_STORE_NO | cpix_INDEX_TOKENIZED,

    },

    {

        L"field05",

        cpix_STORE_NO | cpix_INDEX_TOKENIZED,

    },

    {

        L"field06",

        cpix_STORE_NO | cpix_INDEX_TOKENIZED,

    },

    {

        L"field07",

        cpix_STORE_NO | cpix_INDEX_TOKENIZED,

    },

    {

        L"field08",

        cpix_STORE_NO | cpix_INDEX_TOKENIZED,

    },

    {

        L"field09",

        cpix_STORE_NO | cpix_INDEX_TOKENIZED,

    },

    {

        L"field10",

        cpix_STORE_NO | cpix_INDEX_TOKENIZED,

    },

    {

        L"field11",

        cpix_STORE_NO | cpix_INDEX_TOKENIZED,

    },

    {

        L"field12",

        cpix_STORE_NO | cpix_INDEX_TOKENIZED,

    },

};

#define POI_FIELD_NUM sizeof(PoiSchema) / sizeof(cpix_FieldDesc)

#define POI_APPCLASS "root maps poi"

#define POI_QBASEAPPCLASS "@0:root maps poi"

void PoiIdxUtil::indexItem(const char   * poiLine,

                           Itk::TestMgr * testMgr)

{

    const wchar_t * fields[POI_FIELD_NUM];

    for (const wchar_t ** p = fields;

         p - fields < POI_FIELD_NUM;

         ++p)

        {

            *p = NULL;

        }

    std::list<std::wstring>

        wFields;

    getFields(poiLine,

              wFields);

    std::list<std::wstring>::const_iterator

        i = wFields.begin(),

        end = wFields.end();

    const wchar_t

        ** p = fields;

    std::wstring

        excerpt;

    for (; i != end && p - fields < POI_FIELD_NUM; ++i, ++p)

        {

            *p = i->c_str();

            if (p - fields >= 4 && i->length() > 0)

                {

                    excerpt += i->c_str();

                    excerpt += L' ';

                }

        }

    cpix_IdxDb_add2(idxDb(),

                    schemaId(),

                    id2Wstr(idx_).c_str(),

                    POI_APPCLASS,

                    excerpt.c_str(),

                    NULL,

                    fields,

                    analyzer_);

    if (cpix_Failed(idxDb()))

        {

            ITK_ASSERT(testMgr,

                       false,

                       "Failed to index item %d",

                       idx_);

        }

    ++idx_;

}

void PoiIdxUtil::updateItem(const char   * poiLine,

                            Itk::TestMgr * testMgr)

{

    const wchar_t * fields[POI_FIELD_NUM];

    for (const wchar_t ** p = fields;

         p - fields < POI_FIELD_NUM;

         ++p)

        {

            *p = NULL;

        }

    std::list<std::wstring>

        wFields;

    getFields(poiLine,

              wFields);

    std::list<std::wstring>::const_iterator

        i = wFields.begin(),

        end = wFields.end();

    const wchar_t

        ** p = fields;

    std::wstring

        excerpt;

    for (; i != end && p - fields < POI_FIELD_NUM; ++i, ++p)

        {

            *p = i->c_str();

            if (p - fields >= 4 && i->length() > 0)

                {

                    excerpt += i->c_str();

                    excerpt += L' ';

                }

        }

    cpix_IdxDb_update2(idxDb(),

                       schemaId(),

                       id2Wstr(idx_).c_str(),

                       POI_APPCLASS,

                       excerpt.c_str(),

                       NULL,

                       fields,

                       analyzer_);

    if (cpix_Failed(idxDb()))

        {

            ITK_ASSERT(testMgr,

                       false,

                       "Failed to update item %d",

                       idx_);

        }

    ++idx_;

}

const char * PoiIdxUtil::qualBaseAppClass() const

{

    return POI_QBASEAPPCLASS;

}

const char * PoiIdxUtil::idxDbPath() const

{

#ifdef __WINS__ 

    return CPIX_TEST_INDEVICE_INDEXDB_PHMEM "\\root\\maps\\poi";

#else

    return CPIX_TEST_INDEVICE_INDEXDB_MMC "\\root\\maps\\poi";

#endif

}

SchemaId PoiIdxUtil::addSchema() throw (Itk::PanicExc)

{