/*

 * 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/indexComponent.c#8 $

 */

#include "indexComponent.h"

#include "compiler.h"

#include "errors.h"

#include "indexLayout.h"

#include "indexState.h"

#include "logger.h"

#include "memoryAlloc.h"

#include "permassert.h"

#include "typeDefs.h"

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

int makeIndexComponent(IndexState                *state,

                       const IndexComponentInfo  *info,

                       unsigned int               zoneCount,

                       void                      *data,

                       void                      *context,

                       IndexComponent           **componentPtr)

{

  if ((info == NULL) || (info->name == NULL)) {

    return logErrorWithStringError(UDS_INVALID_ARGUMENT,

                                   "invalid component or directory specified");

  }

  if (info->loader == NULL) {

    return logErrorWithStringError(UDS_INVALID_ARGUMENT,

                                   "no .loader function specified "

                                   "for component %s",

                                   info->name);

  }

  if ((info->saver == NULL) && (info->incremental == NULL)) {

    return logErrorWithStringError(UDS_INVALID_ARGUMENT,

                                   "neither .saver function nor .incremental "

                                   "function specified for component %s",

                                   info->name);

  }

  IndexComponent *component = NULL;

  int result = ALLOCATE(1, IndexComponent, "index component", &component);

  if (result != UDS_SUCCESS) {

    return result;

  }

  component->componentData = data;

  component->context       = context;

  component->info          = info;

  component->numZones      = info->multiZone ? zoneCount : 1;

  component->state         = state;

  component->writeZones    = NULL;

  *componentPtr = component;

  return UDS_SUCCESS;

}

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

static void freeWriteZones(IndexComponent *component)

{

  if (component->writeZones != NULL) {

    unsigned int z;

    for (z = 0; z < component->numZones; ++z) {

      WriteZone *wz = component->writeZones[z];

      if (wz == NULL) {

        continue;

      }

      freeBufferedWriter(wz->writer);

      FREE(wz);

    }

    FREE(component->writeZones);

    component->writeZones = NULL;

  }

}

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

void freeIndexComponent(IndexComponent **componentPtr)

{

  if (componentPtr == NULL) {

    return;

  }

  IndexComponent *component = *componentPtr;

  if (component == NULL) {

    return;

  }

  *componentPtr = NULL;

  freeWriteZones(component);

  FREE(component);

}

/**

 * Destroy, deallocate, and expunge a read portal.

 *

 * @param readPortal     the readzone array

 **/

static void freeReadPortal(ReadPortal *readPortal)

{

  if (readPortal == NULL) {

    return;

  }

  unsigned int z;

  for (z = 0; z < readPortal->zones; ++z) {

    if (readPortal->readers[z] != NULL) {

      freeBufferedReader(readPortal->readers[z]);

    }

  }

  FREE(readPortal->readers);

  FREE(readPortal);

}

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

int getBufferedReaderForPortal(ReadPortal      *portal,

                               unsigned int     part,

                               BufferedReader **readerPtr)

{

  if (part >= portal->zones) {

    return logErrorWithStringError(UDS_INVALID_ARGUMENT,

                                   "%s: cannot access zone %u of %u",

                                   __func__, part, portal->zones);

  }

  IndexComponent *component = portal->component;

  if (component->info->ioStorage && (portal->readers[part] == NULL)) {

    int result = openStateBufferedReader(component->state,

                                         component->info->kind, part,

                                         &portal->readers[part]);

    if (result != UDS_SUCCESS) {

      return logErrorWithStringError(result,

                                     "%s: cannot make buffered reader "

                                     "for zone %u", __func__, part);

    }

  }

  *readerPtr = portal->readers[part];

  return UDS_SUCCESS;

}

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

int readIndexComponent(IndexComponent *component)

{

  ReadPortal *portal;

  int result = ALLOCATE(1, ReadPortal, "index component read portal", &portal);

  if (result != UDS_SUCCESS) {

    return result;

  }

  int readZones = component->state->loadZones;

  result = ALLOCATE(readZones, BufferedReader *, "read zone buffered readers",

                    &portal->readers);

  if (result != UDS_SUCCESS) {

    FREE(portal);

    return result;

  }

  portal->component = component;

  portal->zones = readZones;

  result = (*component->info->loader)(portal);

  freeReadPortal(portal);

  return result;

}

/**

 * Determine the writeZone structure for the specified component and zone.

 *

 * @param [in]  component      the index component

 * @param [in]  zone           the zone number

 * @param [out] writeZonePtr   the resulting write zone instance

 *

 * @return UDS_SUCCESS or an error code

 **/

static int resolveWriteZone(const IndexComponent  *component,

                            unsigned int           zone,

                            WriteZone            **writeZonePtr)

{

  int result = ASSERT(writeZonePtr != NULL,

                      "output parameter is null");

  if (result != UDS_SUCCESS) {

    return result;

  }

  if (component->writeZones == NULL) {

    return logErrorWithStringError(UDS_BAD_STATE,

                                   "cannot resolve index component write zone:"

                                   " not allocated");

  }

  if (zone >= component->numZones) {

    return logErrorWithStringError(UDS_INVALID_ARGUMENT,

                                   "cannot resolve index component write zone:"

                                   " zone out of range");

  }

  *writeZonePtr = component->writeZones[zone];

  return UDS_SUCCESS;

}

/**

 * Non-incremental save function used to emulate a regular save

 * using an incremental save function as a basis.

 *

 * @param component    the index component

 * @param writer       the buffered writer

 * @param zone         the zone number

 *

 * @return UDS_SUCCESS or an error code

 **/

static int indexComponentSaverIncrementalWrapper(IndexComponent *component,

                                                 BufferedWriter *writer,

                                                 unsigned int    zone)

{

  IncrementalWriter incrFunc  = component->info->incremental;

  bool              completed = false;

  int result = (*incrFunc)(component, writer, zone, IWC_START, &completed);

  if (result != UDS_SUCCESS) {

    return result;

  }

  if (!completed) {

    result = (*incrFunc)(component, writer, zone, IWC_FINISH, &completed);

    if (result != UDS_SUCCESS) {

      return result;

    }

  }

  result = flushBufferedWriter(writer);

  if (result != UDS_SUCCESS) {

    return result;

  }

  return UDS_SUCCESS;

}

/**

 * Specify that writing to a specific zone file has finished.

 *

 * If a syncer has been registered with the index component, the file

 * descriptor will be enqueued upon it for fsyncing and closing.

 * If not, or if the enqueue fails, the file will be fsynced and closed

 * immediately.

 *

 * @param writeZone    the index component write zone

 *

 * @return UDS_SUCCESS or an error code

 **/

static int doneWithZone(WriteZone *writeZone)

{

  const IndexComponent *component = writeZone->component;

  if (writeZone->writer != NULL) {

    int result = flushBufferedWriter(writeZone->writer);

    if (result != UDS_SUCCESS) {

      return logErrorWithStringError(result,

                                     "cannot flush buffered writer for "

                                     "%s component (zone %u)",

                                     component->info->name, writeZone->zone);

    }

  }

  return UDS_SUCCESS;

}

/**

 * Construct the array of WriteZone instances for this component.

 *

 * @param component    the index component

 *

 * @return UDS_SUCCESS or an error code

 *

 * If this is a multizone component, each zone will be fully defined,

 * otherwise zone 0 stands in for the single state file.

 **/

static int makeWriteZones(IndexComponent *component)

{

  unsigned int z;

  if (component->writeZones != NULL) {

    // just reinitialize states

    for (z = 0; z < component->numZones; ++z) {

      WriteZone *wz = component->writeZones[z];

      wz->phase = IWC_IDLE;

    }

    return UDS_SUCCESS;

  }

  int result = ALLOCATE(component->numZones, WriteZone *,

                        "index component write zones", &component->writeZones);

  if (result != UDS_SUCCESS) {

    return result;

  }

  for (z = 0; z < component->numZones; ++z) {

    result = ALLOCATE(1, WriteZone, "plain write zone",

                      &component->writeZones[z]);

    if (result != UDS_SUCCESS) {

      freeWriteZones(component);

      return result;

    }

    *component->writeZones[z] = (WriteZone) {

      .component = component,

      .phase     = IWC_IDLE,

      .zone      = z,

    };

  }

  return UDS_SUCCESS;

}

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

static int openBufferedWriters(IndexComponent *component)

{

  int result = UDS_SUCCESS;

  WriteZone **wzp;

  for (wzp = component->writeZones;

       wzp < component->writeZones + component->numZones;

       ++wzp) {

    WriteZone *wz = *wzp;

    wz->phase = IWC_START;

    result = ASSERT(wz->writer == NULL, "write zone writer already exists");

    if (result != UDS_SUCCESS) {

      return result;

    }

    if (component->info->ioStorage) {

      int result = openStateBufferedWriter(component->state,

                                           component->info->kind, wz->zone,

                                           &wz->writer);

      if (result != UDS_SUCCESS) {

        return result;

      }

    }

  }

  return UDS_SUCCESS;

}

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

static int startIndexComponentSave(IndexComponent *component)

{

  int result = makeWriteZones(component);

  if (result != UDS_SUCCESS) {

    return result;

  }

  result = openBufferedWriters(component);

  if (result != UDS_SUCCESS) {

    return result;

  }

  return UDS_SUCCESS;

}

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

int startIndexComponentIncrementalSave(IndexComponent *component)

{

  return startIndexComponentSave(component);

}

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

int writeIndexComponent(IndexComponent *component)

{

  Saver saver = component->info->saver;

  if ((saver == NULL) && (component->info->incremental != NULL)) {

    saver = indexComponentSaverIncrementalWrapper;

  }

  int result = startIndexComponentSave(component);

  if (result != UDS_SUCCESS) {

    return result;

  }

  unsigned int z;

  for (z = 0; z < component->numZones; ++z) {

    WriteZone *writeZone = component->writeZones[z];

    result = (*saver)(component, writeZone->writer, z);

    if (result != UDS_SUCCESS) {

      break;

    }

    result = doneWithZone(writeZone);

    if (result != UDS_SUCCESS) {

      break;

    }

    freeBufferedWriter(writeZone->writer);

    writeZone->writer = NULL;

  }

  if (result != UDS_SUCCESS) {

    freeWriteZones(component);

    return logErrorWithStringError(result, "index component write failed");

  }

  return UDS_SUCCESS;

}

/**

 * Close a specific buffered writer in a component write zone.

 *

 * @param writeZone    the write zone

 *

 * @return UDS_SUCCESS or an error code

 *

 * @note closing a buffered writer causes its file descriptor to be

 *       passed to doneWithZone

 **/

static int closeBufferedWriter(WriteZone *writeZone)

{

  if (writeZone->writer == NULL) {

    return UDS_SUCCESS;

  }

  int result = doneWithZone(writeZone);

  freeBufferedWriter(writeZone->writer);

  writeZone->writer = NULL;

  return result;

}

/**

 * Faux incremental saver function for index components which only define

 * a simple saver.  Conforms to IncrementalWriter signature.

 *

 * @param [in]  component      the index component

 * @param [in]  writer         the buffered writer that does the output

 * @param [in]  zone           the zone number

 * @param [in]  command        the incremental writer command

 * @param [out] completed      if non-NULL, set to whether the save is complete

 *

 * @return UDS_SUCCESS or an error code

 *

 * @note This wrapper always calls the non-incremental saver when

 *       the IWC_START command is issued, and always reports that

 *       the save is complete unless the saver failed.

 **/

static int wrapSaverAsIncremental(IndexComponent           *component,

                                  BufferedWriter           *writer,

                                  unsigned int              zone,

                                  IncrementalWriterCommand  command,

                                  bool                     *completed)

{

  int result = UDS_SUCCESS;

  if ((command >= IWC_START) && (command <= IWC_FINISH)) {

    result = (*component->info->saver)(component, writer, zone);

    if ((result == UDS_SUCCESS) && (writer != NULL)) {

      noteBufferedWriterUsed(writer);

    }

  }

  if ((result == UDS_SUCCESS) && (completed != NULL)) {

    *completed = true;

  }

  return result;

}

/**

 * Return the appropriate incremental writer function depending on

 * the component's type and whether this is the first zone.

 *

 * @param component    the index component

 *

 * @return the correct IncrementalWriter function to use, or

 *         NULL signifying no progress can be made at this time.

 **/

static IncrementalWriter getIncrementalWriter(IndexComponent *component)

{

  IncrementalWriter incrFunc = component->info->incremental;

  if (incrFunc == NULL) {

    incrFunc = &wrapSaverAsIncremental;

  }

  return incrFunc;

}

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

int performIndexComponentZoneSave(IndexComponent   *component,

                                  unsigned int      zone,

                                  CompletionStatus *completed)

{

  CompletionStatus comp = CS_NOT_COMPLETED;

  WriteZone *wz = NULL;

  int result = resolveWriteZone(component, zone, &wz;;

  if (result != UDS_SUCCESS) {

    return result;

  }

  if (wz->phase == IWC_IDLE) {

    comp = CS_COMPLETED_PREVIOUSLY;

  } else if (wz->phase == IWC_DONE) {

    comp = CS_JUST_COMPLETED;

    wz->phase = IWC_IDLE;

  } else if (!component->info->chapterSync) {

    bool done = false;

    IncrementalWriter incrFunc = getIncrementalWriter(component);

    int result = (*incrFunc)(component, wz->writer, zone, wz->phase, &done);

    if (result != UDS_SUCCESS) {

      if (wz->phase == IWC_ABORT) {

        wz->phase = IWC_IDLE;

      } else {

        wz->phase = IWC_ABORT;

      }

      return result;

    }

    if (done) {

      comp = CS_JUST_COMPLETED;

      wz->phase = IWC_IDLE;

    } else if (wz->phase == IWC_START) {

      wz->phase = IWC_CONTINUE;

    }

  }

  if (completed != NULL) {

    *completed = comp;

  }

  return UDS_SUCCESS;

}

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

int performIndexComponentChapterWriterSave(IndexComponent *component)

{

  WriteZone *wz = NULL;

  int result = resolveWriteZone(component, 0, &wz;;

  if (result != UDS_SUCCESS) {

    return result;

  }

  if ((wz->phase != IWC_IDLE) && (wz->phase != IWC_DONE)) {

    bool done = false;

    IncrementalWriter incrFunc = getIncrementalWriter(component);

    int result = ASSERT(incrFunc != NULL, "no writer function");

    if (result != UDS_SUCCESS) {

      return result;

    }

    result = (*incrFunc)(component, wz->writer, 0, wz->phase, &done);

    if (result != UDS_SUCCESS) {

      if (wz->phase == IWC_ABORT) {

        wz->phase = IWC_IDLE;

      } else {

        wz->phase = IWC_ABORT;

      }

      return result;

    }

    if (done) {

      wz->phase = IWC_DONE;

    } else if (wz->phase == IWC_START) {

      wz->phase = IWC_CONTINUE;

    }

  }

  return UDS_SUCCESS;

}

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

int finishIndexComponentZoneSave(IndexComponent   *component,

                                 unsigned int      zone,

                                 CompletionStatus *completed)

{

  WriteZone *wz = NULL;

  int result = resolveWriteZone(component, zone, &wz;;

  if (result != UDS_SUCCESS) {

    return result;

  }

  CompletionStatus comp;

  switch (wz->phase) {

    case IWC_IDLE:

      comp = CS_COMPLETED_PREVIOUSLY;

      break;

    case IWC_DONE:

      comp = CS_JUST_COMPLETED;

      break;

    default:

      comp = CS_NOT_COMPLETED;

  }

  IncrementalWriter incrFunc = getIncrementalWriter(component);

  if ((wz->phase >= IWC_START) && (wz->phase < IWC_ABORT)) {

    bool done = false;

    int result = (*incrFunc)(component, wz->writer, zone, IWC_FINISH, &done);

    if (result != UDS_SUCCESS) {

      wz->phase = IWC_ABORT;

      return result;

    }

    if (!done) {

      logWarning("finish incremental save did not complete for %s zone %u",

                 component->info->name, zone);

      return UDS_CHECKPOINT_INCOMPLETE;

    }

    wz->phase = IWC_IDLE;

    comp = CS_JUST_COMPLETED;

  }

  if (completed != NULL) {

    *completed = comp;

  }

  return UDS_SUCCESS;

}

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

int finishIndexComponentIncrementalSave(IndexComponent *component)

{

  unsigned int zone;

  for (zone = 0; zone < component->numZones; ++zone) {

    WriteZone *wz = component->writeZones[zone];

    IncrementalWriter incrFunc = getIncrementalWriter(component);

    if ((wz->phase != IWC_IDLE) && (wz->phase != IWC_DONE)) {

      // Note: this is only safe if no other threads are currently processing

      // this particular index

      bool done = false;

      int result = (*incrFunc)(component, wz->writer, zone, IWC_FINISH, &done);

      if (result != UDS_SUCCESS) {

        return result;

      }

      if (!done) {

        logWarning("finishing incremental save did not complete for %s zone %u",

                   component->info->name, zone);

        return UDS_UNEXPECTED_RESULT;

      }

      wz->phase = IWC_IDLE;

    }

    if ((wz->writer != NULL) && !wasBufferedWriterUsed(wz->writer)) {

      return logErrorWithStringError(UDS_CHECKPOINT_INCOMPLETE,

                                     "component %s zone %u did not get written",

                                     component->info->name, zone);

    }

    int result = closeBufferedWriter(wz);

    if (result != UDS_SUCCESS) {

      return result;

    }

  }

  return UDS_SUCCESS;

}

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

int abortIndexComponentZoneSave(IndexComponent   *component,

                                unsigned int      zone,

                                CompletionStatus *status)

{

  WriteZone *wz = NULL;

  int result = resolveWriteZone(component, zone, &wz;;

  if (result != UDS_SUCCESS) {

    return result;

  }

  CompletionStatus comp = CS_COMPLETED_PREVIOUSLY;

  IncrementalWriter incrFunc = getIncrementalWriter(component);

  if ((wz->phase != IWC_IDLE) && (wz->phase != IWC_DONE)) {

    result = (*incrFunc)(component, wz->writer, zone, IWC_ABORT, NULL);

    wz->phase = IWC_IDLE;

    if (result != UDS_SUCCESS) {

      return result;

    }

    comp = CS_JUST_COMPLETED;

  }

  if (status != NULL) {

    *status = comp;

  }

  return UDS_SUCCESS;

}

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

int abortIndexComponentIncrementalSave(IndexComponent *component)

{

  int result = UDS_SUCCESS;

  unsigned int zone;

  for (zone = 0; zone < component->numZones; ++zone) {

    WriteZone *wz = component->writeZones[zone];

    IncrementalWriter incrFunc = getIncrementalWriter(component);

    if ((wz->phase != IWC_IDLE) && (wz->phase != IWC_DONE)) {

      // Note: this is only safe if no other threads are currently processing

      // this particular index

      result = (*incrFunc)(component, wz->writer, zone, IWC_ABORT, NULL);

      wz->phase = IWC_IDLE;

      if (result != UDS_SUCCESS) {

        return result;

      }

    }

    int result = closeBufferedWriter(wz);

    if (result != UDS_SUCCESS) {

      return result;

    }

  }

  return UDS_SUCCESS;

}

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

int discardIndexComponent(IndexComponent *component)

{

  if (!component->info->ioStorage) {

    return UDS_INVALID_ARGUMENT;

  }

  unsigned int numZones = 0;

  unsigned int saveSlot = 0;

  int result = findLatestIndexSaveSlot(component->state->layout, &numZones,

                                       &saveSlot);

  if (result != UDS_SUCCESS) {

    return result;

  }

  unsigned int oldSaveSlot = component->state->saveSlot;

  component->state->saveSlot = saveSlot;

  unsigned int z;

  for (z = 0; z < numZones; ++z) {

    BufferedWriter *writer;

    int result = openStateBufferedWriter(component->state,

                                         component->info->kind, z, &writer);

    if (result != UDS_SUCCESS) {

      break;

    }

    result = writeZerosToBufferedWriter(writer, UDS_BLOCK_SIZE);

    if (result != UDS_SUCCESS) {

      break;

    }

    result = flushBufferedWriter(writer);

    if (result != UDS_SUCCESS) {

      break;

    }

    freeBufferedWriter(writer);

  }

  component->state->saveSlot = oldSaveSlot;

  return result;

}