/*
 * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
 *
 * This program is free software: you can use, redistribute, and/or modify
 * it under the terms of the GNU Affero General Public License, version 3
 * or later ("AGPL"), as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

#define _DEFAULT_SOURCE
#include "osMemPool.h"
#include "tmempoolInt.h"
#include "tlog.h"
#include "tutil.h"

void* mpDirectAlloc(SMemPool* pPool, SMPJob* pJob, int64_t size) {
  MP_CHECK_QUOTA(pPool, pJob, size);
  
  return taosMemMalloc(size);
}


void* mpDirectAlignAlloc(SMemPool* pPool, SMPJob* pJob, uint32_t alignment, int64_t size) {
  MP_CHECK_QUOTA(pPool, pJob, size);
  
  return taosMemMallocAlign(alignment, size);
}


void* mpDirectCalloc(SMemPool* pPool, SMPJob* pJob, int64_t num, int64_t size) {
  int64_t tSize = num * size;
  MP_CHECK_QUOTA(pPool, pJob, tSize);

  return taosMemCalloc(num, size);
}

void mpDirectFree(SMemPool* pPool, SMPJob* pJob, void *ptr) {
  if (*pPool->cfg.jobQuota > 0) {
    (void)atomic_sub_fetch_64(&pJob->job.allocMemSize, taosMemSize(ptr));
  }
  taosMemFree(ptr);
}


void* mpDirectRealloc(SMemPool* pPool, SMPJob* pJob, void* ptr, int64_t size) {
  int32_t code = TSDB_CODE_SUCCESS;

  if (NULL == ptr) {
    return mpDirectAlloc(pPool, pJob, size);
  }

  if (0 == size) {
    mpDirectFree(pPool, pJob, ptr);
    return NULL;
  }

  int64_t oSize = taosMemSize(ptr);

  MP_CHECK_QUOTA(pPool, pJob, size - oSize);

  return taosMemRealloc(ptr, size);
}

void* mpDirectStrdup(SMemPool* pPool, SMPJob* pJob, const void* ptr) {
  if (NULL == ptr) {
    return NULL;
  }
  
  int64_t oSize = strlen(ptr);
  MP_CHECK_QUOTA(pPool, pJob, oSize);
  
  return taosStrdupi(ptr);
}

void* mpDirectStrndup(SMemPool* pPool, SMPJob* pJob, const void* ptr, int64_t size) {
  if (NULL == ptr) {
    return NULL;
  }
  
  int64_t oSize = strlen(ptr);
  MP_CHECK_QUOTA(pPool, pJob, TMIN(oSize, size) + 1);
  
  return taosStrndupi(ptr, size);
}




int64_t mpDirectGetMemSize(SMemPool* pPool, SMPSession* pSession, void *ptr) {
  return taosMemSize(ptr);
}

void mpDirectFullFree(SMemPool* pPool, SMPSession* pSession, void *ptr, int64_t* origSize) {
  int64_t oSize = taosMemSize(ptr);
  if (origSize) {
    *origSize = oSize;
  }
  
  MP_LOCK(MP_READ, &pPool->cfgLock); // tmp test

  taosMemFree(ptr);

  if (NULL != pSession) {
    (void)atomic_sub_fetch_64(&pSession->allocMemSize, oSize);
    (void)atomic_sub_fetch_64(&pSession->pJob->job.allocMemSize, oSize);
  }
  
  (void)atomic_sub_fetch_64(&pPool->allocMemSize, oSize);

  MP_UNLOCK(MP_READ, &pPool->cfgLock);
}



int32_t mpDirectFullAlloc(SMemPool* pPool, SMPSession* pSession, int64_t* size, uint32_t alignment, void** ppRes) {
  int32_t code = TSDB_CODE_SUCCESS;
  void* res = NULL;
  int64_t nSize = *size;
  
  MP_LOCK(MP_READ, &pPool->cfgLock);

  MP_ERR_JRET(mpChkFullQuota(pPool, pSession, *size));
  
  res = alignment ? taosMemMallocAlign(alignment, *size) : taosMemMalloc(*size);
  if (NULL != res) {
    nSize = taosMemSize(res);
    mpUpdateAllocSize(pPool, pSession, nSize, nSize - *size);
  } else {
    if (NULL != pSession) {
      (void)atomic_sub_fetch_64(&pSession->pJob->job.allocMemSize, *size);
    }
    
    (void)atomic_sub_fetch_64(&pPool->allocMemSize, *size);
    
    uError("malloc %" PRId64 " alignment %d failed, code: 0x%x", *size, alignment, terrno);

    code = terrno;
  }

_return:

  MP_UNLOCK(MP_READ, &pPool->cfgLock);
  
  *ppRes = res;
  *size = nSize;
  
  MP_RET(code);
}

int32_t mpDirectFullRealloc(SMemPool* pPool, SMPSession* pSession, void **pPtr, int64_t* size, int64_t* origSize) {
  int32_t code = TSDB_CODE_SUCCESS;
  int64_t nSize = *size;

  MP_LOCK(MP_READ, &pPool->cfgLock);

  MP_ERR_JRET(mpChkFullQuota(pPool, pSession, *size - *origSize));
  
  *pPtr = taosMemRealloc(*pPtr, *size);
  if (NULL != *pPtr) {
    nSize = taosMemSize(*pPtr);
    mpUpdateAllocSize(pPool, pSession, nSize - *origSize, nSize - *size + *origSize);
  } else {
    MP_ERR_JRET(terrno);
  }

_return:

  MP_UNLOCK(MP_READ, &pPool->cfgLock);

  if (code) {
    mpDirectFullFree(pPool, pSession, *pPtr, origSize);
    *pPtr = NULL;
  }

  *size = nSize;
  
  return TSDB_CODE_SUCCESS;
}

int32_t mpDirectTrim(SMemPool* pPool, SMPSession* pSession, int32_t size, bool* trimed) {
  return taosMemTrim(size, trimed);
}