// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
#include "vtkDoubleArray.h"
#include "vtkFieldData.h"
#include "vtkIntArray.h"
#include "vtkMath.h"
#include "vtkSortFieldData.h"
#include "vtkStringArray.h"
#include "vtkVariantArray.h"

#include <locale>  // C++ locale
#include <sstream> // to_string chokes some compilers

#include <iostream>

// A simple test sorts on one of the components of a 3-tuple array, and then
// orders all of the arrays based on the sort indices.
int TestSortFieldData(int, char*[])
{
  // Create the arrays
  vtkIntArray* iArray = vtkIntArray::New();
  iArray->SetName("Int Array");
  iArray->SetNumberOfComponents(3);
  iArray->SetNumberOfTuples(10);

  vtkStringArray* sArray = vtkStringArray::New();
  sArray->SetName("String Array");
  sArray->SetNumberOfComponents(1);
  sArray->SetNumberOfTuples(10);

  vtkDoubleArray* dArray = vtkDoubleArray::New();
  dArray->SetName("Double Array");
  dArray->SetNumberOfComponents(2);
  dArray->SetNumberOfTuples(10);

  vtkVariantArray* vArray = vtkVariantArray::New();
  vArray->SetName("Variant Array");
  vArray->SetNumberOfComponents(1);
  vArray->SetNumberOfTuples(10);

  // Populate the arrays. Mostly random numbers with a some values
  // set to compare against expected output.
  std::ostringstream ostr;
  ostr.imbue(std::locale::classic());
  int permute[] = { 3, 0, 9, 6, 7, 4, 5, 8, 2, 1 };
  for (int i = 0; i < 10; ++i)
  {
    iArray->SetComponent(i, 0, i);
    iArray->SetComponent(permute[i], 1, i);
    iArray->SetComponent(i, 2, static_cast<int>(vtkMath::Random(0, 100)));
    ostr.str(""); // clear it out
    ostr << i;
    sArray->SetValue(permute[i], ostr.str());
    dArray->SetComponent(i, 0, vtkMath::Random(-1, 1));
    dArray->SetComponent(permute[i], 1, static_cast<double>(i));
    vArray->SetValue(permute[i], vtkVariant(ostr.str()));
  }

  // Create the field data
  vtkFieldData* fd = vtkFieldData::New();
  fd->AddArray(iArray);
  fd->AddArray(dArray);
  fd->AddArray(vArray);
  fd->AddArray(sArray);

  // Sort the data
  vtkIdType* idx = vtkSortFieldData::Sort(fd, "Int Array", 1, 1, 0);

  // Now test the result
  std::cout << "Ordering:\n\t( ";
  for (int i = 0; i < 10; ++i)
  {
    std::cout << idx[i] << " ";
    if (idx[i] != permute[i])
    {
      std::cout << "Bad sort order!\n";
      delete[] idx;
      return 1;
    }
  }
  delete[] idx;
  std::cout << ")";

  std::cout << "\n\nInteger Array (sorted by component==1):\n";
  for (int i = 0; i < 10; ++i)
  {
    std::cout << "\t(" << iArray->GetComponent(i, 0) << "," << iArray->GetComponent(i, 1) << ","
              << iArray->GetComponent(i, 2) << ")\n";
    if (iArray->GetComponent(i, 1) != i)
    {
      std::cout << "Bad sort order!\n";
      return 1;
    }
  }

  std::cout << "\nDouble Array:\n";
  for (int i = 0; i < 10; ++i)
  {
    std::cout << "\t(" << dArray->GetComponent(i, 0) << "," << dArray->GetComponent(i, 1) << ")\n";
    if (dArray->GetComponent(i, 1) != i)
    {
      std::cout << "Bad sort order!\n";
      return 1;
    }
  }

  std::cout << "\nString Array:\n\t( ";
  for (int i = 0; i < 10; ++i)
  {
    std::cout << sArray->GetValue(i) << " ";
    ostr.str(""); // clear it out
    ostr << i;
    if (sArray->GetValue(i) != ostr.str())
    {
      std::cout << "Bad sort order!\n";
      return 1;
    }
  }
  std::cout << ")\n";

  std::cout << "\nVariant Array:\n\t( ";
  for (int i = 0; i < 10; ++i)
  {
    std::cout << vArray->GetValue(i).ToString() << " ";
    ostr.str(""); // clear it out
    ostr << i;
    if (vArray->GetValue(i).ToString() != ostr.str())
    {
      std::cout << "Bad sort order!\n";
      return 1;
    }
  }
  std::cout << ")\n";

  // Clean up
  iArray->Delete();
  sArray->Delete();
  dArray->Delete();
  vArray->Delete();
  fd->Delete();

  return 0;
}
