/*
   * 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 SEGMENT_H
  #define SEGMENT_H
  
  #include "timedobject.h"
  #include "token.h"
  #include "logger.h"
  
  class Speech;
  
  /**
   * Internal representation of a segment.
   * A segment is a list of Token.
   */
  class Segment : public TimedObject
  {
  	public:		
  		// class destructor
  		~Segment();
  		/**
  		 * Register a Token as a begining token of this segment
  		 * A Segment can have multiple first token as the token is part of a graph.
  		 */
  		void AddFirstToken(Token* token);
  		/**
  		 * Try to retrieve the beginning token indexed number "index"
  		 */
  		Token* GetFirstToken(const size_t& index) { return f_token->GetNextToken(index); }
  		/**
  		 * Register a Token as an ending token of this segment
  		 * A Segment can have multiple ending token as the token is part of a graph.
  		 */
  		void AddLastToken(Token* token);
  		/**
  		 * Try to retrieve the ending token indexed number "index"
  		 */
  		Token* GetLastToken(const size_t& index) { return l_token->GetNextToken(index); }
  		/**
  		 * Return the number of last token of this segments
  		 */
  		size_t GetNumberOfLastToken() { return l_token->GetNbOfNextTokens(); }
  		/**
  		 * Return the number of begin token of this segments
  		 */
  		size_t GetNumberOfFirstToken() { return f_token->GetNbOfNextTokens(); }
  		/**
  		 * Set the Channel name of this segment
  		 */
  		void SetChannel(const string& x) { channel = x; }
  		/**
  		 * Return the channel name of this segment
  		 */
  		string GetChannel() { return channel; }
  		/**
  		 * Set the Speaker Id of this segment
  		 */
  		void SetSpeakerId(const string& x) { speakerId = x; }
  		/**
  		 * Retrieve the Speaker Id of this segment
  		 */
  		string GetSpeakerId() { return speakerId; }
  		/**
  		 * Set the source name of this segment
  		 */
  		void SetSource(const string& x) { source = x; }
  		/**
  		 * Retrieve the source name of this segment
  		 */
  		string GetSource() { return source; }
  		/**
  		 * Change the end time of this segment
  		 */
  		void SetEndTime(const int& _newEndTime) { endTime = _newEndTime; }
  		/**
  		 * Set the ID of the segment
  		 */
  		void SetId(const string& _id) { id = _id; }
  		/**
  		 * Retrieve ID of the segments
  		 */
  		string GetId() { return id; }
  		/**
           * Set the line number of this element in the source file.
           */
  		void SetSourceLineNum(long int _ln) { sourceLineNum = _ln; }
  		/**
           * Get the sequence number of this segment
           */
  		long int GetSourceLineNum() { return sourceLineNum; }
  		/**
           * Set the element sequence number with the source file.
           */
  		void SetSourceElementNum(const long int& _ln) { sourceElementNum = _ln; }
  		/**
           * Get the elements sequence number within the source file
           */
  		long int GetSourceElementNum() { return sourceElementNum; }
  		
  		void SetLabel(const string& _label) { m_Label = _label; }
  		string GetLabel() { return m_Label; }
  		
  		static Segment* CreateWithDuration(const int& _startTime, const int& _duration, Speech* parent);
  		static Segment* CreateWithEndTime(const int& _startTime, const int& _endTime, Speech* parent);
  		/**
  		 * Merge all Segments in one segments
  		 * @deprecated Shoudnt be use anymore. Try to work on the real segments instead
  		 */
          static Segment* Merge(const vector<Segment*> & segments);
  		/**
  		 * Output a planar version of the segment.
  		 */
  		vector<Token*> ToTopologicalOrderedStruct();
  		/** 
           * Return if the token is on the list of the First tokens.
           */
  		bool isFirstToken(Token* token);
  		/**
  		 * Return if the token is on the list of the last tokens.
  		 */
  		bool isLastToken(Token* token);
  		/**
  		 * Return true if no token are into this segment
  		 */
  		bool isEmpty() { return (f_token->GetNbOfNextTokens() == 0 || l_token->GetNbOfNextTokens() == 0); }
  		/**
  		 * Say if this segment should be exclude from scoring
  		 */
  		bool isSegmentExcludeFromScoring() { return ignoreSegmentInScoring; }
  		/**
           * Change the segment status as "not to score"
           */
          void SetAsSegmentExcludeFromScoring() { ignoreSegmentInScoring = true; }
  		
  		/** Retrieves the Speech in which this Segment is located. */
  		Speech* GetParentSpeech();
  		
  		/** Returns a string representation of this Segment */
  		string ToString();
  		
  		/** Returns a string representation of this Segment as a single line*/
  		string ToStringAsLine();
  		
  		/** Determines if case is taken into account to align Tokens part of this Speech. */
  		bool PerformCaseSensitiveAlignment();
  		
  		/** Determines if fragments are considered as correct when aligning Tokens part of this Speech. */
  		bool AreFragmentsCorrect();
  		
  		/** Determines if optionally deletable Tokens need to be accounted for. */
  		bool UseOptionallyDeletable();
  		
  		/** Replaces the token with the link list of tokes pointed to by the vectors containing pointers to the start and end tokens **/
  		void ReplaceTokenWith(Token *token, const vector<Token*> & startTokens, const vector<Token*> & endTokens);
  		
  		int GetMinTokensTime();
  		int GetMaxTokensTime();
  		
  		/** Set all the token optionaly deletable by adding () in the text */
  		void SetTokensOptionallyDeletable();
  		
  	protected:	
          /** Checks that start time and duration are valid for this TimedObject. Extension point for subclasses. */
          virtual bool AreStartTimeAndDurationValid(const int& _startTime, const int& _duration) { return AreStartTimeAndEndTimeValid(_startTime, _startTime + _duration); }
  		
          /** Checks that start time and end time are valid for this TimedObject. Extension point for subclasses. */
          virtual bool AreStartTimeAndEndTimeValid(const int& _startTime, const int& _endTime);
  		
  		// class constructor
  		Segment();
  			
  	private:
  		/**
  		 * Access to the first token of the segment.
  		 */
  		Token* f_token;
  		/**
  		 * Access to the last token of the segment.
  		 */
  		Token* l_token;
  		/**
  		 * The speaker identificator of this speaker.
  		 */
  		string speakerId;
  		/**
  		 * The channel this segment is referenced to.
  		 */
  		string channel;
  		/**
  		 * Represent the source of this segment.
  		 * This can be a meeting number/id or a the show name...
  		 */
  		string source;
  		/**
  		 * The id of the segment (if it has one)
  		 */
  		string id;
  		/**
  		 * The line number of the element within the originating source file
  		 */
  		long int sourceLineNum;
  		/**
  		 * The element number within the originating source file
  		 */
  		long int sourceElementNum;
  		/**
  		 * Define the scoring state of this segment
  		 */
  		bool ignoreSegmentInScoring;
  		/**
  		 * Return the parent speech object
  		 */
          Speech* speech;
  
  		/**
  		 * Labels used for stm files 
  		 */
  		string m_Label;
  		
  		int GetLowestTokenStartTime();
  		int GetHighestTokenEndTime();
  		/**
           * Recurs methods to compute a topological order of a graph
           */
          void ToTopologicalOrderedStruct(Token* start, vector<Token*> *doneNode);
  		
  		static Logger* logger;
  };
  
  #endif // SEGMENT_H