/*
   * 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 TOKENALIGNMENT_H
  #define TOKENALIGNMENT_H
  
  #include "stdinc.h"
  #include "token.h"
  
  class TokenAlignment 
  {
      public:
          class AlignmentResult 
          {
              public:
                  AlignmentResult(const string & _shortName = string("UNSET"), const string & _description = string("Unset description"));
                  string GetDescription() { return m_description; }
                  string GetShortName() { return m_shortName; }
                  inline bool operator==(const AlignmentResult & rh) const { return m_shortName == rh.m_shortName; }
                  
              private:
                  string m_shortName;
                  string m_description;
          };
          
          class AlignmentEvaluation 
          {
              public:
                  AlignmentEvaluation(Token* token, const TokenAlignment::AlignmentResult & result = TokenAlignment::UNAVAILABLE);
                  ~AlignmentEvaluation() {}
                  Token* GetToken() { return m_token; }
                  TokenAlignment::AlignmentResult GetResult() { return m_result; }
                  void SetResult(const TokenAlignment::AlignmentResult & result) { m_result = result; }
                  
                  string ToString();
                  bool Equals(AlignmentEvaluation* other);
              private:
                  TokenAlignment::AlignmentResult m_result;
                  Token* m_token;
          };
          
          TokenAlignment(Token* refToken);
          ~TokenAlignment();
          
          int AddAlignmentFor(const string & hypothesisKey, Token* hypothesisToken);
          AlignmentEvaluation* GetAlignmentFor(const string & system) { return m_alignmentEvaluations[system]; }
          AlignmentResult GetResultFor(const string & system);
          Token* GetTokenFor(const string & system);
          
          Token* GetReferenceToken();
          
          string ToString();
          bool Equals(TokenAlignment* other) { return (this == other); }
          inline bool operator==(const TokenAlignment &rh) { return (this->m_alignmentEvaluations == rh.m_alignmentEvaluations); }
          
          static const AlignmentResult CORRECT;
          static const AlignmentResult SUBSTITUTION;
          static const AlignmentResult SPEAKERSUB;
          static const AlignmentResult DELETION;
          static const AlignmentResult INSERTION;
          static const AlignmentResult REFERENCE;
          static const AlignmentResult INVALID_SYSTEM;
          static const AlignmentResult UNAVAILABLE;
          
          static const string REFERENCE_KEY;
          
      private:
          map< string, AlignmentEvaluation* > m_alignmentEvaluations; 
  };
  
  typedef map< string, TokenAlignment::AlignmentEvaluation* > t_alignmentMap;
  
  #endif