/*
 * ASCLITE
 * Author: Jerome Ajot, Jon Fiscus, Nicolas Radde, Chris Laprun
 *
 * This software was developed at the National Institute of Standards and Technology by 
 * employees of the Federal Government in the course of their official duties. Pursuant
 * to title 17 Section 105 of the United States Code this software is not subject to
 * copyright protection and is in the public domain. ASCLITE is an experimental system.
 * NIST assumes no responsibility whatsoever for its use by other parties, and makes no
 * guarantees, expressed or implied, about its quality, reliability, or any other
 * characteristic. We would appreciate acknowledgement if the software is used.
 *
 * THIS SOFTWARE IS PROVIDED "AS IS."  With regard to this software, NIST MAKES NO EXPRESS
 * OR IMPLIED WARRANTY AS TO ANY MATTER WHATSOEVER, INCLUDING MERCHANTABILITY,
 * OR FITNESS FOR A PARTICULAR PURPOSE.
 */
 
#ifndef TOKEN_H
#define TOKEN_H

#include "timedobject.h"
#include "properties.h"
#include "stdarg.h"
#include "logger.h"

class Segment;

/**
 * Internal representation of a token.
 * A token represent every informations needed on a word to align it.
 */
class Token : public TimedObject
{
	public:
		static const int NOT_FRAGMENT = 0;
		static const int BEGIN_FRAGMENT = 1;
		static const int END_FRAGMENT = 2;
		
		// class destructor
		~Token();
		
		void SetSourceText(const string& x); // sets the value of text
		/** Retrieves the raw text for this Token. */
		string GetSourceText() { return sourceText; }
		
		string GetText(); // returns the cleaned-up version of the text, used for alignment purposes.
		string GetTextInLowerCase(); // Return the text in lower case FIX-ME: REMOVE?
		void SetConfidence(const float& x); // sets the value of confidence
		float GetConfidence() { return confidence; } // returns the value of confidence
        Token* GetNextToken(const size_t& i) { return next[i]; } //retrieve the next token indexed
		void AddNextToken(Token* token) { next.push_back(token); } //add a "next" token indexed
		Token* GetPrecToken(const size_t& i) { return prec[i]; } //retrieve the next token indexed
		void AddPrecToken(Token* token) { prec.push_back(token); } //add a "prec" token indexed     
		
		static Token* CreateWithDuration(const int& _startTime, const int& _duration, Segment* parent);
		static Token* CreateWithDuration(const int& _startTime, const int& _duration, Segment* parent, const string& _text);
		static Token* CreateWithEndTime(const int& _startTime, const int& _endTime, Segment* parent);
		static Token* CreateWithEndTime(const int& _startTime, const int& _endTime, Segment* parent, const string& _text);
		static Token* CreateWithEndTime(const int& _startTime, const int& _endTime, Segment* parent, const string& _text, Token* first_prec_tokens, ...);
		
		void LinkTokens(Token *nextToken);    // Links the two tokens together
		
		/** Breaks the link between tokens **/
		void UnlinkTokens(Token *nextToken);

		/** Breaks the next token link between tokens **/
		void UnlinkNextToken(Token *nextToken);
		void UnlinkPrevToken(Token *prevToken);
		
		/**
		 * Return the number of next Tokens.
		 */
		size_t GetNbOfNextTokens() { return next.size(); }
		/**
		 * Return the number of prec Tokens.
		 */
		size_t GetNbOfPrecTokens() { return prec.size(); }
		/**
		 * Return true if the two token are equivalent in a 
		 * Speech recognition way.
		 */
		bool IsEquivalentTo(Token* token);
		/**
		 * Return if the Token is Optionnaly Deletable/Insertable.
		 */
		bool IsOptional();
		/**
         * Return true IF the confidence value was set
         */
		bool IsConfidenceSet() { return hasConfidence; }
        /**
         * Returns if the token is a Fragment:
		 * - Token::NOT_FRAGMENT if the token is not a fragment.
		 * - Token::BEGIN_FRAGMENT if the token is a beginning fragment => frag-
		 * - Token::END_FRAGMENT if the token is an ending fragment => -ment
         */
        int GetFragmentStatus();
   
		/**
		 * Return if two tokens are equals
		 */
		bool Equals(Token* token);
		
		int EditDistance(Token* token);
		
		/** Returns a string representation of this Token. */
		string ToString();
		
		/** Retrieves the Segment in which this Token is located */
		Segment* GetParentSegment() { return segment; }
		
		/** Output the string information for csv */
		string GetCSVInformation();
		
		void BecomeOptionallyDeletable() { SetSourceText(Token::BEGIN_OPTIONAL_MARKER + GetSourceText() + Token::END_OPTIONAL_MARKER); }
		
	protected:
		// class constructor
		Token();
		
	private:
		/**
		 * Raw text associated with this Token. We distinguish between source text as
		 * found in input source files, which might contain metadata, and cleaned-up
		 * text, which is the actual text of the Token (excluding metadata).
		 */
		string sourceText;
		/** Index position in sourceText of the cleaned-up text. */
		short start;
		/** Size (in characters) of the cleaned-up text. */
		short size;
		
		/** Updates cleaned-up text if needed. */
		void UpdateCleanedUpTextIfNeeded(const bool& force);
	
		/**
		 * The confidence score of the token.
		 * The confidence score is a number between 0 and 1 
		 * which represent the guessed accuracy of the token text.
		 */
		float confidence;
		/**
		 * True if the confidence was set
		 */
		bool hasConfidence;
        /**
		 * Store if the Token is Optionnaly Deletable/Insertable.
		 */
		bool optional;
		/**
		 * Store if the Token is fragment.
		 * - Token::NOT_FRAGMENT if the token is not a fragment
		 * - Token::BEGIN_FRAGMENT if the token is a beginning fragment => frie-
		 * - Token::END_FRAGMENT if the token is an ending fragment => -ing
		 */
		int fragment;
		/**
		 * Precedent Tokens on the graph
		 */
        vector<Token*> prec;
        /**
		 * Next Tokens on the graph
		 */
        vector<Token*> next;
        /**
         * Parent Segment.
         */
        Segment* segment;
        /**
         * log
         */
        static Logger* logger;
		
		static const char FRAGMENT_MARKER;
		static const char BEGIN_OPTIONAL_MARKER;
		static const char END_OPTIONAL_MARKER;
};

#endif // TOKEN_H