/*

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

#include <pthread.h>

#include <algorithm>

#include <iostream>

#include <string>

#include "cpixtools.h"

#include "itk.h"

#include "cpix_async.h"

#include "config.h"

#include "suggestion.h"

#include "testutils.h"

#include "testcorpus.h"

#include "setupsentry.h"

// TODO PROPER, EXAMPLARY error clearing (cpix_ClearError())

bool AddField(cpix_Document * doc,

              const wchar_t * name,

              const wchar_t * value,

              int             flags)

{

    bool

        rv = false;

    cpix_Field

        field;

    cpix_Field_initialize(&field,

                          name,

                          value,

                          flags);

    if (cpix_Succeeded(&field))

        {

            cpix_Document_add(doc,

                              &field);

            if (cpix_Succeeded(doc))

                {

                    rv = true;

                }

            else

                {

                    cpix_Field_release(&field);

                }

        }

    return rv;

}

cpix_Document * CreateSmsDoc(Itk::TestMgr  * testMgr,

                             size_t          docUid,

                             const wchar_t * body,

                             Cpt::Mutex    & cpixMutex)

{

    using namespace std;

    wstring 

        docUidStr = GetItemId(docUid); 

    cpix_Result

        result;

    Cpt::SyncRegion

        sr(cpixMutex);

    cpix_Document

        * doc = cpix_Document_create(&result,

                                     docUidStr.c_str(),

                                     SMSAPPCLASS,

                                     body,

                                     NULL);

    ITK_ASSERT(testMgr,

               cpix_Succeeded(&result),

               "Failed to create document for SMS");

    bool

        success = AddField(doc,

                           LTO_FIELD,

                          L"+3585554444",

                          cpix_STORE_YES | cpix_INDEX_UNTOKENIZED);

    if (success)

        {

            success = AddField(doc,

                               LBODY_FIELD,

                               body,

                               cpix_STORE_NO | cpix_INDEX_TOKENIZED);

        }

    if (!success)

        {

            cpix_Document_destroy(doc);

            ITK_ASSERT(testMgr,

                       false,

                       "Could not add field(s) to SMS doc");

        }

    return doc;

}

// TODO these SyncedAdd operations must evolve to lock on Itk::TestMgr

// * instance (or have a synced Itk::TestMgr derivant class)

/**

 * Reports the CPIX error if the last operation on cpix_Obj

 * failed. Also clears the error status on cpix_Obj (necessary for

 * error info lifetime mgmt).

 *

 * @return if the last operation cpix_Obj was successful, that is,

 * it's return valus is equivalent to calling

 * cpix_Succeeded(cpix_Obj). (But note, that this call clears the

 * error status, thus a cpix_Succeeded(cpix_Obj) call after a call to

 * this function will alsways return true).

 */

template <typename CPIX_OBJ>

bool ReportIfFailed(Itk::TestMgr * testMgr,

                    CPIX_OBJ     * cpix_Obj,

                    Cpt::Mutex   & cpixMutex)

{

    bool

        succeeded = true;

    if (cpix_Failed(cpix_Obj))

        {

            succeeded = false;

            wchar_t

                buffer[256];

            Cpt::SyncRegion

                sr(cpixMutex);

            cpix_Error_report(cpix_Obj->err_,

                              buffer,

                              sizeof(buffer) / sizeof(wchar_t));

            ITK_MSG(testMgr,

                    "CPIX failure: %S",

                    buffer);

            cpix_ClearError(cpix_Obj);

        }

    return succeeded;

}

/**

 * Adds an SMS item to an index using the async API, but it is used as

 * a sync API here.

 */

class SyncedAdd

{

    Cpt::SyncQueue<cpix_JobId>   q_;

    Cpt::Mutex                 & cpixMutex_;

public:

    SyncedAdd(Cpt::Mutex & cpixMutex)

        : q_(1),

          cpixMutex_(cpixMutex)

    {

        ;

    }

    void call(cpix_IdxDb    * idxDb,

              cpix_Document * doc,

              cpix_Analyzer * analyzer,

              Itk::TestMgr  * testMgr)

    {

        cpix_JobId

            jobId;

        {

            Cpt::SyncRegion

                sr(cpixMutex_);

            jobId = cpix_IdxDb_asyncAdd(idxDb,

                                        doc,

                                        analyzer,

                                        this,

                                        &callback);

        }

        ITK_ASSERT(testMgr,

                   ReportIfFailed(testMgr,

                                  idxDb,

                                  cpixMutex_),

                   "Making async call failed");

        cpix_JobId

            jobId2;

        bool 

            couldGet = q_.get(&jobId2);

        ITK_ASSERT(testMgr,

                   jobId == jobId2,

                   "Messed up callback!");

        if (couldGet)

            {

                {

                    Cpt::SyncRegion

                        sr(cpixMutex_);

                    cpix_IdxDb_asyncAddResults(idxDb,

                                               jobId);

                }

                ITK_EXPECT(testMgr,

                           ReportIfFailed(testMgr,

                                          idxDb,

                                          cpixMutex_),

                           "Synced addition failed");

                if (cpix_Succeeded(idxDb))

                    {

                        ITK_MSG(testMgr,

                                "Indexed");

                    }

            }

        else

            {

                ITK_ASSERT(testMgr,

                           false,

                           "Could not get result from async call");

            }

    }

private:

    static void callback(void       * cookie,

                         cpix_JobId   jobId)

    {

        SyncedAdd

            * this_ = reinterpret_cast<SyncedAdd*>(cookie);

        this_->q_.put(jobId);

    }

};

/**

 * Deletes an SMS item from an index using the async API, but it is used as

 * a sync API here.

 */

class SyncedDel

{

    Cpt::SyncQueue<cpix_JobId>   q_;

    Cpt::Mutex                 & cpixMutex_;

public:

    SyncedDel(Cpt::Mutex & cpixMutex)

        : q_(1),

          cpixMutex_(cpixMutex)

    {

        ;

    }

    void call(cpix_IdxDb    * idxDb,

              const wchar_t * docUid,

              Itk::TestMgr  * testMgr)

    {

        cpix_JobId

            jobId;

        {

            Cpt::SyncRegion

                sr(cpixMutex_);

            jobId = cpix_IdxDb_asyncDeleteDocuments(idxDb,

                                                    docUid,

                                                    this,

                                                    &callback);

        }

        ITK_ASSERT(testMgr,

                   ReportIfFailed(testMgr,

                                  idxDb,

                                  cpixMutex_),

                   "could not make async call");

        cpix_JobId

            jobId2;

        bool

            couldGet = q_.get(&jobId2);

        ITK_ASSERT(testMgr,

                   jobId == jobId2,

                   "Messed up callback");

        if (couldGet)

            {

                int32_t

                    rv;

                {

                    Cpt::SyncRegion

                        sr(cpixMutex_);

                    rv = cpix_IdxDb_asyncDeleteDocumentsResults(idxDb,

                                                                jobId);

                }

                ITK_EXPECT(testMgr,

                           ReportIfFailed(testMgr,

                                          idxDb,

                                          cpixMutex_),

                           "Synced delete failed");

                if (cpix_Succeeded(idxDb))

                    {

                        ITK_MSG(testMgr,

                                "Deleted %d",

                                rv);

                    }

            }

        else

            {

                ITK_ASSERT(testMgr,

                           false,

                           "Could not get result from async call");

            }

    }

private:

    static void callback(void       * cookie,

                         cpix_JobId   jobId)

    {

        SyncedDel

            * this_ = reinterpret_cast<SyncedDel*>(cookie);

        this_->q_.put(jobId);

    }

};

/**

 * Updates an SMS item to an index using the async API, but it is used as

 * a sync API here.

 */

class SyncedUpdate

{

    Cpt::SyncQueue<cpix_JobId>   q_;

    Cpt::Mutex                 & cpixMutex_;

public:

    SyncedUpdate(Cpt::Mutex & cpixMutex)

        : q_(1),

          cpixMutex_(cpixMutex)

    {

        ;

    }

    void call(cpix_IdxDb    * idxDb,

              cpix_Document * doc,

              cpix_Analyzer * analyzer,

              Itk::TestMgr  * testMgr)

    {

        cpix_JobId

            jobId;

        {

            Cpt::SyncRegion

                sr(cpixMutex_);

            jobId = cpix_IdxDb_asyncUpdate(idxDb,

                                           doc,

                                           analyzer,

                                           this,

                                           &callback);

        }

        ITK_ASSERT(testMgr,

                   ReportIfFailed(testMgr,

                                  idxDb,

                                  cpixMutex_),

                   "Could not make async call");

        cpix_JobId

            jobId2;

        bool

            couldGet = q_.get(&jobId2);

        ITK_ASSERT(testMgr,

                   jobId == jobId2,

                   "Messed up callback");

        if (couldGet)

            {

                {

                    Cpt::SyncRegion

                        sr(cpixMutex_);

                    cpix_IdxDb_asyncUpdateResults(idxDb,

                                                  jobId);

                }

                ITK_EXPECT(testMgr,

                           ReportIfFailed(testMgr,

                                          idxDb,

                                          cpixMutex_),

                           "Synced update failed");

                if (cpix_Succeeded(idxDb))

                    {

                        ITK_MSG(testMgr,

                                "Updated");

                    }

            }

        else

            {

                ITK_ASSERT(testMgr,

                           false,

                           "Could not get result from async call");

            }

    }

private:

    static void callback(void       * cookie,

                         cpix_JobId   jobId)

    {

        SyncedUpdate

            * this_ = reinterpret_cast<SyncedUpdate*>(cookie);

        this_->q_.put(jobId);

    }

};

class SyncedHousekeep

{

    Cpt::SyncQueue<cpix_JobId>   q_;

    Cpt::Mutex                 & cpixMutex_;

public:

    SyncedHousekeep(Cpt::Mutex & cpixMutex)

        : q_(1),

          cpixMutex_(cpixMutex)

    {

        ;

    }

    void call(Itk::TestMgr   * testMgr)

    {

        cpix_JobId

            jobId;

        cpix_Result

            result;

        {

            Cpt::SyncRegion

                sr(cpixMutex_);

            jobId = cpix_asyncDoHousekeeping(&result,

                                             this,

                                             &callback);

        }

        ITK_ASSERT(testMgr,

                   ReportIfFailed(testMgr,

                                  &result,

                                  cpixMutex_),

                   "Performing async housekeeping failed");

        cpix_JobId

            jobId2;

        bool

            couldGet = q_.get(&jobId2);

        ITK_ASSERT(testMgr,

                   jobId == jobId2,

                   "Messed up callback!");

        if (couldGet)

            {

                {

                    Cpt::SyncRegion