/*

 * 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/indexState.c#6 $

 */

#include "indexState.h"

#include "errors.h"

#include "indexComponent.h"

#include "indexLayout.h"

#include "logger.h"

#include "memoryAlloc.h"

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

int makeIndexState(IndexLayout   *layout,

                   unsigned int   numZones,

                   unsigned int   maxComponents,

                   IndexState   **statePtr)

{

  if (maxComponents == 0) {

    return logErrorWithStringError(

      UDS_INVALID_ARGUMENT, "cannot make index state with maxComponents 0");

  }

  IndexState *state = NULL;

  int result = ALLOCATE_EXTENDED(IndexState, maxComponents, IndexComponent *,

                                 "index state", &state);

  if (result != UDS_SUCCESS) {

    return result;

  }

  state->count     = 0;

  state->layout    = layout;

  state->length    = maxComponents;

  state->loadZones = 0;

  state->loadSlot  = UINT_MAX;

  state->saveSlot  = UINT_MAX;

  state->saving    = false;

  state->zoneCount = numZones;

  *statePtr = state;

  return UDS_SUCCESS;

}

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

void freeIndexState(IndexState **statePtr)

{

  IndexState *state = *statePtr;

  *statePtr = NULL;

  if (state != NULL) {

    unsigned int i;

    for (i = 0; i < state->count; ++i) {

      freeIndexComponent(&state->entries[i]);

    }

    FREE(state);

  }

}

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

/**

 * Add a component to the index state.

 *

 * @param state         The index state.

 * @param component     The index component.

 *

 * @return      UDS_SUCCESS or an error code.

 **/

static int addComponentToIndexState(IndexState     *state,

                                    IndexComponent *component)

{

  if (findIndexComponent(state, component->info) != NULL) {

    return logErrorWithStringError(

      UDS_INVALID_ARGUMENT, "cannot add state component %s: already present",

      component->info->name);

  }

  if (state->count >= state->length) {

    return logErrorWithStringError(

      UDS_RESOURCE_LIMIT_EXCEEDED,

      "cannot add state component %s, %u components already added",

      component->info->name, state->count);

  }

  state->entries[state->count] = component;

  ++state->count;

  return UDS_SUCCESS;

}

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

int addIndexStateComponent(IndexState               *state,

                           const IndexComponentInfo *info,

                           void                     *data,

                           void                     *context)

{

  IndexComponent *component = NULL;

  int result = makeIndexComponent(state, info, state->zoneCount, data, context,

                                  &component);

  if (result != UDS_SUCCESS) {

    return logErrorWithStringError(result,

                                   "cannot make region index component");

  }

  result = addComponentToIndexState(state, component);

  if (result != UDS_SUCCESS) {

    freeIndexComponent(&component);

    return result;

  }

  return UDS_SUCCESS;

}

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

IndexComponent *findIndexComponent(const IndexState         *state,

                                   const IndexComponentInfo *info)

{

  unsigned int i;

  for (i = 0; i < state->count; ++i) {

    IndexComponent *component = state->entries[i];

    if (info == component->info) {

      return component;

    }

  }

  return NULL;

}

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

static const char *indexSaveTypeName(IndexSaveType saveType)

{

  return saveType == IS_SAVE ? "save" : "checkpoint";

}

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

int loadIndexState(IndexState *state, bool *replayPtr)

{

  int result = findLatestIndexSaveSlot(state->layout, &state->loadZones,

                                       &state->loadSlot);

  if (result != UDS_SUCCESS) {

    return result;

  }

  bool replayRequired = false;

  unsigned int i;

  for (i = 0; i < state->count; ++i) {

    IndexComponent *component = state->entries[i];

    result = readIndexComponent(component);

    if (result != UDS_SUCCESS) {

      if (!missingIndexComponentRequiresReplay(component)) {

        state->loadZones = 0;

        state->loadSlot  = UINT_MAX;

        return logErrorWithStringError(result, "index component %s",

                                       indexComponentName(component));

      }

      replayRequired = true;

    }

  }

  state->loadZones = 0;

  state->loadSlot  = UINT_MAX;

  if (replayPtr != NULL) {

    *replayPtr = replayRequired;

  }

  return UDS_SUCCESS;

}

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

int prepareToSaveIndexState(IndexState *state, IndexSaveType saveType)

{

  if (state->saving) {

    return logErrorWithStringError(UDS_BAD_STATE,

                                   "already saving the index state");

  }

  int result = setupIndexSaveSlot(state->layout, state->zoneCount, saveType,

                                  &state->saveSlot);

  if (result != UDS_SUCCESS) {

    return logErrorWithStringError(result, "cannot prepare index %s",

                                   indexSaveTypeName(saveType));

  }

  return UDS_SUCCESS;

}

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

/**

 *  Complete the saving of an index state.

 *

 *  @param state  the index state

 *

 *  @return UDS_SUCCESS or an error code

 **/

static int completeIndexSaving(IndexState *state)

{

  state->saving = false;

  int result = commitIndexSave(state->layout, state->saveSlot);

  state->saveSlot = UINT_MAX;

  if (result != UDS_SUCCESS) {

    return logErrorWithStringError(result, "cannot commit index state");

  }

  return UDS_SUCCESS;

}

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

static int cleanupSave(IndexState *state)

{

  int result = cancelIndexSave(state->layout, state->saveSlot);

  state->saveSlot = UINT_MAX;

  if (result != UDS_SUCCESS) {

    return logErrorWithStringError(result, "cannot cancel index save");

  }

  return UDS_SUCCESS;

}

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

int saveIndexState(IndexState *state)

{

  int result = prepareToSaveIndexState(state, IS_SAVE);

  if (result != UDS_SUCCESS) {

    return result;

  }

unsigned int i;

  for (i = 0; i < state->count; ++i) {

    IndexComponent *component = state->entries[i];

    result = writeIndexComponent(component);

    if (result != UDS_SUCCESS) {

      cleanupSave(state);

      return result;

    }

  }

  return completeIndexSaving(state);

}

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

int writeIndexStateCheckpoint(IndexState *state)

{

  int result = prepareToSaveIndexState(state, IS_CHECKPOINT);

  if (result != UDS_SUCCESS) {

    return result;

  }

  unsigned int i;

  for (i = 0; i < state->count; ++i) {

    IndexComponent *component = state->entries[i];

    if (skipIndexComponentOnCheckpoint(component)) {

      continue;

    }

    result = writeIndexComponent(component);

    if (result != UDS_SUCCESS) {

      cleanupSave(state);

      return result;

    }

  }

  return completeIndexSaving(state);

}

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

int startIndexStateCheckpoint(IndexState *state)

{

  int result = prepareToSaveIndexState(state, IS_CHECKPOINT);

  if (result != UDS_SUCCESS) {

    return result;

  }

  state->saving = true;

  unsigned int i;

  for (i = 0; i < state->count; ++i) {

    IndexComponent *component = state->entries[i];

    if (skipIndexComponentOnCheckpoint(component)) {

      continue;

    }

    result = startIndexComponentIncrementalSave(component);

    if (result != UDS_SUCCESS) {

      abortIndexStateCheckpoint(state);

      return result;

    }

  }

  return result;

}

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

int performIndexStateCheckpointChapterSynchronizedSaves(IndexState *state)

{

  if (!state->saving) {

    return UDS_SUCCESS;

  }

  unsigned int i;

  for (i = 0; i < state->count; ++i) {

    IndexComponent *component = state->entries[i];

    if (skipIndexComponentOnCheckpoint(component) ||

        !deferIndexComponentCheckpointToChapterWriter(component)) {

      continue;

    }

    int result = performIndexComponentChapterWriterSave(component);

    if (result != UDS_SUCCESS) {

      return result;

    }

  }

  return UDS_SUCCESS;

}

/**

 *  Wrapper function to do a zone-based checkpoint operation.

 *

 *  @param [in]  state          the index state

 *  @param [in]  zone           the zone number

 *  @param [in]  compFunc       the index component function to use

 *  @param [out] completed      if non-NULL, where to save the completion status

 *

 *  @return UDS_SUCCESS or an error code

 *

 **/

static int doIndexStateCheckpointInZone(IndexState       *state,

                                        unsigned int      zone,

                                        int (*compFunc)(IndexComponent *,

                                                        unsigned int,

                                                        CompletionStatus *),

                                        CompletionStatus *completed)

{

  if (!state->saving) {

    if (completed != NULL) {

      *completed = CS_COMPLETED_PREVIOUSLY;

    }

    return UDS_SUCCESS;

  }

  CompletionStatus status = CS_COMPLETED_PREVIOUSLY;

  unsigned int i;

  for (i = 0; i < state->count; ++i) {

    IndexComponent *component = state->entries[i];

    if (skipIndexComponentOnCheckpoint(component)) {

      continue;

    }

    if (zone > 0 && !component->info->multiZone) {

      continue;

    }

    CompletionStatus componentStatus = CS_NOT_COMPLETED;

    int result = (*compFunc)(component, zone, &componentStatus);

    if (result != UDS_SUCCESS) {

      return result;

    }

    // compute rolling least status

    if (componentStatus < status) {

      status = componentStatus;

    }

  }

  if (completed != NULL) {

    *completed = status;

  }

  return UDS_SUCCESS;

}

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

int performIndexStateCheckpointInZone(IndexState       *state,

                                      unsigned int      zone,

                                      CompletionStatus *completed)

{

  return doIndexStateCheckpointInZone(state, zone,

                                      &performIndexComponentZoneSave,

                                      completed);

}

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

int finishIndexStateCheckpointInZone(IndexState       *state,

                                     unsigned int      zone,

                                     CompletionStatus *completed)

{

  return doIndexStateCheckpointInZone(state, zone,

                                      &finishIndexComponentZoneSave,

                                      completed);

}

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

int abortIndexStateCheckpointInZone(IndexState       *state,

                                    unsigned int      zone,

                                    CompletionStatus *completed)

{

  return doIndexStateCheckpointInZone(state, zone,

                                      &abortIndexComponentZoneSave, completed);

}

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

int finishIndexStateCheckpoint(IndexState *state)

{

  if (!state->saving) {

    return UDS_SUCCESS;

  }

  unsigned int i;

  for (i = 0; i < state->count; ++i) {

    IndexComponent *component = state->entries[i];

    if (skipIndexComponentOnCheckpoint(component)) {

      continue;

    }

    int result = finishIndexComponentIncrementalSave(component);

    if (result != UDS_SUCCESS) {

      abortIndexStateCheckpoint(state);

      return result;

    }

  }

  int result = completeIndexSaving(state);

  if (result != UDS_SUCCESS) {

    return result;

  }

  return UDS_SUCCESS;

}

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

int abortIndexStateCheckpoint(IndexState *state)

{

  if (!state->saving) {

    return logErrorWithStringError(UDS_BAD_STATE,

                                   "not saving the index state");

  }

  logError("aborting index state checkpoint");

  int result = UDS_SUCCESS;

  unsigned int i;

  for (i = 0; i < state->count; ++i) {

    IndexComponent *component = state->entries[i];

    if (skipIndexComponentOnCheckpoint(component)) {

      continue;

    }

    int tmp = abortIndexComponentIncrementalSave(component);

    if (result == UDS_SUCCESS) {

      result = tmp;

    }

  }

  cleanupSave(state);

  state->saving = false;

  return result;

}

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

int discardIndexStateData(IndexState *state)

{

  int result = discardIndexSaves(state->layout, true);

  state->saveSlot = UINT_MAX;

  if (result != UDS_SUCCESS) {

    return logErrorWithStringError(result,

                                   "%s: cannot destroy all index saves",

                                   __func__);

  }

  return UDS_SUCCESS;

}

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

int discardLastIndexStateSave(IndexState *state)

{

  int result = discardIndexSaves(state->layout, false);

  state->saveSlot = UINT_MAX;

  if (result != UDS_SUCCESS) {

    return logErrorWithStringError(result,

                                   "%s: cannot destroy latest index save",

                                   __func__);

  }

  return UDS_SUCCESS;

}

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

Buffer *getStateIndexStateBuffer(IndexState *state, IOAccessMode mode)

{

  unsigned int slot = mode == IO_READ ? state->loadSlot : state->saveSlot;

  return getIndexStateBuffer(state->layout, slot);

}

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

int openStateBufferedReader(IndexState      *state,

                            RegionKind       kind,

                            unsigned int     zone,

                            BufferedReader **readerPtr)

{

  return openIndexBufferedReader(state->layout, state->loadSlot, kind, zone,

                                 readerPtr);

}

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

int openStateBufferedWriter(IndexState      *state,

                            RegionKind       kind,

                            unsigned int     zone,

                            BufferedWriter **writerPtr)

{

  return openIndexBufferedWriter(state->layout, state->saveSlot, kind, zone,

                                 writerPtr);

}