/*
* 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 <set>
#include <sstream>

#include "cpixtools.h"

#include "itk.h"

#include "cpixidxdb.h"
#include "cpixsearch.h"

#include "config.h"
#include "testutils.h"
#include "setupsentry.h"

#include "std_log_result.h"

#define VATTUNIEMENRANTA_2_GPS L"60.154023,24.887724"



struct GpsLocation
{
    char                    gpsLatitudeRef_;
    Cpt::ExifGpsCoord       gpsLatitude_;
    char                    gpsLongitudeRef_;
    Cpt::ExifGpsCoord       gpsLongitude_;
};


const GpsLocation GPSLOC_DATA[] = {
    {
        Cpt::QNr::NORTH, 
        Cpt::ExifGpsCoord(Cpt::ExifRational(60,1),
                          Cpt::ExifRational(9,1),
                          Cpt::ExifRational(3529,100)),
        Cpt::QNr::EAST,
        Cpt::ExifGpsCoord(Cpt::ExifRational(24,1),
                          Cpt::ExifRational(53,1),
                          Cpt::ExifRational(2508,100)),
    },

    
};


class JpgFileIdxUtil : public FileIdxUtil
{
public:
    virtual ~JpgFileIdxUtil() throw ()
    {
        ;
    }

protected:
    virtual void printHit(cpix_Document * doc,
                          Itk::TestMgr   * testMgr)
    {
        cpix_DocFieldEnum
            * dfe = cpix_Document_fields(doc);
        if (cpix_Succeeded(doc))
            {
                cpix_Field
                    field;

                printf("DOCUMENT:\n");

                while (cpix_DocFieldEnum_hasMore(dfe))
                    {
                        cpix_DocFieldEnum_next(dfe,
                                               &field);
                        const wchar_t
                            * name = cpix_Field_name(&field);

                        ITK_EXPECT(testMgr,
                                   cpix_Succeeded(&field),
                                   "Getting field name failed");

                        printf(" o %S: ",
                               name);

                        bool
                            binary = 
                            static_cast<bool>(cpix_Field_isBinary(&field));

                        /* OBS
                        printf("%S\n",
                               (binary ? 
                                L"(binary)" 
                                : cpix_Field_stringValue(&field)
                                )
                               );
                        */
                        if (binary)
                            {
                                printf("(binary)\n");
                            }
                        else
                            {
                                const wchar_t
                                    * val = cpix_Field_stringValue(&field);
                                
                                ITK_EXPECT(testMgr,
                                           cpix_Succeeded(&field),
                                           "Getting field value failed");

                                bool
                                    docuid = wcscmp(LCPIX_DOCUID_FIELD,
                                                    name) == 0;

                                if (docuid)
                                    {
                                        // docuid is the path that may
                                        // differ in its drive letter
                                        // in emulator and in target
                                        printf("!%S\n",
                                               (wcslen(val) > 0 ? val+1 : val));
                                    }
                                else
                                    {
                                        printf("%S\n",
                                               val);
                                    }
                            }
                    }

                cpix_DocFieldEnum_destroy(dfe);
            }
        else
            {
                ITK_EXPECT(testMgr,
                           false,
                           "Could not get doc enum field");
            }
    }
};




class GeoContext : public Itk::ITestContext, public Cpt::IFileVisitor
{
protected:
    //
    // protected members
    //
    JpgFileIdxUtil       * util_;
    cpix_Analyzer        * analyzer_;
    cpix_QueryParser     * queryParser_;
    cpix_Query           * query_;


    Itk::TestMgr   * testMgr_;

public:

    //
    // From ITestContext
    //
    virtual void setup() throw (Itk::PanicExc)
    {
        SetupSentry
            ss(*this);

        cpix_Result
            result;

        cpix_IdxDb_dbgScrapAll(&result);

        if (cpix_Failed(&result))
            {
                ITK_PANIC("Could not scrap all");
            }

        util_ = new JpgFileIdxUtil;
        util_->init();
        
        analyzer_ = cpix_CreateSimpleAnalyzer(&result);
        if (analyzer_ == NULL)
            {
                ITK_PANIC("Could not create analyzer");
            }
        
        queryParser_ = cpix_QueryParser_create(&result,
                                               QNR_FIELD,
                                               analyzer_);
        if (queryParser_ == NULL)
            {
                ITK_PANIC("Could not create query parser");
            }

        ss.setupComplete();
    }


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


    virtual ~GeoContext()
    {
        cleanup();
    }


    //
    // from Cpt::IFileVisitor
    //
    virtual bool visitFile(const char * path)
    {
        bool
            goOn = true;

        const char
            * extensionChar = path + strlen(path) - 1;
        while (extensionChar >= path && *extensionChar != '.')
            {
                --extensionChar;
            }

        if (strcmp(".jpg", extensionChar) == 0)
            {
                util_->indexFile(path,
                                 analyzer_,
                                 testMgr_);
            }

        return goOn;
    }
    
    
    virtual DirVisitResult visitDirPre(const char * /*path*/)
    {
        return IFV_CONTINUE;
    }


    virtual bool visitDirPost(const char * /*path*/)
    {
        return true;
    }


    //
    // public operations
    //
    GeoContext()
        : util_(NULL),
          analyzer_(NULL),
          queryParser_(NULL),
          query_(NULL),
          testMgr_(NULL)
    {
        ;
    }


    //
    // test methods
    // 

    void testHarvestJpg(Itk::TestMgr * testMgr)
    {
        char *xml_file = (char *)__FUNCTION__;
        assert_failed = 0;
        testMgr_ = testMgr;
        Cpt::traverse(JPG_TEST_CORPUS_PATH,
                      this);
        util_->flush();
        testResultXml(xml_file);
    }


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

        cpix_Hits
            * hits = search(GPSLOC_DATA,
                            sizeof(GPSLOC_DATA) / sizeof(GpsLocation),
                            NULL,
                            4.0, 
                            10);

        cpix_Hits_destroy(hits);
        testResultXml(xml_file);
    }

private:
    void cleanup()
    {
        delete util_;
        util_ = NULL;

        cpix_Analyzer_destroy(analyzer_);
        analyzer_ = NULL;

        cpix_QueryParser_destroy(queryParser_);
        queryParser_ = NULL;

        cpix_Query_destroy(query_);
        query_ = NULL;
    }



    /**
     * This function is the sample code for any client performing
     * location based search on anything that has QNR_FIELD defined.
     *
     * TODO RANKING of hits based on actual distance is not
     * implemented yet
     *
     * @param gpsLocs gps locations around which to search - MUST NOT
     * be NULL
     *
     * @param gpsLocsCount the number of gps locations given by
     * gpsLocs
     *
     * @param additionalTerm any additional term to include in the
     * query ("AND" query operation), if necessary, may be NULL
     *
     * @param radiusKm the radius, in kilometers, within which all
     * hits should be found (no false negatives are allowed). NOTE
     * that we may get false positives (hits that are beyond the
     * radius)
     *
     * @param maxHits the number of hits requested (within the given
     * radius), if possible
     */
    cpix_Hits * search(const GpsLocation   gpsLocs[],
                       size_t              gpsLocsCount,
                       const wchar_t     * additionalTerm,
                       double              radiusKm,
                       size_t              maxHits)
    {
		wchar_t qryStr[512];
		
		int loc = 
			swprintf( qryStr,
					  sizeof(qryStr),
					  L"$quad<");
		
		loc += 
			Cpt::wsnprintdouble( qryStr + loc,
								 sizeof(qryStr)-loc,
								 radiusKm, 
								 4 );  

		
		loc += 
			swprintf( qryStr+loc,
					  sizeof(qryStr)-loc,
					  L",%d,%S",
					  maxHits, 
					  VATTUNIEMENRANTA_2_GPS); 
    
        for (size_t i = 0; i < gpsLocsCount; ++i)
            {
                double
                    latitude,
                    longitude;

                Cpt::QNr::convertGps(gpsLocs[i].gpsLatitudeRef_,
                                     gpsLocs[i].gpsLatitude_,
                                     gpsLocs[i].gpsLongitudeRef_,
                                     gpsLocs[i].gpsLongitude_,
                                     &latitude,
                                     &longitude);
// FIXME: Get rid of Cpt::wsnprintdouble, when printf("%lf", ....) starts to work
                qryStr[loc++]= ',';
                loc +=
					Cpt::wsnprintdouble( qryStr + loc,
										 sizeof(qryStr)-loc,
										 latitude, 
										 10 );  

                qryStr[loc++]= ',';
                loc +=
					Cpt::wsnprintdouble( qryStr + loc,
										 sizeof(qryStr)-loc,
										 longitude, 
										 10 );  

/* FIXME: This DOES NOT work. 
                loc += 
					swprintf( qryStr + loc, 
							  sizeof(qryStr)-loc,
							  L",%lf,%lf", 
							  latitude,
							  longitude );
			    */ 
            }

        loc += 
			swprintf(qryStr + loc, sizeof(qryStr)-loc, L">");

        if (additionalTerm != NULL)
            {
				loc += 
					swprintf(qryStr + loc, 
							 sizeof(qryStr)-loc,
							 L"(%S)", 
							 additionalTerm);
            }
        
        cpix_Query_destroy(query_);
        query_ = NULL;

        query_ = cpix_QueryParser_parse(queryParser_,
                                        qryStr);
        ITK_ASSERT(testMgr_,
                   cpix_Succeeded(queryParser_),
                   "Failed to parse: %S\n",
                   qryStr);
        if(!cpix_Succeeded(queryParser_))
            {
                assert_failed = 1;
            }
        
        cpix_Hits
            * hits = cpix_IdxDb_search(util_->idxDb(),
                                       query_);
        ITK_ASSERT(testMgr_,
                   cpix_Succeeded(util_->idxDb()),
                   "Failed to search (geo)");
        if(!cpix_Succeeded(util_->idxDb()))
            {
                assert_failed = 1;
            }
        
        int32_t
            hitCount = cpix_Hits_length(hits);
        
        if (hitCount > 0)
            {
                util_->printHits(hits,
                                 testMgr_);
            }
        else
            {
                printf("  Nothing is found\n");
            }

        return hits;
    }


};




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

    GeoContext
        * geoContext = new GeoContext;
    ContextTester
        * contextTester = new ContextTester("geo",
                                            geoContext);

#define TEST "harvestJpg"
    contextTester->add(TEST,
                       geoContext,
                       &GeoContext::testHarvestJpg,
                       TEST);
#undef TEST

    // TODO perhaps a dump-all test case too?

#define TEST "searchJpg"
    contextTester->add(TEST,
                       geoContext,
                       &GeoContext::testSearchJpg,
                       TEST);
#undef TEST

    // TODO add more tests to suite
        
    return contextTester;
}
