/*
 * Copyright (c) 2020 Red Hat, Inc.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 * 
 * 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.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA. 
 *
 * $Id: //eng/uds-releases/jasper/src/uds/masterIndexOps.c#4 $
 */
#include "masterIndexOps.h"

#include "compiler.h"
#include "errors.h"
#include "indexComponent.h"
#include "logger.h"
#include "masterIndex005.h"
#include "masterIndex006.h"
#include "memoryAlloc.h"
#include "permassert.h"
#include "uds.h"
#include "zone.h"

/**********************************************************************/
static INLINE bool usesSparse(const Configuration *config)
{
  return config->geometry->sparseChaptersPerVolume > 0;
}

/**********************************************************************/
void getMasterIndexCombinedStats(const MasterIndex *masterIndex,
                                 MasterIndexStats *stats)
{
  MasterIndexStats dense, sparse;
  getMasterIndexStats(masterIndex, &dense, &sparse);
  stats->memoryAllocated = dense.memoryAllocated + sparse.memoryAllocated;
  stats->rebalanceTime   = dense.rebalanceTime   + sparse.rebalanceTime;
  stats->rebalanceCount  = dense.rebalanceCount  + sparse.rebalanceCount;
  stats->recordCount     = dense.recordCount     + sparse.recordCount;
  stats->collisionCount  = dense.collisionCount  + sparse.collisionCount;
  stats->discardCount    = dense.discardCount    + sparse.discardCount;
  stats->overflowCount   = dense.overflowCount   + sparse.overflowCount;
  stats->numLists        = dense.numLists        + sparse.numLists;
  stats->earlyFlushes    = dense.earlyFlushes    + sparse.earlyFlushes;
}

/**********************************************************************/
int makeMasterIndex(const Configuration  *config, unsigned int numZones,
                    uint64_t volumeNonce, MasterIndex **masterIndex)
{
  if (usesSparse(config)) {
    return makeMasterIndex006(config, numZones, volumeNonce, masterIndex);
  } else {
    return makeMasterIndex005(config, numZones, volumeNonce, masterIndex);
  }
}

/**********************************************************************/
int computeMasterIndexSaveBlocks(const Configuration *config,
                                 size_t blockSize, uint64_t *blockCount)
{
  size_t numBytes;
  int result = (usesSparse(config)
                ? computeMasterIndexSaveBytes006(config, &numBytes)
                : computeMasterIndexSaveBytes005(config, &numBytes));
  if (result != UDS_SUCCESS) {
    return result;
  }
  numBytes += sizeof(DeltaListSaveInfo);
  *blockCount = (numBytes + blockSize - 1) / blockSize + MAX_ZONES;
  return UDS_SUCCESS;
}

/**********************************************************************/
static int readMasterIndex(ReadPortal *portal)
{
  MasterIndex *masterIndex = indexComponentContext(portal->component);
  unsigned int numZones = portal->zones;
  if (numZones > MAX_ZONES) {
    return logErrorWithStringError(UDS_BAD_STATE,
                                   "zone count %u must not exceed MAX_ZONES",
                                   numZones);
  }

  BufferedReader *readers[MAX_ZONES];
  unsigned int z;
  for (z = 0; z < numZones; ++z) {
    int result = getBufferedReaderForPortal(portal, z, &readers[z]);
    if (result != UDS_SUCCESS) {
      return logErrorWithStringError(result,
                                     "cannot read component for zone %u", z);
    }
  }
  return restoreMasterIndex(readers, numZones, masterIndex);
}

/**********************************************************************/
static int writeMasterIndex(IndexComponent           *component,
                            BufferedWriter           *writer,
                            unsigned int              zone,
                            IncrementalWriterCommand  command,
                            bool                     *completed)
{
  MasterIndex *masterIndex = indexComponentContext(component);
  bool isComplete = false;

  int result = UDS_SUCCESS;

  switch (command) {
    case IWC_START:
      result = startSavingMasterIndex(masterIndex, zone, writer);
      isComplete = result != UDS_SUCCESS;
      break;
    case IWC_CONTINUE:
      isComplete = isSavingMasterIndexDone(masterIndex, zone);
      break;
    case IWC_FINISH:
      result = finishSavingMasterIndex(masterIndex, zone);
      if (result == UDS_SUCCESS) {
        result = writeGuardDeltaList(writer);
      }
      isComplete = true;
      break;
    case IWC_ABORT:
      result = abortSavingMasterIndex(masterIndex, zone);
      isComplete = true;
      break;
    default:
      result = logWarningWithStringError(UDS_INVALID_ARGUMENT,
                                         "Invalid writer command");
      break;
  }
  if (completed != NULL) {
    *completed = isComplete;
  }
  return result;
}

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

static const IndexComponentInfo MASTER_INDEX_INFO_DATA = {
  .kind        = RL_KIND_MASTER_INDEX,
  .name        = "master index",
  .saveOnly    = false,
  .chapterSync = false,
  .multiZone   = true,
  .ioStorage   = true,
  .loader      = readMasterIndex,
  .saver       = NULL,
  .incremental = writeMasterIndex,
};
const IndexComponentInfo *const MASTER_INDEX_INFO = &MASTER_INDEX_INFO_DATA;

/**********************************************************************/
static int restoreMasterIndexBody(BufferedReader **bufferedReaders,
                                  unsigned int     numReaders,
                                  MasterIndex     *masterIndex,
                                  byte dlData[DELTA_LIST_MAX_BYTE_COUNT])
{
  // Start by reading the "header" section of the stream
  int result = startRestoringMasterIndex(masterIndex, bufferedReaders,
                                         numReaders);
  if (result != UDS_SUCCESS) {
    return result;
  }
  // Loop to read the delta lists, stopping when they have all been processed.
  unsigned int z;
  for (z = 0; z < numReaders; z++) {
    for (;;) {
      DeltaListSaveInfo dlsi;
      result = readSavedDeltaList(&dlsi, dlData, bufferedReaders[z]);
      if (result == UDS_END_OF_FILE) {
        break;
      } else if (result != UDS_SUCCESS) {
        abortRestoringMasterIndex(masterIndex);
        return result;
      }
      result = restoreDeltaListToMasterIndex(masterIndex, &dlsi, dlData);
      if (result != UDS_SUCCESS) {
        abortRestoringMasterIndex(masterIndex);
        return result;
      }
    }
  }
  if (!isRestoringMasterIndexDone(masterIndex)) {
    abortRestoringMasterIndex(masterIndex);
    return logWarningWithStringError(UDS_CORRUPT_COMPONENT,
                                     "incomplete delta list data");
  }
  return UDS_SUCCESS;
}

/**********************************************************************/
int restoreMasterIndex(BufferedReader **bufferedReaders,
                       unsigned int     numReaders,
                       MasterIndex     *masterIndex)
{
  byte *dlData;
  int result = ALLOCATE(DELTA_LIST_MAX_BYTE_COUNT, byte, __func__, &dlData);
  if (result != UDS_SUCCESS) {
    return result;
  }
  result = restoreMasterIndexBody(bufferedReaders, numReaders, masterIndex,
                                  dlData);
  FREE(dlData);
  return result;
}