// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-FileCopyrightText: Copyright (c) Sandia Corporation
// SPDX-License-Identifier: BSD-3-Clause
#include "vtkPExodusIIReader.h"

#include "vtkAppendCompositeDataLeaves.h"
#include "vtkCellData.h"
#include "vtkCommand.h"
#include "vtkDoubleArray.h"
#include "vtkExodusIIReaderPrivate.h"
#include "vtkFloatArray.h"
#include "vtkInformation.h"
#include "vtkInformationVector.h"
#include "vtkIntArray.h"
#include "vtkLogger.h"
#include "vtkMultiBlockDataSet.h"
#include "vtkMultiProcessController.h"
#include "vtkObjectFactory.h"
#include "vtkPointData.h"
#include "vtkSmartPointer.h"
#include "vtkStreamingDemandDrivenPipeline.h"
#include "vtkUnstructuredGrid.h"

#include "vtk_exodusII.h"
#include "vtk_netcdf.h"

#include "vtksys/SystemTools.hxx"

#include <vector>

#include <vtksys/RegularExpression.hxx>

#include <cctype>

#undef DBG_PEXOIIRDR
#define vtkPExodusIIReaderMAXPATHLEN 2048

VTK_ABI_NAMESPACE_BEGIN
static const int objTypes[] = { vtkExodusIIReader::EDGE_BLOCK, vtkExodusIIReader::FACE_BLOCK,
  vtkExodusIIReader::ELEM_BLOCK, vtkExodusIIReader::NODE_SET, vtkExodusIIReader::EDGE_SET,
  vtkExodusIIReader::FACE_SET, vtkExodusIIReader::SIDE_SET, vtkExodusIIReader::ELEM_SET,
  vtkExodusIIReader::NODE_MAP, vtkExodusIIReader::EDGE_MAP, vtkExodusIIReader::FACE_MAP,
  vtkExodusIIReader::ELEM_MAP };
static const int numObjTypes = sizeof(objTypes) / sizeof(objTypes[0]);

static const int objResultTypes[] = { vtkExodusIIReader::NODAL, vtkExodusIIReader::EDGE_BLOCK,
  vtkExodusIIReader::FACE_BLOCK, vtkExodusIIReader::ELEM_BLOCK, vtkExodusIIReader::NODE_SET,
  vtkExodusIIReader::EDGE_SET, vtkExodusIIReader::FACE_SET, vtkExodusIIReader::SIDE_SET,
  vtkExodusIIReader::ELEM_SET, vtkExodusIIReader::GLOBAL };
static const int numObjResultTypes = sizeof(objResultTypes) / sizeof(objResultTypes[0]);

static const int objAttribTypes[] = { vtkExodusIIReader::EDGE_BLOCK, vtkExodusIIReader::FACE_BLOCK,
  vtkExodusIIReader::ELEM_BLOCK };
static const int numObjAttribTypes = sizeof(objAttribTypes) / sizeof(objAttribTypes[0]);

vtkStandardNewMacro(vtkPExodusIIReader);

class vtkPExodusIIReaderUpdateProgress : public vtkCommand
{
public:
  vtkTypeMacro(vtkPExodusIIReaderUpdateProgress, vtkCommand)
  static vtkPExodusIIReaderUpdateProgress* New() { return new vtkPExodusIIReaderUpdateProgress; }
  void SetReader(vtkPExodusIIReader* r) { Reader = r; }
  void SetIndex(int i) { Index = i; }

protected:
  vtkPExodusIIReaderUpdateProgress()
  {
    Reader = nullptr;
    Index = 0;
  }
  ~vtkPExodusIIReaderUpdateProgress() override = default;

  void Execute(vtkObject*, unsigned long event, void* callData) override
  {
    if (event == vtkCommand::ProgressEvent)
    {
      double num = Reader->GetNumberOfFileNames();
      if (num <= 1)
      {
        num = Reader->GetNumberOfFiles();
      }
      double* progress = static_cast<double*>(callData);
      double newProgress = *progress / num + Index / num;
      Reader->UpdateProgress(newProgress);
    }
  }

  vtkPExodusIIReader* Reader;
  int Index;
};

//------------------------------------------------------------------------------
// Description:
// Instantiate object with nullptr filename.
vtkPExodusIIReader::vtkPExodusIIReader()
{
  this->ProcRank = 0;
  this->ProcSize = 1;
  // NB. SetController will initialize ProcSize and ProcRank
  this->Controller = nullptr;
  this->SetController(vtkMultiProcessController::GetGlobalController());
  this->FilePattern = nullptr;
  this->CurrentFilePattern = nullptr;
  this->FilePrefix = nullptr;
  this->CurrentFilePrefix = nullptr;
  this->FileRange[0] = -1;
  this->FileRange[1] = -1;
  this->CurrentFileRange[0] = 0;
  this->CurrentFileRange[1] = 0;
  this->NumberOfFiles = 1;
  this->FileNames = nullptr;
  this->NumberOfFileNames = 0;
  this->MultiFileName = new char[vtkPExodusIIReaderMAXPATHLEN];
  this->XMLFileName = nullptr;
  this->LastCommonTimeStep = -1;
  this->VariableCacheSize = 100;
}

//------------------------------------------------------------------------------
vtkPExodusIIReader::~vtkPExodusIIReader()
{
  this->SetController(nullptr);
  this->SetFilePattern(nullptr);
  this->SetFilePrefix(nullptr);

  // If we've allocated filenames then delete them
  if (this->FileNames)
  {
    for (int i = 0; i < this->NumberOfFileNames; i++)
    {
      delete[] this->FileNames[i];
    }
    delete[] this->FileNames;
  }

  // Delete all the readers we may have
  std::vector<vtkExodusIIReader*>::iterator it;
  for (it = this->ReaderList.begin(); it != this->ReaderList.end(); ++it)
  {
    (*it)->Delete();
  }

  if (this->CurrentFilePrefix)
  {
    delete[] this->CurrentFilePrefix;
    delete[] this->CurrentFilePattern;
  }

  delete[] this->MultiFileName;
}

//------------------------------------------------------------------------------
void vtkPExodusIIReader::SetController(vtkMultiProcessController* c)
{
  vtkSetObjectBodyMacro(Controller, vtkMultiProcessController, c);

  if (this->Controller)
  {
    this->ProcRank = this->Controller->GetLocalProcessId();
    this->ProcSize = this->Controller->GetNumberOfProcesses();
  }

  if (!this->Controller || this->ProcSize <= 0)
  {
    this->ProcRank = 0;
    this->ProcSize = 1;
  }
}

//------------------------------------------------------------------------------
int vtkPExodusIIReader::RequestInformation(
  vtkInformation* request, vtkInformationVector** inputVector, vtkInformationVector* outputVector)
{
  vtkInformation* outInfo = outputVector->GetInformationObject(0);
  outInfo->Set(CAN_HANDLE_PIECE_REQUEST(), 1);

  int requestInformationRetVal = 0;
  if (this->ProcRank == 0)
  {
    bool newName = this->GetMetadataMTime() < this->FileNameMTime;
    bool newPattern =
      ((this->FilePattern &&
         (!this->CurrentFilePattern ||
           !vtksys::SystemTools::ComparePath(this->FilePattern, this->CurrentFilePattern) ||
           ((this->FileRange[0] != this->CurrentFileRange[0]) ||
             (this->FileRange[1] != this->CurrentFileRange[1])))) ||
        (this->FilePrefix &&
          !vtksys::SystemTools::ComparePath(this->FilePrefix, this->CurrentFilePrefix)));

    // setting filename for the first time builds the prefix/pattern
    // if one clears the prefix/pattern, but the filename stays the same,
    // we should rebuild the prefix/pattern
    bool rebuildPattern = newPattern && this->FilePattern[0] == '\0' && this->FilePrefix[0] == '\0';

    bool sanity = ((this->FilePattern && this->FilePrefix) || this->FileName);

    if (!sanity)
    {
      vtkErrorMacro(<< "Must SetFilePattern AND SetFilePrefix, or SetFileName(s)");
      this->Broadcast(this->Controller);
      return 0;
    }

    if (newPattern && !rebuildPattern)
    {
      size_t nmSize = strlen(this->FilePattern) + strlen(this->FilePrefix) + 20;
      char* nm = new char[nmSize];
      snprintf(nm, nmSize, this->FilePattern, this->FilePrefix, this->FileRange[0]);
      delete[] this->FileName;
      this->FileName = nm;
    }
    else if (newName || rebuildPattern)
    {
      if (this->NumberOfFileNames == 1)
      {
        // A singleton file may actually be a hint to look for
        // a series of files with the same base name.  Must compute
        // this now for ParaView.

        this->DeterminePattern(this->FileNames[0]);
      }
    }

    // Read meta-data from 1st file.
    // Previously, this went over all files. This was unnecessary.
    // First file will have all necessary information.
    // Otherwise we end up with bugs like paraview/paraview#20559
    // and paraview/paraview#20558 when the files have no arrays at all.

    if (this->NumberOfFileNames > 1)
    {
      strcpy(this->MultiFileName, this->FileNames[0]);
      if (this->GetGenerateFileIdArray())
      {
        vtkPExodusIIReader::DetermineFileId(this->FileNames[0]);
      }
    }
    else if (this->FilePattern)
    {
      snprintf(
        this->MultiFileName, vtkPExodusIIReaderMAXPATHLEN, this->FilePattern, this->FilePrefix, 0);
    }
    delete[] this->FileName;
    this->FileName = vtksys::SystemTools::DuplicateString(this->MultiFileName);

    // Read in info based on this->FileName
    requestInformationRetVal =
      this->Superclass::RequestInformation(request, inputVector, outputVector);
  }
  this->Controller->Broadcast(&requestInformationRetVal, 1, 0);
  if (!requestInformationRetVal)
  {
    return 0;
  }

  if (this->ProcSize > 1)
  {
    this->Broadcast(this->Controller);
    if (this->ProcRank)
    {
      // The rank 0 node's RequestInformation annotates the output with the available
      // time steps. Now that we've received time steps, advertise them on other procs.
      this->AdvertiseTimeSteps(outInfo);
    }
  }

  // Check whether we have been given a certain timestep to stop at. If so,
  // override the output time keys with the actual range that ALL readers can read.
  // If files are still being written to, some files might be on different timesteps
  // than others.
  if ((this->LastCommonTimeStep >= 0) && !this->GetHasModeShapes())
  {
    double* times = outInfo->Get(vtkStreamingDemandDrivenPipeline::TIME_STEPS());
    int numTimes = outInfo->Length(vtkStreamingDemandDrivenPipeline::TIME_STEPS());
    numTimes = this->LastCommonTimeStep + 1 < numTimes ? this->LastCommonTimeStep + 1 : numTimes;
    std::vector<double> commonTimes;
    commonTimes.insert(commonTimes.begin(), times, times + numTimes);
    double timeRange[2];
    timeRange[1] = commonTimes[numTimes - 1];
    timeRange[0] = commonTimes[0];

    outInfo->Set(vtkStreamingDemandDrivenPipeline::TIME_RANGE(), timeRange, 2);
    outInfo->Set(vtkStreamingDemandDrivenPipeline::TIME_STEPS(), commonTimes.data(), numTimes);
  }

  if (this->CurrentFilePrefix)
  {
    delete[] this->CurrentFilePrefix;
    this->CurrentFilePrefix = nullptr;
    delete[] this->CurrentFilePattern;
    this->CurrentFilePattern = nullptr;
    this->CurrentFileRange[0] = 0;
    this->CurrentFileRange[1] = 0;
  }

  if (this->FilePrefix)
  {
    this->CurrentFilePrefix = vtksys::SystemTools::DuplicateString(this->FilePrefix);
    this->CurrentFilePattern = vtksys::SystemTools::DuplicateString(this->FilePattern);
    this->CurrentFileRange[0] = this->FileRange[0];
    this->CurrentFileRange[1] = this->FileRange[1];
  }

  return 1;
}

//------------------------------------------------------------------------------
int vtkPExodusIIReader::RequestData(vtkInformation* vtkNotUsed(request),
  vtkInformationVector** vtkNotUsed(inputVector), vtkInformationVector* outputVector)
{
  int fileIndex;
  int processNumber;
  int numProcessors;
  int min, max, idx;
  int reader_idx;

  vtkInformation* outInfo = outputVector->GetInformationObject(0);
  // get the output
  vtkMultiBlockDataSet* output =
    vtkMultiBlockDataSet::SafeDownCast(outInfo->Get(vtkDataObject::DATA_OBJECT()));

  // The whole notion of pieces for this reader is really
  // just a division of files between processors
  processNumber = outInfo->Get(vtkStreamingDemandDrivenPipeline::UPDATE_PIECE_NUMBER());
  numProcessors = outInfo->Get(vtkStreamingDemandDrivenPipeline::UPDATE_NUMBER_OF_PIECES());

  int numFiles = this->NumberOfFileNames;
  int start = 0;

  if (numFiles <= 1)
  {
    start = this->FileRange[0]; // use prefix/pattern/range
    numFiles = this->NumberOfFiles;
  }

  // Someone has requested a file that is above the number
  // of pieces I have. That may have been caused by having
  // more processors than files. So I'm going to create an
  // empty unstructured grid that contains all the meta
  // information but has 0 cells
  if (processNumber >= numFiles)
  {
#ifdef DBG_PEXOIIRDR
    vtkWarningMacro("Creating empty grid for processor: " << processNumber);
#endif
    this->Metadata->SetUpEmptyGrid(output);
    return 1;
  }

  // Divide the files evenly between processors
  int num_files_per_process = numFiles / numProcessors;

  // This if/else logic is for when you don't have a nice even division of files
  // Each process computes which sequence of files it needs to read in
  int left_over_files = numFiles - (num_files_per_process * numProcessors);
  if (processNumber < left_over_files)
  {
    min = (num_files_per_process + 1) * processNumber + start;
    max = min + (num_files_per_process + 1) - 1;
  }
  else
  {
    min = num_files_per_process * processNumber + left_over_files + start;
    max = min + num_files_per_process - 1;
  }
#ifdef DBG_PEXOIIRDR
  vtkWarningMacro("Processor: " << processNumber << " reading files: " << min << " " << max);
#endif

#ifdef DBG_PEXOIIRDR
  vtkWarningMacro("Parallel read for processor: " << processNumber);
#endif

  // We are going to read in the files one by one and then
  // append them together. So now we make sure that we have
  // the correct number of serial exodus readers and we create
  // our append object that puts the 'pieces' together
  unsigned int numMyFiles = max - min + 1;

  vtkSmartPointer<vtkAppendCompositeDataLeaves> append =
    vtkSmartPointer<vtkAppendCompositeDataLeaves>::New();
  append->AppendFieldDataOn();

  /*
  if ( this->ExodusModelMetadata )
    {
    this->NewExodusModel();
    }
  */

  if (this->ReaderList.size() < numMyFiles)
  {
    for (reader_idx = static_cast<int>(this->ReaderList.size());
         reader_idx < static_cast<int>(numMyFiles); ++reader_idx)
    {
      vtkExodusIIReader* er = vtkExodusIIReader::New();
      vtkPExodusIIReaderUpdateProgress* progress = vtkPExodusIIReaderUpdateProgress::New();
      progress->SetReader(this);
      progress->SetIndex(reader_idx);
      er->AddObserver(vtkCommand::ProgressEvent, progress);
      progress->Delete();

      this->ReaderList.push_back(er);
    }
  }
  else if (this->ReaderList.size() > numMyFiles)
  {
    for (reader_idx = static_cast<int>(this->ReaderList.size()) - 1;
         reader_idx >= static_cast<int>(numMyFiles); --reader_idx)
    {
      this->ReaderList[reader_idx]->Delete();
      ReaderList.pop_back();
    }
  }

  // If this is the first execution, we need to initialize the arrays
  // that store the number of points/cells output by each reader
  if (this->NumberOfCellsPerFile.empty())
  {
    this->NumberOfCellsPerFile.resize(max - min + 1, 0);
  }
  if (this->NumberOfPointsPerFile.empty())
  {
    this->NumberOfPointsPerFile.resize(max - min + 1, 0);
  }

#ifdef DBG_PEXOIIRDR
  cout << "\n\n ************************************* Parallel master reader dump\n";
  this->Dump();
#endif // DBG_PEXOIIRDR

  // setup the cache size for each reader
  double fractionalCacheSize = 0;
  if (this->VariableCacheSize > 0)
  {
    fractionalCacheSize = this->VariableCacheSize / static_cast<int>(this->ReaderList.size());
  }

  // This constructs the filenames
  for (fileIndex = min, reader_idx = 0; fileIndex <= max; ++fileIndex, ++reader_idx)
  {
    int fileId = -1;
    if (this->NumberOfFileNames > 1)
    {
      strcpy(this->MultiFileName, this->FileNames[fileIndex]);
      if (this->GetGenerateFileIdArray())
      {
        fileId = vtkPExodusIIReader::DetermineFileId(this->FileNames[fileIndex]);
      }
    }
    else if (this->FilePattern)
    {
      snprintf(this->MultiFileName, vtkPExodusIIReaderMAXPATHLEN, this->FilePattern,
        this->FilePrefix, fileIndex);
      if (this->GetGenerateFileIdArray())
      {
        fileId = fileIndex;
      }
    }
    else
    {
      vtkErrorMacro("Some weird problem with filename/filepattern");
      return 0;
    }

    if (outInfo->Has(vtkStreamingDemandDrivenPipeline::UPDATE_TIME_STEP()))
    { // Get the requested time step. We only support requests of a single time step in this reader
      // right now
      double requestedTimeStep = outInfo->Get(vtkStreamingDemandDrivenPipeline::UPDATE_TIME_STEP());

      // Save the time value in the output data information.
      int length = outInfo->Length(vtkStreamingDemandDrivenPipeline::TIME_STEPS());
      double* steps = outInfo->Get(vtkStreamingDemandDrivenPipeline::TIME_STEPS());

      if (!this->GetHasModeShapes())
      {
        int cnt = 0;
        int closestStep = 0;
        double minDist = -1;
        for (cnt = 0; cnt < length; ++cnt)
        {
          double tdist = (steps[cnt] - requestedTimeStep > requestedTimeStep - steps[cnt])
            ? steps[cnt] - requestedTimeStep
            : requestedTimeStep - steps[cnt];
          if (minDist < 0 || tdist < minDist)
          {
            minDist = tdist;
            closestStep = cnt;
          }
        }
        this->TimeStep = closestStep;
        this->ReaderList[reader_idx]->SetTimeStep(this->TimeStep);
        output->GetInformation()->Set(vtkDataObject::DATA_TIME_STEP(), steps[this->TimeStep]);
      }
      else
      {
        // Let the metadata know the time value so that the
        // Metadata->RequestData call below will generate the animated mode
        // shape properly.

        // Don't use this->SetModeShapeTime because that will cause Modified
        // to be called.
        // this->SetModeShapeTime( requestedTimeStep );
        double phase = requestedTimeStep - floor(requestedTimeStep);
        this->Metadata->ModeShapeTime = phase;

        this->ReaderList[reader_idx]->SetTimeStep(this->TimeStep);
        this->ReaderList[reader_idx]->SetModeShapeTime(requestedTimeStep);
        output->GetInformation()->Set(vtkDataObject::DATA_TIME_STEP(), requestedTimeStep);
        // output->GetInformation()->Remove( vtkDataObject::DATA_TIME_STEP() );
      }
    }
    else
    {
      this->ReaderList[reader_idx]->SetTimeStep(this->TimeStep);
    }

    this->ReaderList[reader_idx]->SetGenerateObjectIdCellArray(
      this->GetGenerateObjectIdCellArray());
    this->ReaderList[reader_idx]->SetGenerateGlobalElementIdArray(
      this->GetGenerateGlobalElementIdArray());
    this->ReaderList[reader_idx]->SetGenerateGlobalNodeIdArray(
      this->GetGenerateGlobalNodeIdArray());
    this->ReaderList[reader_idx]->SetGenerateImplicitElementIdArray(
      this->GetGenerateImplicitElementIdArray());
    this->ReaderList[reader_idx]->SetGenerateImplicitNodeIdArray(
      this->GetGenerateImplicitNodeIdArray());
    this->ReaderList[reader_idx]->SetGenerateFileIdArray(this->GetGenerateFileIdArray());
    this->ReaderList[reader_idx]->SetFileId(fileId);
    this->ReaderList[reader_idx]->SetApplyDisplacements(this->GetApplyDisplacements());
    this->ReaderList[reader_idx]->SetDisplacementMagnitude(this->GetDisplacementMagnitude());
    this->ReaderList[reader_idx]->SetHasModeShapes(this->GetHasModeShapes());
    this->ReaderList[reader_idx]->SetAnimateModeShapes(this->GetAnimateModeShapes());

    // this->ReaderList[reader_idx]->SetExodusModelMetadata( this->ExodusModelMetadata );
    // For now, this *must* come last before the UpdateInformation() call because its MTime is
    // compared to the metadata's MTime, which is modified by the calls above.
    this->ReaderList[reader_idx]->SetFileName(this->MultiFileName);
    this->ReaderList[reader_idx]->SetXMLFileName(this->XMLFileName);
    // this->ReaderList[reader_idx]->PackExodusModelOntoOutputOff();

    // BUG #15632: Pass time information from first file to all others.
    if (reader_idx > 1)
    {
      this->ReaderList[reader_idx]->Metadata->SetTimesOverrides(
        this->ReaderList[0]->Metadata->Times);
    }

    this->ReaderList[reader_idx]->UpdateInformation();
#ifdef DBG_PEXOIIRDR
    cout << "\n\n ************************************* Reader " << reader_idx << " dump\n";
    this->ReaderList[reader_idx]->Dump();
#endif // DBG_PEXOIIRDR

    int typ;
    for (typ = 0; typ < numObjTypes; ++typ)
    {
      int nObj = this->ReaderList[reader_idx]->GetNumberOfObjects(objTypes[typ]);
      for (idx = 0; idx < nObj; ++idx)
      {
        this->ReaderList[reader_idx]->SetObjectStatus(
          objTypes[typ], idx, this->GetObjectStatus(objTypes[typ], idx));
      }
    }

    for (typ = 0; typ < numObjAttribTypes; ++typ)
    {
      int nObj = this->ReaderList[reader_idx]->GetNumberOfObjects(objAttribTypes[typ]);
      for (idx = 0; idx < nObj; ++idx)
      {
        int nObjAtt = this->GetNumberOfObjectAttributes(objAttribTypes[typ], idx);
        for (int aidx = 0; aidx < nObjAtt; ++aidx)
        {
          this->ReaderList[reader_idx]->SetObjectAttributeStatus(objAttribTypes[typ], idx, aidx,
            this->GetObjectAttributeStatus(objAttribTypes[typ], idx, aidx));
        }
      }
    }

    for (typ = 0; typ < numObjResultTypes; ++typ)
    {
      int nObjArr = this->GetNumberOfObjectArrays(objResultTypes[typ]);
      for (idx = 0; idx < nObjArr; ++idx)
      {
        this->ReaderList[reader_idx]->SetObjectArrayStatus(
          objResultTypes[typ], idx, this->GetObjectArrayStatus(objResultTypes[typ], idx));
      }
    }

    // set this reader to use the full amount of the cache
    this->ReaderList[reader_idx]->SetCacheSize(this->VariableCacheSize);

    // call the reader
    this->ReaderList[reader_idx]->Update();

    // set the reader back to the fractional amount
    this->ReaderList[reader_idx]->SetCacheSize(fractionalCacheSize);

#if 0
    vtkCompositeDataSet* subgrid = this->ReaderList[reader_idx]->GetOutput();
    //subgrid->ShallowCopy( this->ReaderList[reader_idx]->GetOutput() );

    int ncells = subgrid->GetNumberOfCells();

    if ( ( ncells > 0 ) && this->Metadata->GetGenerateFileIdArray() )
    {
      vtkIntArray* ia = vtkIntArray::New();
      ia->SetNumberOfValues(ncells);
      for ( idx = 0; idx < ncells; ++ idx )
      {
        ia->SetValue( idx, fileId );
      }
      ia->SetName( "vtkFileId" );
      subgrid->GetCellData()->AddArray( ia );
      ia->Delete();
    }

    // Don't append if you don't have any cells
    if ( ncells != 0 )
    {
      if ( this->ExodusModelMetadata )
      {
        vtkExodusModel* em = this->ReaderList[reader_idx]->GetExodusModel();
        if ( em )
        {
          this->ExodusModel->MergeExodusModel( em );
        }
      }

      totalCells += ncells;
      totalPoints += subgrid->GetNumberOfPoints();
      this->NumberOfCellsPerFile[reader_idx] = ncells;
      this->NumberOfPointsPerFile[reader_idx] = subgrid->GetNumberOfPoints();

      append->AddInput( subgrid );
      subgrid->Delete();
    }
#else // 0
    append->AddInputConnection(this->ReaderList[reader_idx]->GetOutputPort());
#endif // 0
  }

  // Append complains/barfs if you update it without any inputs
  if (append->GetNumberOfInputConnections(0) != 0)
  {
    append->Update();
    output->CompositeShallowCopy(append->GetOutput());
  }

  // I've copied append's output to the 'output' so delete append
  append = nullptr;

#if 0  // FIXME: Need multiblock version... or not?
  if ( this->PackExodusModelOntoOutput )
  {
    // The metadata is written to field arrays and attached
    // to the output unstructured grid.
    if ( this->ExodusModel )
    {
      vtkModelMetadata::RemoveMetadata( output );
      this->ExodusModel->GetModelMetadata()->Pack( output );
    }
  }
#endif // 0

  return 1;
}

//------------------------------------------------------------------------------
void vtkPExodusIIReader::SetFileRange(int min, int max)
{
  if (min == this->FileRange[0] && max == this->FileRange[1])
  {
    return;
  }
  this->FileRange[0] = min;
  this->FileRange[1] = max;
  this->NumberOfFiles = max - min + 1;
  this->Modified();
}
//------------------------------------------------------------------------------
void vtkPExodusIIReader::SetFileName(const char* name)
{
  vtkLogScopeF(TRACE, "%s: SetFileName(%s)", vtkLogIdentifier(this), name);
  this->SetFileNames(1, &name);
}

void vtkPExodusIIReader::SetFileNames(int nfiles, const char** names)
{
  vtkLogScopeF(TRACE, "%s: SetFileNames(%d, %s)", vtkLogIdentifier(this), nfiles,
    nfiles > 0 ? names[0] : "nullptr");
  // If I have an old list of filename delete them
  if (this->FileNames)
  {
    for (int i = 0; i < this->NumberOfFileNames; ++i)
    {
      delete[] this->FileNames[i];
    }
    delete[] this->FileNames;
    this->FileNames = nullptr;
  }

  // Set the number of files
  this->NumberOfFileNames = nfiles;

  // Allocate memory for new filenames
  this->FileNames = new char*[this->NumberOfFileNames];

  // Copy filenames
  for (int i = 0; i < nfiles; ++i)
  {
    this->FileNames[i] = vtksys::SystemTools::DuplicateString(names[i]);
  }

  this->Superclass::SetFileName(names[0]);
}

//------------------------------------------------------------------------------
int vtkPExodusIIReader::DetermineFileId(const char* file)
{
  // Assume the file number is the last digits found in the file name.
  int fileId = 0;
  const char* start = file;
  const char* end = file + strlen(file) - 1;
  const char* numString = end;

  if (!isdigit(*numString))
  {
    while (numString > start)
    {
      --numString;
      if (isdigit(*numString))
        break;
    }

    if (numString == start)
    {
      if (isdigit(*numString))
      {
        fileId = atoi(numString);
      }
      return fileId; // no numbers in file name
    }
  }

  while (numString > start)
  {
    --numString;
    if (!isdigit(*numString))
      break;
  }

  if ((numString == start) && (isdigit(*numString)))
  {
    fileId = atoi(numString);
  }
  else
  {
    fileId = atoi(++numString);
  }

  return fileId;
}

int vtkPExodusIIReader::DeterminePattern(const char* file)
{
  char pattern[20] = "%s";
  int scount = 0;
  int cc = 0;
  int min = 0, max = 0;

  // First check for file names for which we should _not_ look for a numbered
  // sequence.  If using the extension .ex2 or .ex2v2, then we should not.
  // Furthermore, if the filename ends in .e-s#, then this number is indicative
  // of a restart number, not a partition number, so we should not look for
  // numbered sequences there either.
  vtksys::RegularExpression ex2RegEx("\\.ex2$");
  vtksys::RegularExpression ex2v2RegEx("\\.ex2v2$");
  vtksys::RegularExpression restartRegEx("\\.e-s\\.?[0-9]+(\\.ex2v[0-9]+)?$");

  // This regular expression finds the number for a numbered sequence.  This
  // number appears at the end of file (or potentially right before an extension
  // like .ex2v3 or perhaps a future version of this extension).  The matches
  // (in parentheses) are as follows:
  // 1 - The prefix.
  // 2 - The sequence number.
  // 3 - The optional extension.
  vtksys::RegularExpression numberRegEx("^(.*[^0-9])([0-9]+)(\\.ex2v[0-9]+)?$");

  if (ex2RegEx.find(file) || ex2v2RegEx.find(file) || restartRegEx.find(file) ||
    !numberRegEx.find(file))
  {
    // Set my info
    // this->SetFilePattern( pattern ); // XXX Bad set
    // this->SetFilePrefix( file ); // XXX Bad set
    // this->SetFileRange( min, max ); // XXX Bad set
    delete[] this->FilePattern;
    delete[] this->FilePrefix;
    this->FilePattern = vtksys::SystemTools::DuplicateString(pattern);
    this->FilePrefix = vtksys::SystemTools::DuplicateString(file);
    this->FileRange[0] = min;
    this->FileRange[1] = max;
    this->NumberOfFiles = max - min + 1;
    return VTK_OK;
  }

  // If we are here, then numberRegEx matched and we have found the part of
  // the filename that is the number.  Extract the filename parts.
  std::string prefix = numberRegEx.match(1);
  scount = static_cast<int>(numberRegEx.match(2).size());
  std::string extension = numberRegEx.match(3);

  // Determine the pattern
  snprintf(pattern, sizeof(pattern), "%%s%%0%ii%s", scount, extension.c_str());

  // Count up the files
  char buffer[1024];
  vtksys::SystemTools::Stat_t fs;

  // First go up every 100
  for (cc = min + 100; true; cc += 100)
  {
    snprintf(buffer, sizeof(buffer), pattern, prefix.c_str(), cc);

    if (vtksys::SystemTools::Stat(buffer, &fs) == -1)
      break;
  }
  // Okay if I'm here than stat has failed so -100 on my cc
  cc = cc - 100;
  for (cc = cc + 1; true; ++cc)
  {
    snprintf(buffer, sizeof(buffer), pattern, prefix.c_str(), cc);

    if (vtksys::SystemTools::Stat(buffer, &fs) == -1)
      break;
  }
  // Okay if I'm here than stat has failed so -1 on my cc
  max = cc - 1;

  // Second, go down every 100
  // We can't assume that we're starting at 0 because the file selector
  // will pick up every file that ends in .ex2v3... not just the first one.
  for (cc = min - 100; true; cc -= 100)
  {
    if (cc < 0)
      break;

    snprintf(buffer, sizeof(buffer), pattern, prefix.c_str(), cc);

    if (vtksys::SystemTools::Stat(buffer, &fs) == -1)
      break;
  }

  cc += 100;
  // Okay if I'm here than stat has failed so -100 on my cc
  for (cc = cc - 1; true; --cc)
  {
    if (cc < 0)
      break;

    snprintf(buffer, sizeof(buffer), pattern, prefix.c_str(), cc);

    if (vtksys::SystemTools::Stat(buffer, &fs) == -1)
      break;
  }
  min = cc + 1;

  // If the user did not specify a range before this,
  // than set the range to the min and max
  if ((this->FileRange[0] == -1) && (this->FileRange[1] == -1))
  {
    // this->SetFileRange( min, max ); // XXX Bad set
    this->FileRange[0] = min;
    this->FileRange[1] = max;
    this->NumberOfFiles = max - min + 1;
  }

  // Set my info
  // this->SetFilePattern( pattern ); // XXX Bad set
  // this->SetFilePrefix( prefix ); // XXX Bad set
  // delete [] prefix;
  delete[] this->FilePattern;
  delete[] this->FilePrefix;
  this->FilePattern = vtksys::SystemTools::DuplicateString(pattern);
  this->FilePrefix = vtksys::SystemTools::DuplicateString(prefix.c_str());

  return VTK_OK;
}

//------------------------------------------------------------------------------
void vtkPExodusIIReader::PrintSelf(ostream& os, vtkIndent indent)
{
  vtkExodusIIReader::PrintSelf(os, indent);

  if (this->FilePattern)
  {
    os << indent << "FilePattern: " << this->FilePattern << endl;
  }
  else
  {
    os << indent << "FilePattern: nullptr\n";
  }

  if (this->FilePattern)
  {
    os << indent << "FilePrefix: " << this->FilePrefix << endl;
  }
  else
  {
    os << indent << "FilePrefix: nullptr\n";
  }

  os << indent << "FileRange: " << this->FileRange[0] << " " << this->FileRange[1] << endl;

  os << indent << "NumberOfFiles: " << this->NumberOfFiles << endl;
  os << indent << "Controller: " << this->Controller << endl;
  os << indent << "VariableCacheSize: " << this->VariableCacheSize << endl;
}

vtkIdType vtkPExodusIIReader::GetTotalNumberOfElements()
{
  vtkIdType total = 0;
  std::vector<vtkExodusIIReader*>::iterator it;
  for (it = this->ReaderList.begin(); it != this->ReaderList.end(); ++it)
  {
    total += (*it)->GetTotalNumberOfElements();
  }
  return total;
}

vtkIdType vtkPExodusIIReader::GetTotalNumberOfNodes()
{
  vtkIdType total = 0;
  std::vector<vtkExodusIIReader*>::iterator it;
  for (it = this->ReaderList.begin(); it != this->ReaderList.end(); ++it)
  {
    total += (*it)->GetTotalNumberOfNodes();
  }
  return total;
}

static void BroadcastXmitString(vtkMultiProcessController* ctrl, char* str)
{
  int len;
  if (str)
  {
    len = static_cast<int>(strlen(str)) + 1;
    ctrl->Broadcast(&len, 1, 0);
    ctrl->Broadcast(str, len, 0);
  }
  else
  {
    len = 0;
    ctrl->Broadcast(&len, 1, 0);
  }
}

static bool BroadcastRecvString(vtkMultiProcessController* ctrl, std::vector<char>& str)
{
  int len;
  ctrl->Broadcast(&len, 1, 0);
  if (len)
  {
    str.resize(len);
    ctrl->Broadcast(str.data(), len, 0);
    return true;
  }
  return false;
}

static void BroadcastDoubleVector(
  vtkMultiProcessController* controller, std::vector<double>& dvec, int rank)
{
  unsigned long len = static_cast<unsigned long>(dvec.size());
  controller->Broadcast(&len, 1, 0);
  if (rank)
  {
    dvec.resize(len);
  }
  if (len)
  {
    controller->Broadcast(dvec.data(), len, 0);
  }
}

static void BroadcastIntVector(
  vtkMultiProcessController* controller, std::vector<int>& ivec, int rank)
{
  unsigned long len = static_cast<unsigned long>(ivec.size());
  controller->Broadcast(&len, 1, 0);
  if (rank)
  {
    ivec.resize(len);
  }
  if (len)
  {
    controller->Broadcast(ivec.data(), len, 0);
  }
}

static void BroadcastString(vtkMultiProcessController* controller, std::string& str, int rank)
{
  unsigned long len = static_cast<unsigned long>(str.size()) + 1;
  controller->Broadcast(&len, 1, 0);
  if (len)
  {
    if (rank)
    {
      std::vector<char> tmp;
      tmp.resize(len);
      controller->Broadcast(tmp.data(), len, 0);
      str = tmp.data();
    }
    else
    {
      const char* start = str.c_str();
      std::vector<char> tmp(start, start + len);
      controller->Broadcast(tmp.data(), len, 0);
    }
  }
}

static void BroadcastStringVector(
  vtkMultiProcessController* controller, std::vector<vtkStdString>& svec, int rank)
{
  unsigned long len = static_cast<unsigned long>(svec.size());
  controller->Broadcast(&len, 1, 0);
  if (rank)
    svec.resize(len);
  for (auto it = svec.begin(); it != svec.end(); ++it)
  {
    BroadcastString(controller, *it, rank);
  }
}

static void BroadcastObjectInfo(
  vtkMultiProcessController* controller, vtkExodusIIReaderPrivate::ObjectInfoType* oinfo, int rank)
{
  controller->Broadcast(&oinfo->Size, 1, 0);
  controller->Broadcast(&oinfo->Status, 1, 0);
  controller->Broadcast(&oinfo->Id, 1, 0);
  BroadcastString(controller, oinfo->Name, rank);
}

static void BroadcastBlockSetInfo(vtkMultiProcessController* controller,
  vtkExodusIIReaderPrivate::BlockSetInfoType* bsinfo, int rank)
{
  BroadcastObjectInfo(controller, bsinfo, rank);
  controller->Broadcast(&bsinfo->FileOffset, 1, 0);
  unsigned long len;
  unsigned long i;
  std::map<vtkIdType, vtkIdType>::iterator it;
  vtkIdType item[2];
  if (rank == 0)
  {
    len = static_cast<unsigned long>(bsinfo->PointMap.size());
    controller->Broadcast(&len, 1, 0);
    for (it = bsinfo->PointMap.begin(); it != bsinfo->PointMap.end(); ++it)
    {
      item[0] = it->first;
      item[1] = it->second;
      controller->Broadcast(item, 2, 0);
    }
  }
  else
  {
    if (bsinfo->CachedConnectivity)
    {
      bsinfo->CachedConnectivity->Delete();
    }
    bsinfo->CachedConnectivity = nullptr;
    bsinfo->PointMap.clear();
    bsinfo->ReversePointMap.clear();
    controller->Broadcast(&len, 1, 0);
    for (i = 0; i < len; ++i)
    {
      controller->Broadcast(item, 2, 0);
      bsinfo->PointMap[item[0]] = item[1];
      bsinfo->ReversePointMap[item[1]] = item[0];
    }
  }
  controller->Broadcast(&bsinfo->NextSqueezePoint, 1, 0);
}

static void BroadcastBlockInfo(
  vtkMultiProcessController* controller, vtkExodusIIReaderPrivate::BlockInfoType* binfo, int rank)
{
  BroadcastBlockSetInfo(controller, binfo, rank);
  BroadcastString(controller, binfo->TypeName, rank);
  controller->Broadcast(binfo->BdsPerEntry, 3, 0);
  controller->Broadcast(&binfo->AttributesPerEntry, 1, 0);
  BroadcastStringVector(controller, binfo->AttributeNames, rank);
  BroadcastIntVector(controller, binfo->AttributeStatus, rank);
  controller->Broadcast(&binfo->CellType, 1, 0);
  controller->Broadcast(&binfo->PointsPerCell, 1, 0);
}

static void BroadcastPartInfo(
  vtkMultiProcessController* controller, vtkExodusIIReaderPrivate::PartInfoType* pinfo, int rank)
{
  BroadcastObjectInfo(controller, pinfo, rank);
  BroadcastIntVector(controller, pinfo->BlockIndices, rank);
}

static void BroadcastAssemblyInfo(vtkMultiProcessController* controller,
  vtkExodusIIReaderPrivate::AssemblyInfoType* ainfo, int rank)
{
  BroadcastObjectInfo(controller, ainfo, rank);
  BroadcastIntVector(controller, ainfo->BlockIndices, rank);
}

static void BroadcastMaterialInfo(vtkMultiProcessController* controller,
  vtkExodusIIReaderPrivate::MaterialInfoType* minfo, int rank)
{
  BroadcastObjectInfo(controller, minfo, rank);
  BroadcastIntVector(controller, minfo->BlockIndices, rank);
}

static void BroadcastSetInfo(
  vtkMultiProcessController* controller, vtkExodusIIReaderPrivate::SetInfoType* sinfo, int rank)
{
  BroadcastBlockSetInfo(controller, sinfo, rank);
  controller->Broadcast(&sinfo->DistFact, 1, 0);
}

static void BroadcastArrayInfo(
  vtkMultiProcessController* controller, vtkExodusIIReaderPrivate::ArrayInfoType* ainfo, int rank)
{
  if (rank)
    ainfo->Reset();

  BroadcastString(controller, ainfo->Name, rank);
  controller->Broadcast(&ainfo->Components, 1, 0);
  controller->Broadcast(&ainfo->GlomType, 1, 0);
  controller->Broadcast(&ainfo->StorageType, 1, 0);
  controller->Broadcast(&ainfo->Source, 1, 0);
  controller->Broadcast(&ainfo->Status, 1, 0);
  BroadcastStringVector(controller, ainfo->OriginalNames, rank);
  BroadcastIntVector(controller, ainfo->OriginalIndices, rank);
  BroadcastIntVector(controller, ainfo->ObjectTruth, rank);
}

static void BroadcastArrayInfoVector(vtkMultiProcessController* controller,
  std::vector<vtkExodusIIReaderPrivate::ArrayInfoType>& ainfo, int rank)
{
  unsigned long len = static_cast<unsigned long>(ainfo.size());
  controller->Broadcast(&len, 1, 0);
  if (rank)
    ainfo.resize(len);
  unsigned long i;
  for (i = 0; i < len; ++i)
  {
    BroadcastArrayInfo(controller, &ainfo[i], rank);
  }
}

static void BroadcastSortedObjectIndices(
  vtkMultiProcessController* controller, std::map<int, std::vector<int>>& oidx, int rank)
{
  unsigned long len = static_cast<unsigned long>(oidx.size());
  controller->Broadcast(&len, 1, 0);
  if (rank == 0)
  {
    std::map<int, std::vector<int>>::iterator it;
    int tmp;
    for (it = oidx.begin(); it != oidx.end(); ++it)
    {
      tmp = it->first;
      controller->Broadcast(&tmp, 1, 0);
      BroadcastIntVector(controller, it->second, rank);
    }
  }
  else
  {
    unsigned long i;
    for (i = 0; i < len; ++i)
    {
      std::vector<int> blank;
      int key;
      controller->Broadcast(&key, 1, 0);
      oidx[key] = blank;
      BroadcastIntVector(controller, oidx[key], rank);
    }
  }
}

static void BroadcastArrayInfoMap(vtkMultiProcessController* controller,
  std::map<int, std::vector<vtkExodusIIReaderPrivate::ArrayInfoType>>& oidx, int rank)
{
  unsigned long len = static_cast<unsigned long>(oidx.size());
  controller->Broadcast(&len, 1, 0);
  if (rank == 0)
  {
    int tmp;
    std::map<int, std::vector<vtkExodusIIReaderPrivate::ArrayInfoType>>::iterator it;
    for (it = oidx.begin(); it != oidx.end(); ++it)
    {
      tmp = it->first;
      controller->Broadcast(&tmp, 1, 0);
      BroadcastArrayInfoVector(controller, it->second, rank);
    }
  }
  else
  {
    unsigned long i;
    for (i = 0; i < len; ++i)
    {
      std::vector<vtkExodusIIReaderPrivate::ArrayInfoType> blank;
      int key;
      controller->Broadcast(&key, 1, 0);
      oidx[key] = blank;
      BroadcastArrayInfoVector(controller, oidx[key], rank);
    }
  }
}

static void BroadcastModelParameters(
  vtkMultiProcessController* controller, ex_init_params& params, int vtkNotUsed(rank))
{
  controller->Broadcast(params.title, MAX_LINE_LENGTH + 1, 0);
  controller->Broadcast(&params.num_dim, 1, 0);
  controller->Broadcast(&params.num_nodes, 1, 0);
  controller->Broadcast(&params.num_edge, 1, 0);
  controller->Broadcast(&params.num_edge_blk, 1, 0);
  controller->Broadcast(&params.num_face, 1, 0);
  controller->Broadcast(&params.num_face_blk, 1, 0);
  controller->Broadcast(&params.num_elem, 1, 0);
  controller->Broadcast(&params.num_elem_blk, 1, 0);
  controller->Broadcast(&params.num_node_sets, 1, 0);
  controller->Broadcast(&params.num_edge_sets, 1, 0);
  controller->Broadcast(&params.num_face_sets, 1, 0);
  controller->Broadcast(&params.num_side_sets, 1, 0);
  controller->Broadcast(&params.num_elem_sets, 1, 0);
  controller->Broadcast(&params.num_node_maps, 1, 0);
  controller->Broadcast(&params.num_edge_maps, 1, 0);
  controller->Broadcast(&params.num_face_maps, 1, 0);
  controller->Broadcast(&params.num_elem_maps, 1, 0);
}

static void BroadcastBlockInfoVector(vtkMultiProcessController* controller,
  std::vector<vtkExodusIIReaderPrivate::BlockInfoType>& binfo, int rank)
{
  unsigned long len = static_cast<unsigned long>(binfo.size());
  controller->Broadcast(&len, 1, 0);
  if (rank)
    binfo.resize(len);
  std::vector<vtkExodusIIReaderPrivate::BlockInfoType>::iterator it;
  for (it = binfo.begin(); it != binfo.end(); ++it)
  {
    BroadcastBlockInfo(controller, &(*it), rank);
  }
}

static void BroadcastBlockInfoMap(vtkMultiProcessController* controller,
  std::map<int, std::vector<vtkExodusIIReaderPrivate::BlockInfoType>>& binfo, int rank)
{
  unsigned long len = static_cast<unsigned long>(binfo.size());
  controller->Broadcast(&len, 1, 0);
  int tmp;
  if (rank == 0)
  {
    std::map<int, std::vector<vtkExodusIIReaderPrivate::BlockInfoType>>::iterator it;
    for (it = binfo.begin(); it != binfo.end(); ++it)
    {
      tmp = it->first;
      controller->Broadcast(&tmp, 1, 0);
      BroadcastBlockInfoVector(controller, it->second, rank);
    }
  }
  else
  {
    unsigned long i;
    std::vector<vtkExodusIIReaderPrivate::BlockInfoType> blank;
    for (i = 0; i < len; ++i)
    {
      controller->Broadcast(&tmp, 1, 0);
      binfo[tmp] = blank;
      BroadcastBlockInfoVector(controller, binfo[tmp], rank);
    }
  }
}

static void BroadcastSetInfoVector(vtkMultiProcessController* controller,
  std::vector<vtkExodusIIReaderPrivate::SetInfoType>& sinfo, int rank)
{
  unsigned long len = static_cast<unsigned long>(sinfo.size());
  controller->Broadcast(&len, 1, 0);
  if (rank)
    sinfo.resize(len);
  std::vector<vtkExodusIIReaderPrivate::SetInfoType>::iterator it;
  for (it = sinfo.begin(); it != sinfo.end(); ++it)
  {
    BroadcastSetInfo(controller, &(*it), rank);
  }
}

static void BroadcastSetInfoMap(vtkMultiProcessController* controller,
  std::map<int, std::vector<vtkExodusIIReaderPrivate::SetInfoType>>& sinfo, int rank)
{
  unsigned long len = static_cast<unsigned long>(sinfo.size());
  controller->Broadcast(&len, 1, 0);
  int tmp;
  if (rank == 0)
  {
    std::map<int, std::vector<vtkExodusIIReaderPrivate::SetInfoType>>::iterator it;
    for (it = sinfo.begin(); it != sinfo.end(); ++it)
    {
      tmp = it->first;
      controller->Broadcast(&tmp, 1, 0);
      BroadcastSetInfoVector(controller, it->second, rank);
    }
  }
  else
  {
    unsigned long i;
    std::vector<vtkExodusIIReaderPrivate::SetInfoType> blank;
    for (i = 0; i < len; ++i)
    {
      controller->Broadcast(&tmp, 1, 0);
      sinfo[tmp] = blank;
      BroadcastSetInfoVector(controller, sinfo[tmp], rank);
    }
  }
}

static void BroadcastMapInfoVector(vtkMultiProcessController* controller,
  std::vector<vtkExodusIIReaderPrivate::MapInfoType>& minfo, int rank)
{
  unsigned long len = static_cast<unsigned long>(minfo.size());
  controller->Broadcast(&len, 1, 0);
  if (rank)
    minfo.resize(len);
  std::vector<vtkExodusIIReaderPrivate::MapInfoType>::iterator it;
  for (it = minfo.begin(); it != minfo.end(); ++it)
  {
    BroadcastObjectInfo(controller, &(*it), rank);
  }
}

static void BroadcastMapInfoMap(vtkMultiProcessController* controller,
  std::map<int, std::vector<vtkExodusIIReaderPrivate::MapInfoType>>& minfo, int rank)
{
  unsigned long len = static_cast<unsigned long>(minfo.size());
  controller->Broadcast(&len, 1, 0);
  int tmp;
  if (rank == 0)
  {
    std::map<int, std::vector<vtkExodusIIReaderPrivate::MapInfoType>>::iterator it;
    for (it = minfo.begin(); it != minfo.end(); ++it)
    {
      tmp = it->first;
      controller->Broadcast(&tmp, 1, 0);
      BroadcastMapInfoVector(controller, it->second, rank);
    }
  }
  else
  {
    unsigned long i;
    std::vector<vtkExodusIIReaderPrivate::MapInfoType> blank;
    for (i = 0; i < len; ++i)
    {
      controller->Broadcast(&tmp, 1, 0);
      minfo[tmp] = blank;
      BroadcastMapInfoVector(controller, minfo[tmp], rank);
    }
  }
}

static void BroadcastPartInfoVector(vtkMultiProcessController* controller,
  std::vector<vtkExodusIIReaderPrivate::PartInfoType>& pinfo, int rank)
{
  unsigned long len = static_cast<unsigned long>(pinfo.size());
  controller->Broadcast(&len, 1, 0);
  if (rank)
    pinfo.resize(len);
  std::vector<vtkExodusIIReaderPrivate::PartInfoType>::iterator it;
  for (it = pinfo.begin(); it != pinfo.end(); ++it)
  {
    BroadcastPartInfo(controller, &(*it), rank);
  }
}

static void BroadcastMaterialInfoVector(vtkMultiProcessController* controller,
  std::vector<vtkExodusIIReaderPrivate::MaterialInfoType>& minfo, int rank)
{
  unsigned long len = static_cast<unsigned long>(minfo.size());
  controller->Broadcast(&len, 1, 0);
  if (rank)
    minfo.resize(len);
  std::vector<vtkExodusIIReaderPrivate::MaterialInfoType>::iterator it;
  for (it = minfo.begin(); it != minfo.end(); ++it)
  {
    BroadcastMaterialInfo(controller, &(*it), rank);
  }
}

static void BroadcastAssemblyInfoVector(vtkMultiProcessController* controller,
  std::vector<vtkExodusIIReaderPrivate::AssemblyInfoType>& ainfo, int rank)
{
  unsigned long len = static_cast<unsigned long>(ainfo.size());
  controller->Broadcast(&len, 1, 0);
  if (rank)
    ainfo.resize(len);
  std::vector<vtkExodusIIReaderPrivate::AssemblyInfoType>::iterator it;
  for (it = ainfo.begin(); it != ainfo.end(); ++it)
  {
    BroadcastAssemblyInfo(controller, &(*it), rank);
  }
}

void vtkPExodusIIReader::Broadcast(vtkMultiProcessController* ctrl)
{
  if (ctrl)
  {
    int rank = ctrl->GetLocalProcessId();
    BroadcastBlockInfoMap(ctrl, this->Metadata->BlockInfo, rank);
    BroadcastSetInfoMap(ctrl, this->Metadata->SetInfo, rank);
    BroadcastMapInfoMap(ctrl, this->Metadata->MapInfo, rank);
    BroadcastPartInfoVector(ctrl, this->Metadata->PartInfo, rank);
    BroadcastMaterialInfoVector(ctrl, this->Metadata->MaterialInfo, rank);
    BroadcastAssemblyInfoVector(ctrl, this->Metadata->AssemblyInfo, rank);
    BroadcastSortedObjectIndices(ctrl, this->Metadata->SortedObjectIndices, rank);
    BroadcastArrayInfoMap(ctrl, this->Metadata->ArrayInfo, rank);
    ctrl->Broadcast(&this->Metadata->AppWordSize, 1, 0);
    ctrl->Broadcast(&this->Metadata->DiskWordSize, 1, 0);
    ctrl->Broadcast(&this->Metadata->ExodusVersion, 1, 0);
    ctrl->Broadcast(&this->Metadata->ExodusVersion, 1, 0);
    BroadcastModelParameters(ctrl, this->Metadata->ModelParameters, rank);
    BroadcastDoubleVector(ctrl, this->Metadata->Times, rank);

    ctrl->Broadcast(this->TimeStepRange, 2, 0);
    if (rank == 0)
    {
      BroadcastXmitString(ctrl, this->FilePattern);
      BroadcastXmitString(ctrl, this->FilePrefix);
    }
    else
    {
      std::vector<char> tmp;
      delete[] this->FilePattern;
      delete[] this->FilePrefix;
      // XXX Bad set for these two calls
      // this->SetFilePattern( BroadcastRecvString( ctrl, tmp ) ? tmp.data() : nullptr );
      // this->SetFilePrefix(  BroadcastRecvString( ctrl, tmp ) ? tmp.data() : nullptr );
      this->FilePattern =
        BroadcastRecvString(ctrl, tmp) ? vtksys::SystemTools::DuplicateString(tmp.data()) : nullptr;
      this->FilePrefix =
        BroadcastRecvString(ctrl, tmp) ? vtksys::SystemTools::DuplicateString(tmp.data()) : nullptr;
    }
    ctrl->Broadcast(this->FileRange, 2, 0);
    ctrl->Broadcast(&this->NumberOfFiles, 1, 0);
  }
}
VTK_ABI_NAMESPACE_END
