/** \file internal_capability_container.cpp .
-----------------------------------------------------------------------------

 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.

-----------------------------------------------------------------------------

   Description:

-----------------------------------------------------------------------------


   02/05/2003  Initial creation

-------------------------------------------------------------------------- */
//#define DEBUG_VERBOSE
// ---------------------------------------------------------------------------
//  Includes
// ---------------------------------------------------------------------------
#include "uima/pragmas.hpp"
using namespace std;


#include "uima/macros.h"
#include "uima/internal_capability_container.hpp"
#include "uima/err_ids.h"
#include "uima/msg.h"

namespace uima {

  UIMA_EXC_CLASSIMPLEMENT(CapabilityException, Exception);

  namespace internal {


    CapabilityContainer::CapabilityContainer( )
        :  iv_psetInputTOFsForUnspecifiedLang(NULL),
        iv_psetOutputTOFsForUnspecifiedLang(NULL),
        iv_bHasEmptyOutputTOFsForUnspecifiedLang(false) {}


    /*static*/
    void
    CapabilityContainer::initTypeOrFeatures(
      TyMapLang2TypeOrFeatures & rMap, // output argument
      Capability::TyVecCapabilityTofs const & vecTofs,
      Capability::TyVecCapabilityLanguages const & vecLangs,
      TypeSystem const & typeSystem) {
      const int BUF_SIZE = 0x100;
      char  cBuf[BUF_SIZE];
      Capability::TyVecCapabilityLanguages::const_iterator itLang;
      for (itLang = vecLangs.begin(); itLang != vecLangs.end(); ++itLang) {
        // convert unicode lang string to single-byte lang string
        assert((*itLang).length() < BUF_SIZE);
        // Note: this conversion can be used only for invariant characters
        u_UCharsToChars((*itLang).getBuffer(), cBuf, (*itLang).length());
        // zero terminate single-byte buffer
        cBuf[(*itLang).length()] = '\0';
        // Special workaround code for the new way to specify the unspecified language
        if (strcasecmp(cBuf, "x-unspecified") == 0) {
          strcpy(cBuf, Language::UNSPECIFIED);
        }
        // create a language object based on single-byte lang string
        Language lang(cBuf);
        if (!lang.isValid()) {
          /* taph 06.02.2003: once we have more detailed information about
          the origin of the error we need to replace "unknown configuration file"
          with the filename of the XML file (and maybe line number?) */
          UIMA_EXC_THROW_NEW(uima::CapabilityException,          // exc-type
                             UIMA_ERR_ENGINE_LANGUAGE_INVALID,   // error code
                             ErrorMessage(UIMA_MSG_ID_EXC_INVALID_LANGUAGE, cBuf), // error message
                             ErrorMessage(UIMA_MSG_ID_EXCON_CHECKING_CAPABILITY_SPEC,"unknown configuration file"),  // error context message
                             ErrorInfo::recoverable);
        }
        // create a new empty vector in the map for this lang
        TySetTypeOrFeatures & setTofs = rMap[lang];
        // now fill the vector with tof objects created from tof strings
        Capability::TyVecCapabilityTofs::const_iterator itTof;
        for (itTof = vecTofs.begin(); itTof != vecTofs.end(); ++itTof) {
          TypeOrFeature tof;
          // the tof string may be a type...
          Type t = typeSystem.getType(*itTof);
          if (t.isValid()) {
            tof = TypeOrFeature(t);
          } else {
            // or the tof string may be a feature
            Feature f = typeSystem.getFeatureByFullName(*itTof);
            if (f.isValid()) {
              tof = TypeOrFeature(f);
            } else {
              /* taph 06.02.2003: once we have more detailed information about
              the origin of the error we need to replace "unknown configuration file"
              with the filename of the XML file (and maybe line number?) */
              if (tof.isType()) {
                UIMA_EXC_THROW_NEW(uima::CapabilityException,        // exc-type
                                   UIMA_ERR_INVALID_FSTYPE_OBJECT,   // error code
                                   ErrorMessage(UIMA_MSG_ID_EXC_UNKNOWN_TYPE_NAME, *itTof), // error message
                                   ErrorMessage(UIMA_MSG_ID_EXCON_CHECKING_CAPABILITY_SPEC, "unknown configuration file"),  // error context message
                                   ErrorInfo::recoverable);
              } else {
                UIMA_EXC_THROW_NEW(uima::CapabilityException,        // exc-type
                                   UIMA_ERR_INVALID_FSFEATURE_OBJECT,// error code
                                   ErrorMessage(UIMA_MSG_ID_EXC_UNKNOWN_FEATURE_NAME, *itTof), // error message
                                   ErrorMessage(UIMA_MSG_ID_EXCON_CHECKING_CAPABILITY_SPEC, "unknown configuration file"),  // error context message
                                   ErrorInfo::recoverable);
              }
            }
          }
          assert(tof.isValid());
          setTofs.insert(tof);
        } // for all tof strings
      } // for all lang strings
    }


    void CapabilityContainer::computeClosure(TyMapLang2TypeOrFeatures & rMap, TyMapLang2TypeOrFeatures & noTerritoryMap) {
      assert( noTerritoryMap.empty() );
      // 1. all original TOFS from iv_mapLang2*TypesOrFeatures for language codes without territory
      // are copied as iv_mapLang2*TypesOrFeaturesNoTerritory
      TyMapLang2TypeOrFeatures::const_iterator cit;
      for (cit = rMap.begin(); cit != rMap.end(); ++cit) {
        Language const & lang = (*cit).first;
        if ( !lang.hasTerritory() ) {
          noTerritoryMap[lang] = (*cit).second;
        }
      }

      // 2. all TOFs from en are appended to en_US, en_GB etc. for iv_mapLang2*TypesOrFeatures
      TyMapLang2TypeOrFeatures::iterator it;
      for (it = rMap.begin(); it != rMap.end(); ++it) {
        Language const & lang = (*it).first;
        if ( lang.hasTerritory() ) {
          // put all TOFs "down" from pt to pt_BR
          Language langWithoutTerritory(lang.getLanguage());
          TySetTypeOrFeatures & rSet = rMap[langWithoutTerritory];
          TySetTypeOrFeatures & specificSet = (*it).second;
          // MSV6 compile error: specificSet.insert( rSet.begin(), rSet.end() );
          TySetTypeOrFeatures::const_iterator setit;
          for (setit = rSet.begin(); setit != rSet.end(); ++setit) {
            specificSet.insert( *setit );
          }
        }
      }

      // 3. all TOFs from en_GB, en_US, etc. are appended to en for iv_mapLang2*TypesOrFeatures
      for (it = rMap.begin(); it != rMap.end(); ++it) {
        Language const & lang = (*it).first;
        if ( lang.hasTerritory() ) {
          // put all TOFs "up" from pt_BR to pt
          Language langWithoutTerritory(lang.getLanguage());
          TySetTypeOrFeatures & rSet = (*it).second;
          // MSV6 compile error:       rMap[langWithoutTerritory].insert( rSet.begin(), rSet.end() );
          TySetTypeOrFeatures::const_iterator setit;
          for (setit = rSet.begin(); setit != rSet.end(); ++setit) {
            rMap[langWithoutTerritory].insert(*setit);
          }

        }
      }

#ifdef DEBUG_VERBOSE
      UIMA_TPRINT("Standard Map:");
      for (cit = rMap.begin(); cit != rMap.end(); ++cit) {
        UIMA_TPRINT("Language: " << (*cit).first);
        UIMA_TPRINT("   TOFs:");
        TySetTypeOrFeatures const & set = (*cit).second;
        TySetTypeOrFeatures::const_iterator setcit;
        for (setcit = set.begin(); setcit != set.end(); ++setcit) {
          UIMA_TPRINT("       " << (*setcit).getName());
        }
      }

#endif

    }


    void
    CapabilityContainer::init( vector<Capability*> const & vecCap, TypeSystem const & typeSystem, EnMatchPolicy enMatchPolicy ) {
      iv_enMatchPolicy = enMatchPolicy;
      vector<Capability*>::const_iterator it;
      assert(iv_mapLang2InputTypesOrFeatures.size() == 0);
      assert(iv_mapLang2OutputTypesOrFeatures.size() == 0);
      for (it = vecCap.begin(); it != vecCap.end(); ++it) {
        assert(EXISTS(*it));
        Capability const & cap = (*(*it));
        initTypeOrFeatures(
          iv_mapLang2InputTypesOrFeatures,
          cap.getCapabilityTypes(Capability::INPUT),
          cap.getSupportedLanguages(),
          typeSystem);
        initTypeOrFeatures(
          iv_mapLang2InputTypesOrFeatures,
          cap.getCapabilityFeatures(Capability::INPUT),
          cap.getSupportedLanguages(),
          typeSystem);
        initTypeOrFeatures(
          iv_mapLang2OutputTypesOrFeatures,
          cap.getCapabilityTypes(Capability::OUTPUT),
          cap.getSupportedLanguages(),
          typeSystem);
        initTypeOrFeatures(
          iv_mapLang2OutputTypesOrFeatures,
          cap.getCapabilityFeatures(Capability::OUTPUT),
          cap.getSupportedLanguages(),
          typeSystem);
      }

      // try to find input tofs for unspecifed language
      assert(iv_psetInputTOFsForUnspecifiedLang == NULL);
      TySetTypeOrFeatures const * pSetInputTOFs =
        findInputTOFs(Language(Language::UNSPECIFIED));
      if (pSetInputTOFs != NULL) {
        iv_psetInputTOFsForUnspecifiedLang = pSetInputTOFs;
      }
      // try to find output tofs for unspecifed language
      assert(iv_psetOutputTOFsForUnspecifiedLang == NULL);
      TySetTypeOrFeatures const * pSetOutputTOFs =
        findOutputTOFs(Language(Language::UNSPECIFIED));
      if (pSetOutputTOFs != NULL) {
        iv_psetOutputTOFsForUnspecifiedLang = pSetOutputTOFs;
      }

      copyEntriesForUnspecifedLanguage();
      if (hasEmptyOutputTypeOrFeatures(Language(Language::UNSPECIFIED))) {
        iv_bHasEmptyOutputTOFsForUnspecifiedLang = true;
      }

      computeClosure(iv_mapLang2OutputTypesOrFeatures, iv_mapLang2OutputTypesOrFeaturesNoTerritory );
      computeClosure(iv_mapLang2InputTypesOrFeatures, iv_mapLang2InputTypesOrFeaturesNoTerritory );
    }

    void CapabilityContainer::copyEntriesForUnspecifedLanguage() {
      if (iv_psetInputTOFsForUnspecifiedLang == NULL) {
        // if it is not in the input it can't be in the output either
        assert(findOutputTOFs(Language(Language::UNSPECIFIED)) == NULL);
        return;
      }
      assert(EXISTS(iv_psetInputTOFsForUnspecifiedLang));
      if (iv_psetInputTOFsForUnspecifiedLang->size() != 0) {
        TyMapLang2TypeOrFeatures::iterator it;
        for (it = iv_mapLang2InputTypesOrFeatures.begin(); it != iv_mapLang2InputTypesOrFeatures.end(); ++it) {
          if (&(*it).second != iv_psetInputTOFsForUnspecifiedLang) { // don't append onto ourselves
            if ((*it).second.size() > 0) { // don't append to empty
#ifndef NDEBUG
              size_t uiOldSize = (*it).second.size();
#endif /* NDEBUG */
              // MSV6 compile error: (*it).second.insert(iv_psetInputTOFsForUnspecifiedLang->begin(), iv_psetInputTOFsForUnspecifiedLang->end());
              TySetTypeOrFeatures::const_iterator tofit;
              for (tofit = iv_psetInputTOFsForUnspecifiedLang->begin(); tofit != iv_psetInputTOFsForUnspecifiedLang->end(); ++tofit) {
                (*it).second.insert( *tofit );
              }
              assert((*it).second.size() >= uiOldSize);
            }
          }
        }

        // Now do the same copying for the output

        // if it is in the input it must be in the output too
        assert(findOutputTOFs(Language(Language::UNSPECIFIED)) != NULL);
        assert(EXISTS(iv_psetOutputTOFsForUnspecifiedLang));

        for (it = iv_mapLang2OutputTypesOrFeatures.begin(); it != iv_mapLang2OutputTypesOrFeatures.end(); ++it) {
          if (&(*it).second != iv_psetOutputTOFsForUnspecifiedLang) { // don't append onto ourselves
            if ((*it).second.size() > 0) { // don't append to empty
#ifndef NDEBUG
              size_t uiOldSize = (*it).second.size();
#endif /* NDEBUG */
              // MSV6 compile error: (*it).second.insert(iv_psetOutputTOFsForUnspecifiedLang->begin(), iv_psetOutputTOFsForUnspecifiedLang->end());
              TySetTypeOrFeatures::const_iterator tofit;
              for (tofit = iv_psetOutputTOFsForUnspecifiedLang->begin(); tofit != iv_psetOutputTOFsForUnspecifiedLang->end(); ++tofit) {
                (*it).second.insert(*tofit);
              }
              assert((*it).second.size() >= uiOldSize);
            }
          }
        }
      }
    }


    /*static*/ CapabilityContainer::TySetTypeOrFeatures const *
    CapabilityContainer::findTOFs(TyMapLang2TypeOrFeatures const & crMap,
                                  TyMapLang2TypeOrFeatures const & noTerritoryMap,
                                  Language const & lang,  EnMatchPolicy enMatchPolicy) {
      // temporary
      assert( enMatchPolicy == enStrictThenLooseMatch );
      //first try strict match using built-in find function
      TyMapLang2TypeOrFeatures::const_iterator itMap = crMap.find(lang);
      if (itMap != crMap.end()) {
        return (&(*itMap).second);
      }

      if (enMatchPolicy == enStrictMatchOnly) {
        return NULL;
      }
      assert(enMatchPolicy == enStrictThenLooseMatch);
      // language was not found directly
      // now try without territory
      Language newLang(lang.getLanguage());
      assert( !newLang.hasTerritory() );
      for (itMap = noTerritoryMap.begin(); itMap != noTerritoryMap.end(); ++itMap) {
        assert( !(*itMap).first.hasTerritory() );
        if ((*itMap).first.getLanguage() == lang.getLanguage()) {
          return (&(*itMap).second);
        }
      }
      return NULL;
    }

    CapabilityContainer::TySetTypeOrFeatures const *
    CapabilityContainer::findInputTOFs(Language const & lang) const {
      // try to find the set for the language
      TySetTypeOrFeatures const * pSetTOFs =
        findTOFs(iv_mapLang2InputTypesOrFeatures, iv_mapLang2InputTypesOrFeaturesNoTerritory, lang, iv_enMatchPolicy);
      // if there is one return that one
      if (pSetTOFs != NULL) {
        return pSetTOFs;
      }
      // else return whatever we may have for the unspecified language
      return (iv_psetInputTOFsForUnspecifiedLang);
    }

    CapabilityContainer::TySetTypeOrFeatures const *
    CapabilityContainer::findOutputTOFs(Language const & lang) const {
      // try to find the set for the language
      TySetTypeOrFeatures const * pSetTOFs =
        findTOFs(iv_mapLang2OutputTypesOrFeatures, iv_mapLang2OutputTypesOrFeaturesNoTerritory, lang, iv_enMatchPolicy);
      // if there is one return that one
      if (pSetTOFs != NULL) {
        return pSetTOFs;
      }
      // else return whatever we may have for the unspecified language
      return (iv_psetOutputTOFsForUnspecifiedLang);
    }


    CapabilityContainer::TySetTypeOrFeatures const &
    CapabilityContainer::getInputTypeOrFeatures( Language const & lang) const {
      // try to find it
      TySetTypeOrFeatures const * pSetTOFs = findInputTOFs(lang);
      if (pSetTOFs != NULL) {
        return (*pSetTOFs);
      }
      // don't use the [] operator because would insert and return a
      // newly created empty vector
      assert(iv_setEmptyTypeOrFeaturesSet.size() == 0);
      return iv_setEmptyTypeOrFeaturesSet;
    }

    bool
    CapabilityContainer::hasInputTypeOrFeature( TypeOrFeature const & tof, Language const & lang) const {
      // try to find it
      TySetTypeOrFeatures const * pSetTOFs = findInputTOFs(lang);
      if (pSetTOFs == NULL) {
        return false;
      }
      TySetTypeOrFeatures::const_iterator itSet = pSetTOFs->find(tof);
      if (itSet == pSetTOFs->end()) {
        return false;
      }
      return true;
    }

    CapabilityContainer::TySetTypeOrFeatures const &
    CapabilityContainer::getOutputTypeOrFeatures( Language const & lang) const {
      // try to find it
      TySetTypeOrFeatures const * pSetTOFs = findOutputTOFs(lang);
      if (pSetTOFs != NULL) {
        return (*pSetTOFs);
      }
      // don't use the [] operator because will insert and return a
      // newly created empty vector
      assert(iv_setEmptyTypeOrFeaturesSet.size() == 0);
      return iv_setEmptyTypeOrFeaturesSet;
    }

    bool
    CapabilityContainer::hasOutputTypeOrFeature( TypeOrFeature const & tof, Language const & lang) const {
      // try to find it
      TySetTypeOrFeatures const * pSetTOFs = findOutputTOFs(lang);
      if (pSetTOFs == NULL) {
        return false;
      }
      TySetTypeOrFeatures::const_iterator itSet = pSetTOFs->find(tof);
      if (itSet == pSetTOFs->end()) {
        return false;
      }
      return true;
    }

    bool
    CapabilityContainer::hasEmptyOutputTypeOrFeatures( Language const & lang) const {
      // try to find it in output
      TySetTypeOrFeatures const * pSetTOFs = findOutputTOFs(lang);
      if (pSetTOFs == NULL) {
        // we must have an explicit entry for that language in our map
        // or maybe we have an empty entry for the unspecifed lang
        return iv_bHasEmptyOutputTOFsForUnspecifiedLang;
      }
      // but that explicit entry must be empty
      if (pSetTOFs->size() > 0) {
        return false;
      }
      return true;

    }

  } // namespace internal
} // namespace uima