/*
* 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 <memory>
#include <iostream>
#include <list>
#include <map>
#include <vector>

#include "cpixfstools.h"

#include "itk.h"

#include "cpixidxdb.h"
#include "cpixsearch.h"
#include "idxdbmgr.h" // from private folder: whitebox testing

#include "config.h"
#include "suggestion.h"
#include "testutils.h"
#include "testcorpus.h"
#include "setupsentry.h"
#include "std_log_result.h"

//
// these constants are set so that a cpix_XXX entity should be
// eligible for internal (transparent) release between the 2nd and 3rd
// period (sleep)
//
const unsigned int SleepSec   = 2;
const char         LastAccessedPattern[] = "(last accessed: ";


class HeartbeatContext : public Itk::ITestContext
{
    cpix_Analyzer            * analyzer_;
    cpix_QueryParser         * queryParser_;
    cpix_Query               * query_;

    LineTestCorpusRef          corpus_;
    SmsIdxUtil               * smsIdxUtil_;
    FileIdxUtil              * fileIdxUtil_;
    cpix_IdxSearcher         * searcher_;

    cpix_LogLevel              oldLogLevel_;


public:
    virtual void setup() throw (Itk::PanicExc)
    {
        SetupSentry
            ss(*this);

        cpix_Result
            result;

        oldLogLevel_ = cpix_setLogLevel(CPIX_LL_TRACE);

        cpix_IdxDb_dbgScrapAll(&result);

        if (cpix_Failed(&result))
            {
                ITK_PANIC("Could not dbg scrapp all indexes");
            }

        analyzer_ = cpix_CreateSimpleAnalyzer(&result);

        if (analyzer_ == NULL)
            {
                ITK_PANIC("Could not create analyzer");
            }

        queryParser_ = cpix_QueryParser_create(&result,
                                               LBODY_FIELD,
                                               analyzer_);
        if (queryParser_ == NULL)
            {
                ITK_PANIC("Could not create query parser");
            }

        query_ = cpix_QueryParser_parse(queryParser_,
                                        L"happy");
        if (cpix_Failed(queryParser_)
            || query_ == NULL)
            {
                ITK_PANIC("Could not parse query string");
            }

        ss.setupComplete();
    }

    virtual void tearDown() throw()
    {
        cleanup();
    }


    virtual ~HeartbeatContext()
    {
        cleanup();
    }


    //
    // public operations
    //
    HeartbeatContext()
        : analyzer_(NULL),
          queryParser_(NULL),
          query_(NULL),
          corpus_(DEFAULT_TEST_CORPUS_PATH),
          smsIdxUtil_(NULL),
          fileIdxUtil_(NULL),
          searcher_(NULL)
          
    {
        ;
    }


    //
    // public (test) operations
    //
    void testCreateFileIdxDb(Itk::TestMgr * testMgr)
    {
        using namespace std;
        char *xml_file = (char *)__FUNCTION__;
        assert_failed = 0;
        doCommonJobs(testMgr,
                     false);

        auto_ptr<FileIdxUtil>
            fiu(new FileIdxUtil);
        fiu->init(true);

        fileIdxUtil_ = fiu.release();
        testResultXml(xml_file);        
    }


    void testCreateSmsIdxDb(Itk::TestMgr * testMgr)
    {
        using namespace std;
        char *xml_file = (char *)__FUNCTION__;
        assert_failed = 0;

        doCommonJobs(testMgr);

        auto_ptr<SmsIdxUtil>
            siu(new SmsIdxUtil);
        siu->init(true);
        
        smsIdxUtil_ = siu.release();
        testResultXml(xml_file);  
    }
    

    void testAddSomeSms(Itk::TestMgr * testMgr)
    {
        char *xml_file = (char *)__FUNCTION__;
        assert_failed = 0;
        using namespace std;

        doCommonJobs(testMgr);

        for (size_t i = 0; i < 5; ++i)
            {
                std::wstring
                    body = corpus_.item(i);
                smsIdxUtil_->indexSms(i,
                                      body.c_str(),
                                      analyzer_,
                                      testMgr);
                if ((i % 5) == 0)
                    {
                        ITK_DBGMSG(testMgr,
                                   ".");
                    }
            }
        testResultXml(xml_file);  
    }


    void testIdle(Itk::TestMgr * testMgr)
    {
        doCommonJobs(testMgr);
    }


    void testUseMultiSearcher(Itk::TestMgr * testMgr)
    {
        char *xml_file = (char *)__FUNCTION__;
        assert_failed = 0;
        doCommonJobs(testMgr);

        if (searcher_ == NULL)
            {
                cpix_Result
                    result;

                searcher_ = cpix_IdxSearcher_openDb(&result,
                                                    "root");
                                     
                if (searcher_ == NULL)
                    {
                        ITK_ASSERT(testMgr,
                                   false,
                                   "Could not create multi searcher");
                    }
            }

        cpix_Hits
            * hits = cpix_IdxSearcher_search(searcher_,
                                             query_);
        ITK_EXPECT(testMgr,
                   cpix_Succeeded(query_),
                   "Could not search with multisearcher");
        if( !cpix_Succeeded(query_))
            {
                assert_failed = 1;
            }
        if (hits != NULL)
            {
                PrintHits(hits,
                          testMgr);

                cpix_Hits_destroy(hits);
            }
        testResultXml(xml_file);  
    }

    
    void testAddSomeFile(Itk::TestMgr * testMgr)
    {
        char *xml_file = (char *)__FUNCTION__;
        assert_failed = 0;
        doCommonJobs(testMgr);

        fileIdxUtil_->indexFile(FILE_TEST_CORPUS_PATH "\\en\\1.txt",
                                analyzer_,
                                testMgr);
        testResultXml(xml_file); 
    }

    
    void testReleaseAll(Itk::TestMgr * testMgr)
    {
        char *xml_file = (char *)__FUNCTION__;
        assert_failed = 0;
        doCommonJobs(testMgr);

        delete fileIdxUtil_;
        fileIdxUtil_ = NULL;

        delete smsIdxUtil_;
        smsIdxUtil_ = NULL;

        cpix_IdxSearcher_releaseDb(searcher_);
        searcher_ = NULL;
        testResultXml(xml_file);
    }
    

private:
    //
    // private methods
    //
    void cleanup()
    {
        delete smsIdxUtil_;
        smsIdxUtil_ = NULL;

        delete fileIdxUtil_;
        fileIdxUtil_ = NULL;

        cpix_IdxSearcher_releaseDb(searcher_);
        searcher_ = NULL;

        cpix_Analyzer_destroy(analyzer_);
        analyzer_ = NULL;

        cpix_Query_destroy(query_);
        query_ = NULL;

        cpix_QueryParser_destroy(queryParser_);
        queryParser_ = NULL;
        

        cpix_setLogLevel(oldLogLevel_);
    }
    

    void doCommonJobs(Itk::TestMgr * testMgr,
                      bool           doSleep = true)
    {
        if (doSleep)
            {
                printf("Sleeping %d seconds...\n",
                       SleepSec);
                ITK_EXPECT(testMgr,
                           sleep(SleepSec) == 0,
                           "Could not sleep");
                printf("... slept.\n");
            }

        cpix_doHousekeeping();

        printf("Housekept.\n");

        // TODO
        // measure memory consumption (not tested by I/O)

        cpix_dbgDumpState();
    }

};


Itk::TesterBase * CreateHeartbeatTests()
{
    using namespace Itk;

    HeartbeatContext
        * heartbeatContext = new HeartbeatContext();
    ContextTester
        * contextTester = new ContextTester("heartbeat",
                                            heartbeatContext);
#define TEST "00_createFileIdxDb"
    contextTester->add(TEST,
                       heartbeatContext,
                       &HeartbeatContext::testCreateFileIdxDb,
                       TEST,
                       LastAccessedPattern);
#undef TEST

#define TEST "01_createSmsIdxDb"
    contextTester->add(TEST,
                       heartbeatContext,
                       &HeartbeatContext::testCreateSmsIdxDb,
                       TEST,
                       LastAccessedPattern);
#undef TEST

#define TEST "02_addSomeSms"
    contextTester->add(TEST,
                       heartbeatContext,
                       &HeartbeatContext::testAddSomeSms,
                       TEST,
                       LastAccessedPattern);
#undef TEST

#define TEST "03_idle"
    contextTester->add(TEST,
                       heartbeatContext,
                       &HeartbeatContext::testIdle,
                       TEST,
                       LastAccessedPattern);
#undef TEST

#define TEST "04_idle"
    contextTester->add(TEST,
                       heartbeatContext,
                       &HeartbeatContext::testIdle,
                       TEST,
                       LastAccessedPattern);
#undef TEST

#define TEST "05_idle"
    contextTester->add(TEST,
                       heartbeatContext,
                       &HeartbeatContext::testIdle,
                       TEST,
                       LastAccessedPattern);
#undef TEST

#define TEST "06_useMultiSearcher"
    contextTester->add(TEST,
                       heartbeatContext,
                       &HeartbeatContext::testUseMultiSearcher,
                       TEST,
                       LastAccessedPattern);
#undef TEST

#define TEST "07_addSomeFile"
    contextTester->add(TEST,
                       heartbeatContext,
                       &HeartbeatContext::testAddSomeFile,
                       TEST,
                       LastAccessedPattern);
#undef TEST

#define TEST "08_idle"
    contextTester->add(TEST,
                       heartbeatContext,
                       &HeartbeatContext::testIdle,
                       TEST,
                       LastAccessedPattern);
#undef TEST

#define TEST "09_idle"
    contextTester->add(TEST,
                       heartbeatContext,
                       &HeartbeatContext::testIdle,
                       TEST,
                       LastAccessedPattern);
#undef TEST

#define TEST "10_idle"
    contextTester->add(TEST,
                       heartbeatContext,
                       &HeartbeatContext::testIdle,
                       TEST,
                       LastAccessedPattern);
#undef TEST

#define TEST "11_useMultiSearcher"
    contextTester->add(TEST,
                       heartbeatContext,
                       &HeartbeatContext::testUseMultiSearcher,
                       TEST,
                       LastAccessedPattern);
#undef TEST

#define TEST "12_releaseAll"
    contextTester->add(TEST,
                       heartbeatContext,
                       &HeartbeatContext::testReleaseAll,
                       TEST,
                       LastAccessedPattern);
#undef TEST


#define TEST "13_idle"
    contextTester->add(TEST,
                       heartbeatContext,
                       &HeartbeatContext::testIdle,
                       TEST,
                       LastAccessedPattern);
#undef TEST

    // ... add more

    return contextTester;
}
