/*=========================================================================
 *
 *  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 <fstream>
#include <iostream>
#include <iomanip>

int main( int argc, char * argv[] )
{
  itk::wasm::Pipeline pipeline("input-output-files-test", "A pipeline to test general binary and text IO", argc, argv);

  bool useFiles = false;
  pipeline.add_flag("-f,--use-files", useFiles, "Use files -- otherwise use stream objects");


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

  itk::wasm::OutputTextStream outputTextStream;
  pipeline.add_option("output-text-stream", outputTextStream, "The output text stream")->group("Streams")->type_name("OUTPUT_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::OutputBinaryStream outputBinaryStream;
  pipeline.add_option("output-binary-stream", outputBinaryStream, "The output binary stream")->group("Streams")->type_name("OUTPUT_BINARY_STREAM");


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

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

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

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


  ITK_WASM_PARSE(pipeline);

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

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

  std::cout << "Input text: " << buffer << std::endl;


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


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

  std::cerr << "Input binary: ";
  for( size_t ii = 0; ii < readLength; ++ii )
    {
    std::cerr << std::hex << std::setfill('0') << std::setw(2) << int(buffer[ii]);
    }
  std::cerr << std::endl;


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

  delete[] buffer;
  return EXIT_SUCCESS;
}