/*=========================================================================
 *
 *  Copyright NumFOCUS
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         https://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
#include "itkPipeline.h"
#include "itkInputTextStream.h"
#include "itkOutputTextStream.h"
#include "itkInputBinaryStream.h"
#include "itkOutputBinaryStream.h"
#include "itkMesh.h"
#include "itkInputMesh.h"
#include "itkOutputMesh.h"
#include "itkInputImage.h"
#include "itkOutputImage.h"

int main( int argc, char * argv[] )
{
  itk::wasm::Pipeline pipeline("bindgen-interface-types-test", "A test to exercise interface types for bindgen", argc, argv);

  using PixelType = unsigned char;
  constexpr unsigned int Dimension = 3;

  std::string inputTextFile;
  pipeline.add_option("input-text-file", inputTextFile, "The input text file")->required()->group("Files")->type_name("INPUT_TEXT_FILE");

  std::string inputBinaryFile;
  pipeline.add_option("input-binary-file", inputBinaryFile, "The input binary file")->required()->group("Files")->type_name("INPUT_BINARY_FILE");

  itk::wasm::InputTextStream inputTextStream;
  pipeline.add_option("input-text-stream", inputTextStream, "The input text stream")->group("Streams")->type_name("INPUT_TEXT_STREAM");

  itk::wasm::InputBinaryStream inputBinaryStream;
  pipeline.add_option("input-binary-stream", inputBinaryStream, "The input binary stream")->group("Streams")->type_name("INPUT_BINARY_STREAM");

  itk::wasm::InputTextStream inputJson;
  pipeline.add_option("input-json", inputJson, "The input json")->type_name("INPUT_JSON");

  using ImageType = itk::Image< PixelType, 2 >;

  using InputImageType = itk::wasm::InputImage<ImageType>;
  InputImageType inputImage;
  pipeline.add_option("input-image", inputImage, "The input image")->required()->group("Images")->type_name("INPUT_IMAGE");

  using MeshType = itk::Mesh< PixelType, Dimension >;

  using InputMeshType = itk::wasm::InputMesh<MeshType>;
  InputMeshType inputMesh;
  pipeline.add_option("input-mesh", inputMesh, "The input mesh")->required()->group("Meshes")->type_name("INPUT_MESH");

  int integerType = 3;
  pipeline.add_option("-i,--integer-type", integerType, "An integer type.");

  double floatingType = 2.0;
  pipeline.add_option("-f,--floating-type", floatingType, "A floating type.");

  double floatingRange = 2.0;
  pipeline.add_option("--floating-range", floatingRange, "A floating type with a range check.")->check(CLI::Range(1.0, 3.0));

  std::vector<double> floatingVector = { 7.0 };
  pipeline.add_option("--floating-vector", floatingVector, "A floating vector.");

  std::vector<double> floatingTypeSize = { 7.0, 8.0 };
  pipeline.add_option("--floating-type-size", floatingTypeSize, "A floating vector with a type size constraint.")->type_size(2);

  std::vector<double> floatingTypeSizeRange = { 7.0, 8.0, 9.0 };
  pipeline.add_option("--floating-type-size-range", floatingTypeSizeRange, "A floating vector with a type size range constraint.")->type_size(2, 3);

  std::string outputTextFile;
  pipeline.add_option("output-text-file", outputTextFile, "The output text file")->required()->group("Files")->type_name("OUTPUT_TEXT_FILE");

  std::string outputBinaryFile;
  pipeline.add_option("output-binary-file", outputBinaryFile, "The output binary file")->required()->group("Files")->type_name("OUTPUT_BINARY_FILE");

  itk::wasm::OutputTextStream outputTextStream;
  pipeline.add_option("output-text-stream", outputTextStream, "The output text stream")->group("Streams")->type_name("OUTPUT_TEXT_STREAM");

  itk::wasm::OutputBinaryStream outputBinaryStream;
  pipeline.add_option("output-binary-stream", outputBinaryStream, "The output binary stream")->group("Streams")->type_name("OUTPUT_BINARY_STREAM");

  itk::wasm::OutputTextStream outputJson;
  pipeline.add_option("output-json", outputJson, "The output json")->type_name("OUTPUT_JSON");

  using OutputImageType = itk::wasm::OutputImage<ImageType>;
  OutputImageType outputImage;
  pipeline.add_option("output-image", outputImage, "The output image")->required()->group("Images")->type_name("OUTPUT_IMAGE");

  using OutputMeshType = itk::wasm::OutputMesh<MeshType>;
  OutputMeshType outputMesh;
  pipeline.add_option("output-mesh", outputMesh, "The output mesh")->required()->group("Meshes")->type_name("OUTPUT_MESH");

  ITK_WASM_PARSE(pipeline);

  const size_t bufferLength = 2048;
  char * buffer = new char[bufferLength];
  size_t readLength = 0;

  std::ifstream inputTxtFile( inputTextFile, std::ifstream::in );
  if(!inputTxtFile.is_open())
    {
    std::cerr << "Could not open inputTextFile." << std::endl;
    delete[] buffer;
    return EXIT_FAILURE;
    }
  inputTxtFile.read( buffer, bufferLength );
  readLength = inputTxtFile.gcount();
  inputTxtFile.close();
  buffer[readLength] = '\0';

  std::ofstream outputFileTxt( outputTextFile, std::ofstream::out );
  if( !outputFileTxt.is_open() )
    {
    std::cerr << "Could not open outputTxtFile." << std::endl;
    delete[] buffer;
    return EXIT_FAILURE;
    }
  outputFileTxt.write( buffer, readLength );
  outputFileTxt.close();

  std::ifstream inputBinFile( inputBinaryFile, std::ifstream::in | std::ifstream::binary );
  if( !inputBinFile.is_open() )
    {
    std::cerr << "Could not open inputBinFile." << std::endl;
    delete[] buffer;
    return EXIT_FAILURE;
    }
  inputBinFile.read( buffer, bufferLength );
  readLength = inputBinFile.gcount();
  inputBinFile.close();

  std::ofstream outputBinFile( outputBinaryFile, std::ofstream::out | std::ofstream::binary );
  if( !outputBinFile.is_open() )
    {
    std::cerr << "Could not open outputBinFile." << std::endl;
    delete[] buffer;
    return EXIT_FAILURE;
    }
  outputBinFile.write( buffer, readLength );
  outputBinFile.close();

  std::istream & inputTxtStream = inputTextStream.Get();
  inputTxtStream.read( buffer, bufferLength );
  readLength = inputTxtStream.gcount();
  buffer[readLength] = '\0';

  outputTextStream.Get().write( buffer, readLength );

  inputBinaryStream.Get().read( buffer, bufferLength );
  readLength = inputBinaryStream.Get().gcount();

  outputBinaryStream.Get().write( buffer, readLength );

  std::istream & inputTxtJson = inputJson.Get();
  inputTxtJson.read( buffer, bufferLength );
  readLength = inputTxtJson.gcount();
  buffer[readLength] = '\0';

  outputJson.Get().write( buffer, readLength );

  outputImage.Set(inputImage.Get());

  outputMesh.Set(inputMesh.Get());

  delete[] buffer;

  return EXIT_SUCCESS;
}