/*

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

#include "itk.h"

#include "config.h"

#include "testutils.h"

#include "setupsentry.h"

struct TestPathAndContent

{

    const char    * utf8Dir_;

    const char    * utf8File_;

    const char    * utf8Content_;

};

const struct TestPathAndContent TestPathAndContents[] = 

    {

        { "english 1\\",

          "great ideas.txt",

          "Some great ideas never catch on. London. Foobar."

        },

        { "russian 2\\",

          "Русский язык.txt",

          "Подарок обошелся в $12 тысяч Голливудский актер Брэд Питт попал в аварию в Лос-Анджелесе. Moscow. Foobar."

        },

        { "chinese 3\\",

          "中文.txt",

          "解放军今年演习强度密度\"罕见\" 开放透明度空前 高清 Beijing. Foobar."

        },

        { "japanese 4\\",

          "日本語.txt",

          "10月25日（日曜日）、バグダッドにおいて連続爆発テロが発生し、 Tokyo. Foobar."

        },

        { "finnish 5\\",

          "äÄöÖ.txt",

          "Syksyllä satoi vettä. Helsinki. Foobar."

        },

        { NULL,

          NULL,

          NULL

        },

    };

class Utf8PathContext : public Itk::ITestContext, public Cpt::IFileVisitor

{

private:

    FileIdxUtil             * util_;

    cpix_Analyzer           * analyzer_;

    cpix_Query              * query_;

    cpix_QueryParser        * queryParser_;

    Itk::TestMgr            * testMgr_;

    static const char         BaseDir_[];

public:

    //

    // From ITestContext

    //

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

    {

        SetupSentry

            ss(*this);

        cpix_Result

            result;

        cpix_IdxDb_dbgScrapAll(&result);

        using namespace std;

        util_ = new FileIdxUtil;

        util_->init();

        analyzer_ = cpix_CreateSimpleAnalyzer(&result);

        if (analyzer_ == NULL)

            {

                ITK_PANIC("Could not create analyzer");

            }

        queryParser_ = cpix_QueryParser_create(&result,

                                               CONTENTS_FIELD,

                                               analyzer_);

        if (queryParser_ == NULL)

            {

                ITK_PANIC("Could not create query parser");

            }

        query_ = cpix_QueryParser_parse(queryParser_,

                                        L"foobar");

        if (cpix_Failed(queryParser_)

            || query_ == NULL)

            {

                ITK_PANIC("Could not parse query string");

            }

        ss.setupComplete();

    }

    virtual void tearDown() throw ()

    {

        cleanup();

    }

    Utf8PathContext()

        : util_(NULL),

          analyzer_(NULL),

          query_(NULL),

          queryParser_(NULL),

          testMgr_(NULL)

    {

        ;

    }

    ~Utf8PathContext()

    {

        cleanup();

    }

    //

    // from Cpt::IFileVisitor

    //

    virtual bool visitFile(const char * path)

    {

        bool

            goOn = true;

        util_->indexFile(path,

                         analyzer_,

                         testMgr_);

        return goOn;

    }

    virtual DirVisitResult visitDirPre(const char * /*path*/)

    {

        return IFV_CONTINUE;

    }

    virtual bool visitDirPost(const char * /*path*/)

    {

        return true;

    }

    /**

     * We have to generate text files manually, because even if

     * Symbian itself supports unicode, its build tools like bldmake

     * etc do not, so we can't even export test files etc. DAMN

     * SYMBIAN!

     */

    void testCreateUtf8PathFiles(Itk::TestMgr * mgr)

    {

        printf("Creating files with utf8 paths and content\n");

        using namespace std;

        for (const struct TestPathAndContent * tpac = TestPathAndContents;

             tpac->utf8Dir_ != NULL;

             ++tpac)

            {

                string

                    utf8Path(BaseDir_);

                utf8Path += tpac->utf8Dir_;

                int

                    result = Cpt::mkdirs(utf8Path.c_str(), 0666);

                ITK_ASSERT(mgr,

                           result == 0,

                           "Could not create base dir %s",

                           utf8Path.c_str());

                utf8Path += tpac->utf8File_;

                ofstream

                    ofs(utf8Path.c_str());

                ofs << tpac->utf8Content_;

                ofs.flush();

                printf("Created file at : %s\n",

                       utf8Path.c_str());

            }

    }

    void testHarvesting(Itk::TestMgr * mgr)

    {

        printf("Harvesting files with utf8 paths and content\n");

        testMgr_ = mgr;

        Cpt::traverse(BaseDir_,

                      this);

        util_->flush();

    }

    void testSearching(Itk::TestMgr * mgr)

    {

        printf("Searching files with utf8 paths and content\n");

        using namespace Itk;

        cpix_Hits

            * hits = cpix_IdxDb_search(util_->idxDb(),

                                       query_);

        if (cpix_Failed(util_->idxDb()))

            {

                ITK_EXPECT(mgr,

                           false,

                           "Failed to search index");

                cpix_ClearError(util_->idxDb());

            }

        else

            {

                util_->printHits(hits,

                                 mgr);

                cpix_Hits_destroy(hits);

            }

    }

private:

    //

    // private methods

    //

    void cleanup()

    {

        delete util_;

        util_ = NULL;

        cpix_Analyzer_destroy(analyzer_);

        analyzer_ = NULL;

        cpix_Query_destroy(query_);

        query_ = NULL;

        cpix_QueryParser_destroy(queryParser_);

        queryParser_ = NULL;

    }

};

const char Utf8PathContext::BaseDir_[] = "c:\\Data\\cpixunittest\\_txt\\";

Itk::TesterBase * CreateUtf8PathTests()

{

    using namespace Itk;

    Utf8PathContext

        * ctxt = new Utf8PathContext;

    ContextTester

        * utf8Path = new ContextTester("utf8path",

                                       ctxt);

#define TEST "createUtf8PathFiles"

    utf8Path->add(TEST,

                  ctxt,

                  &Utf8PathContext::testCreateUtf8PathFiles,

                  TEST);

#undef TEST

#define TEST "harvest"

    utf8Path->add(TEST,

                  ctxt,

                  &Utf8PathContext::testHarvesting,

                  TEST);

#undef TEST

#define TEST "search"

    utf8Path->add(TEST,

                  ctxt,

                  &Utf8PathContext::testSearching,

                  TEST);

#undef TEST

    // TODO add more

    return utf8Path;

}