/*

* 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 <dirent.h>

#include <errno.h>

#include <wchar.h>

#include <stddef.h>

#include <iostream>

#include <sstream>

#include <fstream>

#include "cpixidxdb.h"

#include "itk.h"

#include "config.h"

#include "testutils.h"

#include "std_log_result.h"

std::wstring GetItemId(int itemIndex)

{

    using namespace std;

    wostringstream 

        id; 

    if (itemIndex == 0)

        {

            id << (wchar_t)'a';

        }

    else

        {

            // smallest first 

            while (itemIndex > 0) {

                id << (wchar_t)('a'+(itemIndex%10));

                itemIndex/=10; 

            }

        }

    return id.str(); 

}

int GetItemIndex(const wchar_t * itemId)

{

    int 

        ret = 0, 

        exp = 1;

    size_t

        length = wcslen(itemId);

    for (size_t i = 0; i < length; ++i) {

        if ( itemId[i] >= 'a' && itemId[i] < 'a'+10) {

            ret += (itemId[i]-'a') * exp; 

            exp*=10; 

        } else {

            // TODO: Panic

            return -1; 

        }

    }

    return ret; 

}

void PrintHit(cpix_Document * doc,

              Itk::TestMgr * testMgr)

{

    using namespace std;

    const wchar_t

        * value = cpix_Document_getFieldValue(doc,

                                              LCPIX_DOCUID_FIELD);

    // path-case: if it looks like path starting with a drive letter

    // and a colon-separator, then get rid of the drive letter to be

    // able to pass test cases both on the phone and the emulator

    wstring

        docUid(value);

    if (docUid.length() > 2

        && docUid[1] == L':')

        {

            docUid[0] = L'!';

        }

    ITK_EXPECT(testMgr, value != NULL, "DOCUID field not found");

    fprintf(stdout,

            "DOC (%S): ",

            docUid.c_str());

    value = cpix_Document_getFieldValue(doc,

                                        LCPIX_EXCERPT_FIELD);

    ITK_EXPECT(testMgr, value != NULL, "EXCERPT field not found");

    fprintf(stdout,

            "%S\n",

            value);

}

void PrintHits(cpix_Hits    * hits,

               Itk::TestMgr * testMgr)

{

    CustomPrintHits(hits,

                    testMgr,

                    &PrintHit);

}

void CustomPrintHits(cpix_Hits    * hits,

                     Itk::TestMgr * testMgr,

                     void        (* printHitFunc)(cpix_Document *, Itk::TestMgr *))

{

    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;

    cpix_Document

    for (int32_t i = 0; i < hitCount; ++i)

        {

            cpix_Hits_doc(hits,

                          i,

                {

                    ITK_EXPECT(testMgr,

                               false,

                               "Failed to get doc %d",

                               i);

                    cpix_ClearError(hits);

                    break;

                }

            // OBS PrintHit(&doc,

                         testMgr);

        }

}

IdxUtil::IdxUtil()

    : idxDb_(NULL),

      schemaId_(0)

{

    ;

}

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

{

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

        }

    if (idxDb_ == NULL)

        {

            wchar_t

                report[256];

            cpix_Error_report(result.err_,

                              report,

                              sizeof(report) / sizeof(wchar_t));

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

                      idxDbPath(),

                      qualBaseAppClass(),

                      report);

            assert_failed = 1;

        }

    schemaId_ = addSchema();

}

void IdxUtil::reload() throw (Itk::PanicExc)

{

    cpix_Result

        result;

    cpix_IdxDb_releaseDb(idxDb_);

    idxDb_ = NULL; 

    schemaId_ = NULL; 

    idxDb_ = cpix_IdxDb_openDb(&result,

                               qualBaseAppClass(),

                               cpix_IDX_OPEN);

    if (idxDb_ == NULL)

        {

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

                      idxDbPath(),

                      qualBaseAppClass());

        }

    schemaId_ = addSchema(); 

}

void IdxUtil::recreate() throw (Itk::PanicExc)

{

    cpix_Result

        result;

    cpix_IdxDb_releaseDb(idxDb_);

    idxDb_ = NULL; 

    schemaId_ = NULL; 

    cpix_IdxDb_defineVolume(&result,

                            qualBaseAppClass(),

                            idxDbPath());

    if (cpix_Succeeded(&result))

        {

            idxDb_ = cpix_IdxDb_openDb(&result,

                                       qualBaseAppClass(),

                                       cpix_IDX_CREATE);

        }

    if (idxDb_ == NULL)

        {

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

                      idxDbPath(),

                      qualBaseAppClass());

        }

    schemaId_ = addSchema(); 	

}

void IdxUtil::flush() throw (Itk::PanicExc) 

{

	cpix_IdxDb_flush( idxDb_ );

    if ( cpix_Failed( idxDb_ ) )

    {

        assert_failed = 1;

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

				  idxDbPath(),

				  qualBaseAppClass());

    }

}

void IdxUtil::close() throw() 

{

	if ( idxDb_ ) 

	{

		cpix_IdxDb_releaseDb(idxDb_);

		idxDb_ = 0; 

	}

}

IdxUtil::~IdxUtil() throw()

{

	close(); 

}

void IdxUtil::printHits(cpix_Hits    * hits,

                        Itk::TestMgr * testMgr,

                        bool           allowFailure)

{

    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;

    cpix_Document

    for (int32_t i = 0; i < hitCount; ++i)

        {

            cpix_Hits_doc(hits,

                          i,

                {

                    if (allowFailure)

                        {

                            printf("Failed to get doc %d - updated index?\n",

                                   i);

                        }

                    else

                        {

                            ITK_EXPECT(testMgr,

                                       false,

                                       "Failed to get doc %d",

                                       i);

                        }

                    cpix_ClearError(hits);

                    break;

                }

                        testMgr);

        }

}

cpix_IdxDb * IdxUtil::idxDb()

{

    return idxDb_;

}

SchemaId IdxUtil::schemaId()

{

    return schemaId_;

}

void IdxUtil::printHit(cpix_Document * doc,

                       Itk::TestMgr   * testMgr)

{

    using namespace std;

    std::wstring

        idStr(getIdStr(doc,

                       testMgr));

    fprintf(stdout, 

    		"DOC (%S): ",

    		idStr.c_str());

    const wchar_t 

        * value = cpix_Document_getFieldValue(doc,

												LCPIX_EXCERPT_FIELD);

    ITK_EXPECT(testMgr, value != NULL, "EXCERPT field not found");

    fprintf(stdout, 

    		"%S\n",

    		value);

}

/****

 * SmsIdxUtil

 */

SmsIdxUtil::SmsIdxUtil(const char * qbac)

    : qbac_(qbac)

{

    ;

}

SmsIdxUtil::~SmsIdxUtil() throw ()

{

    ;

}

const char * SmsIdxUtil::qualBaseAppClass() const

{

    return qbac_.c_str();

}

const char * SmsIdxUtil::idxDbPath() const

{

    return NULL;

}

cpix_FieldDesc SmsSchema[] = {

    // NOTE: in an actual SMS schema, you would probably not want to

    // store fields "to", "from" and "folder".

    {

        LTO_FIELD,                                     // name_

        cpix_STORE_YES | cpix_INDEX_UNTOKENIZED,      // cfg_

    },

    {

        LFROM_FIELD,                                   // name_

        cpix_STORE_YES | cpix_INDEX_UNTOKENIZED,      // cfg_

    },

    {

        LFOLDER_FIELD,                                 // name_

        cpix_STORE_YES | cpix_INDEX_UNTOKENIZED,      // cfg_

    },

    {

        LBODY_FIELD,                                   // name_

        cpix_STORE_NO | cpix_INDEX_TOKENIZED,         // cfg_

    },

};

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

{

    SchemaId

        rv = cpix_IdxDb_addSchema(idxDb(),

                                  SmsSchema,

                                  sizeof(SmsSchema)/sizeof(cpix_FieldDesc));

    if (cpix_Failed(idxDb()))

        {

            cpix_ClearError(idxDb());

            ITK_PANIC("Failed to add SMS schema");

        }

    return rv;

}

void SmsIdxUtil::deleteSms(size_t         id,

                           Itk::TestMgr * testMgr)

{

    std::wstring

        docUid = GetItemId(id);

    int32_t

        result = cpix_IdxDb_deleteDocuments(idxDb(),

                                            docUid.c_str());

    ITK_EXPECT(testMgr,

               cpix_Succeeded(idxDb()),

               "Failed to delete by %S",

               docUid.c_str());

    if (cpix_Succeeded(idxDb()))

        {

            ITK_MSG(testMgr,

                    "Deleted %d items by %S",

                    result,

                    docUid.c_str());

        }

    else

        {

            assert_failed = 1;

        }

}

void SmsIdxUtil::indexSms(size_t          id,

                          const wchar_t * body,

                          cpix_Analyzer * analyzer,

                          Itk::TestMgr   * testMgr,

                          bool            update)

{

    using namespace std;

    wstring 

        docUid = GetItemId(id); 

    /* TEMP

       currently we are going to use the full SMS body as excerpt

       for testing purposes, but otherwise this piece of code could

       do excerpt generation.

    wchar_t

        excerpt[128];