/** \file lowlevel_fsheap.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:

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


-------------------------------------------------------------------------- */


/* ----------------------------------------------------------------------- */
/*       Include dependencies                                              */
/* ----------------------------------------------------------------------- */
#include "uima/pragmas.hpp"

//#define DEBUG_VERBOSE
#include "uima/macros.h"

#include "uima/lowlevel_fsheap.hpp"

/* ----------------------------------------------------------------------- */
/*       Constants                                                         */
/* ----------------------------------------------------------------------- */

/* ----------------------------------------------------------------------- */
/*       Forward declarations                                              */
/* ----------------------------------------------------------------------- */

/* ----------------------------------------------------------------------- */
/*       Types / Classes                                                   */
/* ----------------------------------------------------------------------- */

/* ----------------------------------------------------------------------- */
/*       Implementation                                                    */
/* ----------------------------------------------------------------------- */
using namespace std;
namespace uima {

  namespace lowlevel {

    TyFS const FSHeap::INVALID_FS = 0;

    FSHeap::FSHeap(TypeSystem const & rclTypeSystem,
                   size_t uiFSHeapPageSize,
                   size_t uiStringHeapPageSize,
                   size_t uiStringRefHeapPageSize) :
        iv_clTemporaryHeap(uiFSHeapPageSize, 0),
        iv_clTemporaryStringHeap(uiStringHeapPageSize, 0),
        iv_clTemporaryStringRefHeap(uiStringRefHeapPageSize, 0),
        iv_clTemporary8BitHeap(1, 0),
        iv_clTemporary16BitHeap(1, 0),
        iv_clTemporary64BitHeap(1, 0),
        iv_rclTypeSystem(rclTypeSystem) {
      UIMA_TPRINT("heap constructed");
      assert( INVALID_FS == 0 );
    }

    FSHeap::FSHeap(TypeSystem const & rclTypeSystem,
                   size_t uiFSHeapPageSize,
                   size_t uiStringHeapPageSize,
                   size_t uiStringRefHeapPageSize,
                   size_t uiMinHeapPageSize) :
        iv_clTemporaryHeap(uiFSHeapPageSize, 0),
        iv_clTemporaryStringHeap(uiStringHeapPageSize, 0),
        iv_clTemporaryStringRefHeap(uiStringRefHeapPageSize, 0),
        iv_clTemporary8BitHeap(uiMinHeapPageSize, 0),
        iv_clTemporary16BitHeap(uiMinHeapPageSize, 0),
        iv_clTemporary64BitHeap(uiMinHeapPageSize, 0),
        iv_rclTypeSystem(rclTypeSystem) {
      UIMA_TPRINT("heap constructed");
      assert( INVALID_FS == 0 );
    }


    FSHeap::~FSHeap() {}

    void FSHeap::reset() {
      assert( debugIsConsistent() );
      TyFSHeap & rHeapToBeResetted = getHeap();
      rHeapToBeResetted.reset();
      TyStringHeap & rStringHeapToBeResetted = getStringHeap();
      rStringHeapToBeResetted.reset();
      TyStringRefHeap & rStringRefHeapToBeResetted = getStringRefHeap();
      rStringRefHeapToBeResetted.reset();

      Ty8BitHeap & r8BitHeapToBeResetted = get8BitHeap();
      r8BitHeapToBeResetted.reset();
      Ty16BitHeap & r16BitHeapToBeResetted = get16BitHeap();
      r16BitHeapToBeResetted.reset();
      Ty64BitHeap & r64BitHeapToBeResetted = get64BitHeap();
      r64BitHeapToBeResetted.reset();
    }


    void FSHeap::setStringValue(TyFS tyFs, TyFSFeature tyFeature, int strRef) {
      assert( iv_rclTypeSystem.isValidFeature(tyFeature) );
      assert( iv_rclTypeSystem.subsumes(uima::internal::gs_tyStringType, iv_rclTypeSystem.getRangeType(tyFeature)));

#ifndef NDEBUG
      TyFSType rangeType = iv_rclTypeSystem.getRangeType(tyFeature);
      // if we have an enumeration subtype of string
      if (rangeType != uima::internal::gs_tyStringType ) {
        vector<icu::UnicodeString> const & crStringSet = iv_rclTypeSystem.getStringsForStringSubtype(rangeType);
        vector<icu::UnicodeString>::const_iterator cit;
        bool bStringFound = false;
        UnicodeStringRef crStringRef(iv_clTemporaryStringHeap.getHeapStart()+strRef);
        for (cit = crStringSet.begin(); cit != crStringSet.end(); ++cit) {
          UnicodeStringRef ref(*cit);
          if ( ref == crStringRef ) {
            bStringFound = true;
            break;
          }
        }
        assert (bStringFound);
      }
#endif

      TyFS tyCurrentString = getFeatureInternal( tyFs, tyFeature );
      if (tyCurrentString == 0) {
        // add entry to StringRefHeap and set values there
        tyCurrentString = getStringAsFS(strRef);
      } else {
        // reuse entry in StringRefHeap
        setStringRef(tyCurrentString, strRef);
      }

      setFeatureInternal(tyFs, tyFeature, tyCurrentString);
    }

    void FSHeap::copyFeatures(TyFS tyTarget, TyFS tySource, size_t featNum) {
      uima::lowlevel::TyFSType type = getType(tyTarget);
      if (featNum == 0) {
        assert( type == getType(tySource) );
        featNum = iv_rclTypeSystem.getFeatureNumber( getType(tyTarget));
      }
      size_t i;
      for (i=1; i<=featNum; ++i) {
        uima::lowlevel::TyFSFeature feat = iv_rclTypeSystem.getFeatureFromOffset(type, i);
        if ( iv_rclTypeSystem.subsumes( uima::internal::gs_tyStringType, iv_rclTypeSystem.getRangeType(feat) ) ) {
          // get offset of stringRef in stringRefHeap
          int strRef = iv_clTemporaryHeap.getHeapValue(tySource+i);
          // if string value set, create duplicate reference to string in refHeap
          if (strRef != 0) {
            int ref = iv_clTemporaryStringRefHeap.getHeapValue(1 + 2*(strRef-1));
            iv_clTemporaryHeap.setHeapValue(tyTarget+i, getStringAsFS(ref));
          }
        } else {
          iv_clTemporaryHeap.setHeapValue(tyTarget+i, iv_clTemporaryHeap.getHeapValue(tySource+i));
        }
      }

    }


// cout << of a 64bit type causes a warning (conversion to int, loss of data)
// since we can't help the implementation of cout we surpress the warning
#if defined( _MSC_VER )
#pragma warning( push )
#pragma warning( disable : 4244 )
#endif
    void FSHeap::printFS(ostream& os, TyFS fs) const {
      TyFSType type = getType( fs );
      icu::UnicodeString typeName = iv_rclTypeSystem.getTypeName(type);
      int n=0;
      os << n++ << ":  | " << typeName << endl;
      unsigned int i;
      for (i=1; i<iv_rclTypeSystem.getFeatureNumber(type) + 1; ++i) {
        os << n++ << ":  | " << (ptrdiff_t) getFeatureWithOffset(fs, i) << endl;
      }
    }


    void FSHeap::print(ostream& os) const {
      os << "=============================================" << endl;
#ifdef BYEBYEPTRS
      void * h;
      size_t i;
      size_t lastHeapCell = iv_clTemporaryHeap.getLastHeapCell();
      size_t topOfHeap = iv_clTemporaryHeap.getTopOfHeap();

      if (true) {
        os << "Plain HEAP:" << endl;
        h=iv_clTemporaryHeap.getHeapStart();
        i=0;
        for (h=1; h< lastHeapCell; ++h) {
          os << i++ << " (" << (ptrdiff_t) h << ", " << h << ") :  | " << ((ptrdiff_t) (*h));
          if (h == topOfHeap) {
            os << "   <---" << endl;
            break;
          }

          os << endl;
        }
      }
      os << "-----------------------------" << endl;


      UChar* uc = iv_clTemporaryStringHeap.getHeapStart();
      size_t topOfStringHeap = iv_clTemporaryStringHeap.getTopOfHeap();

      if (false) {
        os << "PLAIN STRING TABLE" << endl;
        while ((uc-iv_clTemporaryStringHeap.getHeapStart())<topOfStringHeap) {
          os << (ptrdiff_t) uc << ": " << *uc << "(" << (ptrdiff_t) (*uc) << ")" << endl;
          ++uc;
        }
        os << "-----------------------------" << endl;
        uc = iv_clTemporaryStringHeap.getHeapStart();
        topOfStringHeap = iv_clTemporaryStringHeap.getTopOfHeap();
      }
      os << "String table: " << endl;
      while ( (uc-iv_clTemporaryStringHeap.getHeapStart()) < topOfStringHeap) {
        UnicodeStringRef uls(uc);
        os << " " << (ptrdiff_t) uc << ": " << uls << endl;
        uc += uls.length() + 1;
      }

      os << "-----------------------------" << endl;
      os << "HEAP:" << endl;
      h = iv_clTemporaryHeap.getHeapStart() + 1;
      int n=1;
      while (h<lastHeapCell) {
        if ( (*h) == 0 ) {
          return;
        }
        TyFS currentFS = h;
        TyFSType type = getType( h );
        icu::UnicodeString typeName = iv_rclTypeSystem.getTypeName(type);
        os << n++ << ":  (" << (ptrdiff_t) h << ")| " << typeName << endl;
        ++h;
        int i;
        for (i=0; i< (int) iv_rclTypeSystem.getFeatureNumber(type); ++i) {
          os << n++ << ":  (" << (ptrdiff_t) h << ")| " << ((ptrdiff_t) (*h)) << endl;
          ++h;
        }
        if (iv_rclTypeSystem.subsumes( uima::internal::gs_tyArrayBaseType, type) ) {
          ++h; // for the array size field
          int iArraySize = getArraySize(currentFS);
          for (i=0; i<iArraySize; ++i) {
            os << n++ << ":  (" << (ptrdiff_t) h << ")| " << ((ptrdiff_t) (*h)) << endl;
            ++h;
          }
        }
      }
#endif
    }
#if defined( _MSC_VER )
#pragma warning( pop )
#endif

#ifdef ASSERT_OR_RETURN_FALSE
#error ASSERT_OR_RETURN_FALSE already defined
#endif
#define ASSERT_OR_RETURN_FALSE(x) if (!(x)) return false
//#define ASSERT_OR_RETURN_FALSE(x) assert(x)


    bool FSHeap::debugIsConsistent() const {
#ifdef BYEBYEPTRS
      if (iv_clTemporaryHeap.getSegmentNumber() >= 1) {
        return true;
      }
//         print(cout);
      static int debugCheck = 0;
      //   cerr << " debugCheck: " << debugCheck << endl;
      ++debugCheck;
      if ( (debugCheck % 1) != 0) {
//            return true;
      }
      UIMA_TPRINT("  doing check... (debugCheck: " << debugCheck << ")");
      TyFSType integerType = iv_rclTypeSystem.getTypeByName("uima.cas.Integer");
      TyFSType floatType = iv_rclTypeSystem.getTypeByName("uima.cas.Float");
      TyFSType stringType = iv_rclTypeSystem.getTypeByName("uima.cas.String");

      size_t lastHeapCell = iv_clTemporaryHeap.getLastHeapCell();
      size_t h = 1;
      while (h<lastHeapCell) {
        UIMA_TPRINT("Checking heap cell " << ((lastHeapCell-h)) );
        ASSERT_OR_RETURN_FALSE( EXISTS(h) );
        ASSERT_OR_RETURN_FALSE( debugIsValidHeapCell(h) );

        if ( (*h) == 0) {
          do {
            ASSERT_OR_RETURN_FALSE( (*h) == 0 );
            ++h;
          } while (h<lastHeapCell);
          UIMA_TPRINT("   check done");
          return true;
        }
        ASSERT_OR_RETURN_FALSE( *h != 0 );

        TyFSType type = getType( h );
        ASSERT_OR_RETURN_FALSE( type != 0 );
        vector<TyFSFeature> features;
        iv_rclTypeSystem.getAppropriateFeatures(type, features);
        ASSERT_OR_RETURN_FALSE( features.size() == iv_rclTypeSystem.getFeatureNumber(type) );
        size_t i;
        for (i=0; i<features.size(); ++i) {
          TyFSFeature f = features[i];
          TyFSType rangeType = iv_rclTypeSystem.getRangeType( f );
          if ( (rangeType == integerType)
               || (rangeType == floatType)
             || iv_rclTypeSystem.subsumes(stringType, rangeType) ) {}
          else {
            if (!isUntouchedFSValue(h,f)) {
              // type is complex FS
              TyFS fs = getFSValue(h, f);
              ASSERT_OR_RETURN_FALSE(debugIsValidHeapCell(fs));
              TyFSType fsType = getType(fs);
              ASSERT_OR_RETURN_FALSE( iv_rclTypeSystem.subsumes(rangeType, fsType) );
            }
          }
        }
        h += features.size() + 1;
      }
#endif
      UIMA_TPRINT("   check done");
      return true;
    }


    bool FSHeap::debugIsValidHeapCell(TyHeapCell cell) const {
      return iv_clTemporaryHeap.debugIsValidHeapCell(cell);
    }

  }
}
/* ----------------------------------------------------------------------- */