/*

* 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: 

*

*/

#ifndef EVALUATIONTOOL_H_

#define EVALUATIONTOOL_H_

#include <vector>

#include <memory>

#include <string>

#include <bitset>

#include "cpixmemtools.h"

namespace lucene {

	namespace analysis {

		class Analyzer;

	}

	namespace store {

		class FSDirectory;

	}

	namespace search {

		class IndexSearcher;

	}

	namespace queryParser {

		class QueryParser;

	}

	namespace util {

		class Reader;

	}

}

namespace evaluationtool 

{

	/**

	 * Loads and provides access to a corpus in foreign language

	 */

	class Corpus 

	{

		public:

			Corpus(const char* file);

			const wchar_t* operator[](int i);

			int size(); 

		private: 

			std::vector<std::wstring> lines_; 

	};

#define MAXLINES 1024

	/**

	 * Contains the corpus in indexed form so that it can be searched

	 */

	class PreparedCorpus 

	{

	public:

		PreparedCorpus( Corpus& corpus, 

				        lucene::analysis::Analyzer& analyzer, 

				        lucene::analysis::Analyzer* queryAnalyzer = NULL,

				        lucene::analysis::Analyzer* prefixAnalyzer = NULL );

		int size();

		int indexSize();

		void search(const wchar_t* query, std::bitset<MAXLINES>& hits ); 

	public: 

		int size_;

		std::auto_ptr<lucene::store::FSDirectory> dir_;

		std::auto_ptr<lucene::queryParser::QueryParser> queryParser_;

		std::auto_ptr<lucene::search::IndexSearcher> searcher_;

		lucene::analysis::Analyzer* prefixAnalyzer_; 

	};

	class Results 

		{

		public: 

			Results();

			Results(std::bitset<MAXLINES>& hits, int lines);

			Results(PreparedCorpus& corpus, 

					const wchar_t* query);

			bool hit(int i);

			void append(bool hit);

			int length(); 

		private:

			std::bitset<MAXLINES> hits_;

			int lines_; 

		};

	/**

	 * An entry containing the ideal and measured results for a query.

	 */

	class EvaluationRecordEntry {

	public:

		EvaluationRecordEntry(const wchar_t* query, 

							  Results& ideal, 

							  Results& measured);

		EvaluationRecordEntry(lucene::util::Reader& reader);

		EvaluationRecordEntry();

		std::wstring query_; 

		Results ideal_; 

		Results measured_; 

	};

	/** 

	 * Contains ideal results and measured results for all queries. 

	 */

	class EvaluationRecord  {

		public: 

			EvaluationRecord(const char* file);

			int length();

			const wchar_t* query(int i); 

			Results& ideal(int i); 

			Results& measured(int i); 

		private:

			std::vector<EvaluationRecordEntry> entries_; 

	};

	/**

	 * Provides information of how the measured search compared

	 * to the ideal one. 

	 */

	class Evaluation

	{

		public:

			Evaluation(Results& ideal, Results& measured);

			bool falsePositive(int line);

			bool falseNegative(int line);

			bool error(int line);

			int errors();

			int falsePositives(); 

			int falseNegatives(); 

		private: 

			Results& ideal_; 

			Results& measured_; 

	};

}

#endif /* EVALUATIONTOOL_H_ */