////////////////////////////////////////////////////////////////////////////////
/** 
  \file
  \brief \ru Контроль выделения памяти под отладкой.
         \en Memory allocation control during the debugging process. \~

*/
////////////////////////////////////////////////////////////////////////////////

#ifndef __MEMORY_DEBUG_H
#define __MEMORY_DEBUG_H

//#define __DEBUG_MEMORY_ALLOCATE_FREE_
//#define __MEMSET_USED_FREE_HEAP_HEAR__
//#define __REALLOC_ARRAYS_STATISTIC_

#include <math_x.h>
#include <system_types.h>
#include <memory.h>

#ifdef C3D_DEBUG
  #if defined(C3D_MacOS) // mac
  #include <malloc/malloc.h>
  #elif defined(C3D_FreeBSD)
  #include <stdlib.h>
  #else
  #include <malloc.h>
  #endif // mac

  #ifndef __DISABLE_MEMORY_CONTROL__  // \ru Чтобы можно было отключать в других проектах \en To allow to disable it in other projects 
    #ifndef __BORLANDC__
      #define USE_REALLOC_IN_ARRAYS // no _aligned_realloc in bcc32c
    #endif
  #endif // __DISABLE_MEMORY_CONTROL__
#endif // C3D_DEBUG

#ifdef __REALLOC_ARRAYS_STATISTIC_
//#include <stdio.h>
#include <string>
#include <fstream>
#endif


#ifdef __DEBUG_MEMORY_ALLOCATE_FREE_

//------------------------------------------------------------------------------
/// \ru Проверить указатель и значение. \en Check pointer and value.  \~ \ingroup Base_Tools
// ---
inline void CheckPointerAndValue( void * ptr, size_t size )
{
#if defined (C3D_WINDOWS) && !defined(ALL_WARNINGS)  //_MSC_VER // Set warnings level
#pragma warning(disable: 4312)
#endif
  C3D_ASSERT( ptr != (ptrdiff_t *)0xEEEEEEEE );
  C3D_ASSERT( ptr != (ptrdiff_t *)0xFFFFFFFF );
#if defined (C3D_WINDOWS) && !defined(ALL_WARNINGS)  //_MSC_VER // Set warnings level
#pragma warning(default: 4312)
#endif

  if ( ptr ) {
    // \ru Надо доработать для 64-бит \en It should be adapted for the 64-bit version 
    if ( size > 11 ) {
      uint32* _ptr = (uint32 *)ptr;
      uint32 value1 = *_ptr++;
      uint32 value2 = *_ptr++;
      uint32 value3 = *_ptr;
      C3D_ASSERT( value1 != 0xEEEEEEEE || value2 != 0xEEEEEEEE || value3 != 0xEEEEEEEE );
      C3D_ASSERT( value1 != 0xFFFFFFFF || value2 != 0xFFFFFFFF || value3 != 0xFFFFFFFF );
    }
    else if ( size > 7 ) {
      uint32 * _ptr = (uint32 *)ptr;
      uint32 value1 = *_ptr++;
      uint32 value2 = *_ptr;
      C3D_ASSERT( value1 != 0xEEEEEEEE && value2 != 0xEEEEEEEE );
      C3D_ASSERT( value1 != 0xFFFFFFFF || value2 != 0xFFFFFFFF );
    }
    else if ( size > 3 ) {
      uint32 value = *(uint32 *)ptr;
      C3D_ASSERT( value != 0xEEEEEEEE );
      C3D_ASSERT( value != 0xFFFFFFFF );
    }
    else if ( size > 1 ) {
      uint16 value = *(uint16 *)ptr;
      C3D_ASSERT( value != 0xEEEE );
      C3D_ASSERT( value != 0xFFFF );
    }
  }
}

//------------------------------------------------------------------------------
/// \ru Выделить память указанного размера. \en Allocate memory of the given size.  \~ \ingroup Base_Tools
// ---
inline void * Allocate( size_t size, const char * ) // className )
{
  void * ptr = ::malloc( size );
  // \ru Дабы работал _msize: void * ptr = ::operator new( size ); \en For working of _msize: void * ptr = ::operator new( size ); 

  if ( ptr ) {
    ::memset( ptr, 0xFF, size );
  }
  return ptr;
}

//------------------------------------------------------------------------------
/// \ru Выделить память указанного размера под массив. \en Allocate memory of the given size for an array.  \~ \ingroup Base_Tools
// ---
inline void * AllocateArray( size_t size, const char * ) // className )
{
  void * ptr = ::malloc( size );
  // \ru Дабы работал _msize: void *ptr = ::operator new [] ( size ); \en For working of _msize: void *ptr = ::operator new [] ( size ); 

  if ( ptr ) {
#ifdef __MEMSET_USED_FREE_HEAP_HEAR__
    ::memset( ptr, 0xFFFFFFFF, size );  // \ru OV - надо доработать для 64-бит \en OV - it should be adapted for the 64-bit version 
#endif // __MEMSET_USED_FREE_HEAP_HEAR__
  }
  return ptr;
}

//------------------------------------------------------------------------------
/// \ru Освободить память указанного размера. \en Free memory of the given size.  \~ \ingroup Base_Tools
// ---
inline void Free( void * ptr, size_t size, const char * ) // className )
{
  if ( ptr ) {
    ::CheckPointerAndValue( ptr, size );

#ifdef __MEMSET_USED_FREE_HEAP_HEAR__
    size_t ptr_size = ::_msize( ptr );
    C3D_ASSERT( ptr_size > 0 && ptr_size < 0xFFFFFFFF ); // \ru Надо доработать для 64-бит. \en It should be adapted for the 64-bit version.
    if ( ptr_size ) {
      C3D_ASSERT( size <= ptr_size );
      ::memset( ptr, 0xEE, ptr_size );
    }
#endif // __MEMSET_USED_FREE_HEAP_HEAR__

    ::free( ptr );
  }
}

//------------------------------------------------------------------------------
/// \ru Освободить память, выделенную под массив. \en Free the memory allocated for the array.  \~ \ingroup Base_Tools
// ---
// \ru ЯТ можно перегрузить в классах operator delete [] ( void *, size_t ) и передать \en ЯТ it is pertinent to overload the operator delete [] ( void *, size_t ) and pass 
// \ru в эту функцию size_t size, но это будет не размер массива, а размер Type, \en to this function size_t size, but this will be not the size of an array but the size of 'Type', 
// \ru массив которых распределялся. То есть эта информация здесь не нужна (делать \en an array of which was not distribute. I.e. this information is not needed here ( 
// \ru ::memset не нее НЕЛЬЗЯ!) \en it is forbidden to do ::memset here) 
// ---
inline void FreeArray( void * ptr, const char * ) // className )
{
  if ( ptr ) {
    ::CheckPointerAndValue( ptr, 0/*size*/ );

#ifdef __MEMSET_USED_FREE_HEAP_HEAR__
    size_t size = ::_msize( ptr );
    C3D_ASSERT( size > 0 && size < 0xFFFFFFFF );  // \ru OV - надо доработать для 64-бит \en OV - it should be adapted for the 64-bit version 
    ::CheckPointerAndValue( ptr, size );
    if ( size )
      ::memset( ptr, 0xEE, size );
#endif // __MEMSET_USED_FREE_HEAP_HEAR__

    ::free( ptr );
  }
}

#endif // __DEBUG_MEMORY_ALLOCATE_FREE_


#ifdef __REALLOC_ARRAYS_STATISTIC_

struct OneArrayTypeStatistic {
public:
  size_t reallocCountSuccess; // \ru кол-во успешных перераспределений памяти \en A number of successfully reallocations of the memory 
  size_t firstAlloc         ; // \ru кол-во первичных распределений \en the number of primary allocations 
  size_t lastAlloc          ; // \ru кол-во освобождений \en the number of releases 
  size_t realAllocIncremet  ; // \ru кол-во запросов на увеличение \en the number of requests for an increment 
  size_t realAllocDecremet  ; // \ru кол-во запросов на уменьшение \en the number of requests for a decrement 
  size_t fullLength         ; // \ru суммарный размер в байтах \en the total size in bites 
  size_t maxOneArrayLength  ; // \ru максимальный размер одного массива \en the minimal size of one array 
  size_t sumCurrLength      ; // \ru суммарный размер памяти во всех массивах этого типа в данный момент \en the total size of the memory in all arrays of this type at this moment 
  size_t maxOneTimeLength   ; // \ru максимальный одновременный размер памяти во всех массивах этого типа \en the maximum simultaneous size of the memory in all arrays of this type 
  size_t minDelta           ; // \ru минимальное приращение \en minimum increment 
  size_t maxDelta           ; // \ru максимальное приращение \en maximum increment 
public:
  OneArrayTypeStatistic() { Clear(); }
  void Clear() {
    reallocCountSuccess = 0;
    firstAlloc          = 0;
    lastAlloc           = 0;
    realAllocIncremet   = 0;
    realAllocDecremet   = 0;
    fullLength          = 0;
    maxOneArrayLength   = 0;
    sumCurrLength       = 0;
    maxOneTimeLength    = 0;
    minDelta            = SYS_MAX_T; // \ru минимальное приращение \en minimum increment 
    maxDelta            = 0;         // \ru максимальное приращение \en maximum increment 
  }
};

const size_t STAT_ARRAY_COUNT = 6;
static OneArrayTypeStatistic statisticArray[STAT_ARRAY_COUNT]
  = { OneArrayTypeStatistic(), OneArrayTypeStatistic(), OneArrayTypeStatistic(),
      OneArrayTypeStatistic(), OneArrayTypeStatistic(), OneArrayTypeStatistic() };

static size_t allReallocCount = 0;

//------------------------------------------------------------------------------
// \ru Уменьшение uint с проверкой \en A decrement of uint with the check 
// ---
inline void DecrementUint( size_t & val, size_t delta ) {
  val = (delta < val) ? (val - delta) : 0;
}

//------------------------------------------------------------------------------
/// \ru Статистика изменений размера массива. \en Statistics of array size changes.  \~ \ingroup Base_Tools
// arrayType : 
// \ru 0 - SArray (или наследники), \en 0 -SAray (or inheritors) 
// \ru 1 - RParray (или наследники), \en 1 -RPAray (or inheritors) 
// 2 - Array2,
// 3 - LiSArray,
// 4 - CcArray,
// \ru 5 - неопознанные (вообще-то, такого не должно быть) \en 5 - not defined (it should not happen) 
// ---
inline void ReallocArrayStatistic( void * oldParr, size_t oldSize, 
                                   void * newParr, size_t newSize, 
                                   uint arrayType ) 
{
  if ( oldParr || newSize ) {
    allReallocCount++;

    // \ru найдем статистическую запись про данный тип массива \en find a statistic record about the given type of array 
    size_t index = (size_t)arrayType;
    if ( index >= STAT_ARRAY_COUNT )
      index = STAT_ARRAY_COUNT - 1;
    OneArrayTypeStatistic & stat = statisticArray[index];

    if ( newSize > stat.maxOneArrayLength )
      stat.maxOneArrayLength = newSize;

    if ( !oldParr ) {                // \ru первичное распределение \en primary allocation 
      stat.firstAlloc++;
      stat.fullLength    += newSize; // \ru общее кол-во байт в этом типе массива \en the total number of bites in this type of an array 
      stat.sumCurrLength += newSize; // \ru суммарный размер памяти во всех массивах этого типа в данный момент \en the total size of the memory in all arrays of this type at this moment 
    }

    if ( oldParr && !newSize ) {     // \ru полное освобождение \en full release 
      stat.lastAlloc++;
      // \ru максимальный одновременный размер памяти во всех массивах этого типа \en the maximum simultaneous size of the memory in all arrays of this type 
      if ( stat.sumCurrLength > stat.maxOneTimeLength )
        stat.maxOneTimeLength = stat.sumCurrLength;
      // \ru суммарный размер памяти во всех массивах этого типа в данный момент \en the total size of the memory in all arrays of this type at this moment 
      ::DecrementUint( stat.sumCurrLength, oldSize );
    }

    if ( oldParr && newSize > oldSize ) { // \ru запрос на увеличение \en a request to increase 
      stat.realAllocIncremet++;
      size_t delta = newSize - oldSize;
      stat.fullLength    += delta; // \ru общее кол-во байт в этом типе массива \en the total number of bites in this type of an array 
      stat.sumCurrLength += delta; // \ru суммарный размер памяти во всех массивах этого типа в данный момент \en the total size of the memory in all arrays of this type at this moment 

      if ( delta < stat.minDelta )
        stat.minDelta = delta; // \ru минимальное приращение \en minimum increment 
      if ( delta > stat.minDelta )
        stat.maxDelta = delta; // \ru максимальное приращение \en maximum increment 
    }

    if ( oldParr && newSize && newSize < oldSize ) { // \ru запрос на уменьшение \en a request to decrease 
      stat.realAllocDecremet++;
      // \ru максимальный одновременный размер памяти во всех массивах этого типа \en the maximum simultaneous size of the memory in all arrays of this type 
      if ( stat.sumCurrLength > stat.maxOneTimeLength )
        stat.maxOneTimeLength = stat.sumCurrLength;
      // \ru суммарный размер памяти во всех массивах этого типа в данный момент \en the total size of the memory in all arrays of this type at this moment 
      ::DecrementUint( stat.sumCurrLength, oldSize - newSize );
    }

#ifdef USE_REALLOC_IN_ARRAYS
    if ( oldParr && oldParr == newParr && newSize != oldSize )
      stat.reallocCountSuccess++;
#endif // USE_REALLOC_IN_ARRAYS
  }
}


//------------------------------------------------------------------------------
/// \ru Отчет по статистике изменений размера массива. \en A report by the statistics of array size changes.  \~ \ingroup Base_Tools
// ---
inline void ReallocReport( bool clear, const char * title = NULL )
{
  std::string text( title );

  if ( text.length() > 0 )
    text.append( "\n" );

  char buf[256];
  ::sprintf( buf, "Общее кол-во realloc %d", ::LoUint32( allReallocCount ) );
  text.append( buf );

  for ( size_t i = 0; i < STAT_ARRAY_COUNT; i++ ) {
    OneArrayTypeStatistic & stat = statisticArray[i];

    // \ru если данных нет, то и писать про них не будем \en if there is no data then we will not write about it 
    if ( stat.firstAlloc || stat.lastAlloc || stat.realAllocIncremet || stat.realAllocDecremet ) {

      switch ( i ) {
        case 0 : text.append( "\n\n SArray  (или наследники)" );  break;
        case 1 : text.append( "\n\n RParray (или наследники)" );  break;
        case 2 : text.append( "\n\n Array2" );                    break;
        case 3 : text.append( "\n\n LiSArray (или наследники)" ); break;
        case 4 : text.append( "\n\n CcArray" );                   break;
        case 5 : text.append( "\n\n неопознанные" );              break;
      }

      ::sprintf( buf, "\n всего байт \t %d", ::LoUint32( stat.fullLength ) );
      text.append( buf );
      ::sprintf( buf, "\n макс.размер \t %d", ::LoUint32( stat.maxOneArrayLength ) );
      text.append( buf );
      ::sprintf( buf, "\n первичных \t %d", ::LoUint32( stat.firstAlloc ) );
      text.append( buf );
      ::sprintf( buf, "\n освобождений \t %d", ::LoUint32( stat.lastAlloc ) );
      text.append( buf );
      if ( stat.realAllocIncremet ) {
        ::sprintf( buf, "\n на увеличение \t %d", ::LoUint32( stat.realAllocIncremet ) );
        text.append( buf );
      }
      if ( stat.realAllocDecremet ) {
        ::sprintf( buf, "\n на уменьшение \t %d", ::LoUint32( stat.realAllocDecremet ) );
        text.append( buf );
      }
#ifdef USE_REALLOC_IN_ARRAYS
      if ( stat.reallocCountSuccess ) {
        ::sprintf( buf, "\n удачных realloc \t %d", ::LoUint32( stat.reallocCountSuccess ) );
        text.append( buf );
      }
#endif
      ::sprintf( buf, "\n max одновременно %d", ::LoUint32( stat.maxOneTimeLength ) );
      text.append( buf );
      if ( stat.realAllocIncremet ) {
        ::sprintf( buf, "\n Delta (min, max) \t %d, %d", ::LoUint32( stat.minDelta ), ::LoUint32( stat.maxDelta ) );
        text.append( buf );
      }
    }
  }

  {
    const char * outName = "C:\\Logs\\ADRAFT_TTEST.txt";
    std::ofstream out( outName, std::ios::out|std::ios::app );
    out << "\n Статистика использования памяти \n";
    //out << text;
    out << "\n";
  }

  if ( clear ) {
    // \ru очистить, чтобы в следующий раз цифры были новые, а не накопленные \en clear to renew numbers 
    allReallocCount = 0;
    for ( size_t i = 0; i < STAT_ARRAY_COUNT; i++ )
      statisticArray[i].Clear();
  }
}

#endif // __REALLOC_ARRAYS_STATISTIC_


//------------------------------------------------------------------------------
// \ru Использовать realloc для изменения размера массивов \en Use realloc to change arrays sizes 
// \ru (если не определено, то по-старому, через new и delete) \en (if it is not defined then use new and delete operators) 
//---
#ifdef USE_REALLOC_IN_ARRAYS

#ifdef C3D_DEBUG

#ifdef __MEMSET_USED_FREE_HEAP_HEAR__
//------------------------------------------------------------------------------
/// \ru Функция перезахватов памяти в массивах. \en Function of memory reallocation in arrays.  \~ \ingroup Base_Tools
// ---
inline void * ReallocArraySize( void * arr_parr, size_t newBytesCount, bool clear )
#else // __MEMSET_USED_FREE_HEAP_HEAR__
//------------------------------------------------------------------------------
/// \ru Функция перезахватов памяти в массивах. \en Function of memory reallocation in arrays.  \~ \ingroup Base_Tools
// ---
inline void * ReallocArraySize( void * arr_parr, size_t newBytesCount, bool )
#endif // __MEMSET_USED_FREE_HEAP_HEAR__
{
#ifdef __MEMSET_USED_FREE_HEAP_HEAR__
  if ( newBytesCount == 0 || clear ) {
    size_t arr_parr_size = ::_msize( arr_parr );
    C3D_ASSERT( arr_parr ? (arr_parr_size > 0 && arr_parr_size < 0xFFFFFFFF) : true ); // \ru OV - надо доработать для 64-бит \en OV - it should be adapted for the 64-bit version 
    if ( arr_parr_size )
      ::memset( arr_parr, 0xEE, arr_parr_size );
  }
#endif // __MEMSET_USED_FREE_HEAP_HEAR__

#if defined( _AFXDLL ) && defined( C3D_DEBUG )
  void * tmp_parr = _realloc_dbg( arr_parr, newBytesCount, _NORMAL_BLOCK, __FILE__, __LINE__ );
#else
  void * tmp_parr = ::realloc( arr_parr, newBytesCount );
#endif

  PRECONDITION( newBytesCount == 0 || tmp_parr != NULL ); // \ru проверка на нехватку памяти в массивах \en check the memory deficit in arrays  

#ifdef __MEMSET_USED_FREE_HEAP_HEAR__
  if ( clear ) {
    size_t tmp_parr_size = ::_msize( tmp_parr );
    C3D_ASSERT( tmp_parr ? (tmp_parr_size > 0 && tmp_parr_size < 0xFFFFFFFF) : true ); // \ru OV - надо доработать для 64-бит \en OV - it should be adapted for the 64-bit version 
    if ( tmp_parr_size )
      ::memset( tmp_parr, 0xEE, tmp_parr_size );
  }
#endif // __MEMSET_USED_FREE_HEAP_HEAR__

  return tmp_parr;
}

#define REALLOC_ARRAY_SIZE(p,s,c) ::ReallocArraySize((p),(s),(c))
#else // C3D_DEBUG
#define REALLOC_ARRAY_SIZE(p,s,c) ::realloc((p),(s))
#endif // C3D_DEBUG

#endif // USE_REALLOC_IN_ARRAYS


#endif  // __MEMORY_DEBUG_H