/*
* File:   InsaneWorker.cpp
* Author: Saleem Edah-Tally - nmset@yandex.com
* License : CeCILL-C
* Copyright Saleem Edah-Tally - © 2024
*
* Created on 14 02 2024, 13:00
*/

#include "InsaneWorker.h"
#include <iostream>
#include <iomanip>
#include <sstream>
#include <fstream>
#include <paper.h>
#include <libinsane/safebet.h>
#include <libinsane/error.h>
#include <libinsane/util.h>
#include <libinsane/normalizers.h>
#include <libinsane/constants.h>

using namespace std;

#define IERR(e) ("[" + to_string(e) + "] " + lis_strerror(e))
static bool gs_cancelRequested = false;

InsaneWorker::InsaneWorker ( InsaneWorkerEvent * evh )
{
  m_evh = evh;
}

InsaneWorker::~InsaneWorker()
{
  if (m_api)
    m_api->cleanup(m_api);
}

bool InsaneWorker::Init()
{
  // Terminate a previous one.
  if (m_api)
  {
    m_devices.clear();
    m_deviceId.clear();
    m_api->cleanup(m_api);
    m_sourceItem = nullptr;
    m_rootSourceItem = nullptr;
  }
  lis_error err;
  err = lis_safebet ( &m_api );
  if ( err )
  {
    if ( m_evh )
    {
      m_evh->OnInsaneError ( IERR(err) );
      return false;
    }
  }

  lis_device_descriptor ** devices = nullptr; // nullptr terminated.
  err = m_api->list_devices ( m_api, LIS_DEVICE_LOCATIONS_LOCAL_ONLY, &devices ); // Gets network scanners though.
  if ( err )
  {
    m_evh->OnInsaneError ( IERR(err) );
    return false;
  }

  uint numberOfDevices = 0;
  for ( uint i = 0; devices[i] != nullptr; i++ )
  {
    numberOfDevices++;
  }
  // Collect available descriptions for all devices.
  for ( uint i = 0; i < numberOfDevices; i++ )
  {
    DeviceDescriptor dd;
    lis_device_descriptor * descriptor = devices[i];
    dd.id = descriptor->dev_id;
    dd.model = descriptor->model;
    dd.type = descriptor->type;
    dd.vendor = descriptor->vendor;
    m_devices.push_back(dd);
  }

  return true;
}

// Determine if a source item is a feeder.
int InsaneWorker::IsADF(const std::string& deviceId, int sourceChildIndex)
{
  if ( !m_api )
  {
    if ( m_evh )
    {
      m_evh->OnError ( "Insane api is NULL; has Init() been called?");
      return -1;
    }
  }
  lis_error err;
  lis_item * rootSourceItem = nullptr;
  err = m_api->get_device ( m_api, deviceId.c_str(), &rootSourceItem );
  if ( err )
  {
    if ( m_evh )
      m_evh->OnInsaneError ( IERR ( err ) );
    return false;
  }
  lis_item ** children = nullptr;
  err = rootSourceItem->get_children(rootSourceItem, &children);
  if ( err )
  {
    if ( m_evh )
      m_evh->OnInsaneError ( IERR ( err ) );
    return -1;
  }

  bool adf = (children[sourceChildIndex]->type == LIS_ITEM_ADF);
  rootSourceItem->close(rootSourceItem);
  return adf;
}

// Ex: all supported resolutions.
std::string InsaneWorker::GetOptionPossibleValues(const std::string& deviceId,
                                          const std::string& optionName, std::vector<std::string>& possible)
{
  if ( !m_api )
  {
    if ( m_evh )
    {
      m_evh->OnError ( "Insane api is NULL; has Init() been called?");
      return "";
    }
  }
  lis_error err;
  lis_item * item = nullptr;
  err = m_api->get_device ( m_api, deviceId.c_str(), &item );
  if ( err )
  {
    if ( m_evh )
      m_evh->OnInsaneError ( IERR ( err ) );
    return "";
  }

  lis_option_descriptor ** options = nullptr;
  err = item->get_options ( item, &options );
  if ( err )
  {
    if ( m_evh )
      m_evh->OnInsaneError ( IERR ( err ) );
    item->close(item);
    return "";
  }
  uint numberOfOptions = 0;
  for ( uint i = 0; options[i] != nullptr; i++ )
  {
    numberOfOptions++;
  }

  std::string defaultValue;
  for ( uint i = 0; i < numberOfOptions; i++ )
  {
    lis_option_descriptor * optionDescriptor = options[i];
    const std::string name = optionDescriptor->name;
    if ( ToLower(name) != optionName )
      continue;
    union lis_value value;
    err = optionDescriptor->fn.get_value ( optionDescriptor, &value );
    if ( err )
    {
      if ( m_evh )
        m_evh->OnInsaneError ( IERR ( err ) );
      item->close(item);
      return "";
    }
    lis_value_type type = optionDescriptor->value.type;
    bool isString = false;
    switch ( type )
    {
    case LIS_TYPE_BOOL:
      defaultValue = std::to_string(( bool ) value.boolean);
      break;
    case LIS_TYPE_INTEGER:
      defaultValue = std::to_string(( long ) value.integer);
      break;
    case LIS_TYPE_DOUBLE:
      defaultValue = std::to_string(( double ) value.dbl);
      break;
    case LIS_TYPE_STRING:
      isString = true;
      defaultValue = value.string;
      break;
    case LIS_TYPE_IMAGE_FORMAT:
      defaultValue = "Unmanaged";
      break;
    default:
      defaultValue = "Unknown";
      break;
    }
    lis_value_list valueList = optionDescriptor->constraint.possible.list;
    int numberOfListItems = valueList.nb_values;
    if ( numberOfListItems )
    {
      for ( int j = 0; j < numberOfListItems; j++ )
      {
        if ( isString )
          possible.push_back( valueList.values[j].string );
        else
          possible.push_back( std::to_string ( valueList.values[j].integer ) );
      }
    }
  }

  item->close(item);
  return defaultValue;
}

// Open a source item and prepare for the next step, i.e, scanning.
bool InsaneWorker::ConfigureDevice(const std::string& deviceId,
                                   const std::string& source, int sourceChildIndex,
                                   const std::string& mode, int resolution,
                                   const std::string& paperSize)
{
  if ( !m_api )
  {
    if ( m_evh )
    {
      m_evh->OnError ( "Insane api is NULL; has Init() been called?");
      return false;
    }
  }
  m_deviceId = deviceId;
  m_source = source;
  m_sourceChildIndex = (sourceChildIndex > -1) ? sourceChildIndex : 0;
  m_mode = mode;
  m_resolution = resolution;
  m_paperSize = paperSize;

  lis_error err;

  err = m_api->get_device ( m_api, m_deviceId.c_str(), &m_rootSourceItem );
  if ( err )
  {
    if ( m_evh )
      m_evh->OnInsaneError ( IERR ( err ) );
    return false;
  }

  lis_item ** children = nullptr;
  err = m_rootSourceItem->get_children(m_rootSourceItem, &children);
  if ( err )
  {
    if ( m_evh )
      m_evh->OnInsaneError ( IERR ( err ) );
    return false;
  }
  
  // Selecting a lis_item by the source index.
  // One child item is created by libinsane if there is no source: v4l.
  m_sourceItem = children[m_sourceChildIndex];
  if (!m_sourceItem)
  {
    if (m_evh)
      m_evh->OnError("Could not determine a device item");
    m_rootSourceItem->close(m_rootSourceItem);
    return false;
  }

  // Error status not checked; use defaults if failure.
  lis_set_option(m_sourceItem, OPT_NAME_MODE, mode.c_str());
  /*
   * Selecting a source on a child item that has been selected by a source index.
   * Sounds weird but needed.
   */
  lis_set_option(m_sourceItem, OPT_NAME_SOURCE, source.c_str());
  if (resolution > 0) // No resolution with v4l devices.
    lis_set_option(m_sourceItem, OPT_NAME_RESOLUTION, to_string(resolution).c_str());
  pair<double, double> br;
  if (GetBottomRight(br))
  {
    // For v4l, these do not get applied.
    lis_set_option(m_sourceItem, "br-x", to_string(br.first).c_str());
    lis_set_option(m_sourceItem, "br-y", to_string(br.second).c_str());
  }
  
  // Don't close m_rootDeviceItem, it is prepared for ::Scan().
  return true;
}

// Perform scanning: create raw data files.
bool InsaneWorker::Scan(const std::string& dir, const std::string& basename,
                        int startIndex, int padwidth, int increment)
{
  if ( !m_api || !m_sourceItem )
  {
    if ( m_evh )
    {
      m_evh->OnError ( "Insane api or device item is NULL, cannot scan.");
      return false;
    }
  }
  if (dir.empty() || basename.empty() || startIndex < 0 || padwidth < 0 || (increment == 0))
  {
    if ( m_evh )
    {
      m_evh->OnError ( "Invalid input, cannot scan.");
      return false;
    }
  }
  auto makeFileName = [&] (int index)
  {
    // std:format is not friendly with a variable padwidth; requires a literal format.
    stringstream ss;
    ss << setfill('0') << setw(padwidth) << index;
    return (dir + "/" + basename + "-" + ss.str());
  };

  lis_error err;
  
  lis_scan_session * session;
  // Scanning starts here on device.
  err = m_sourceItem->scan_start(m_sourceItem, &session);
  if (err || !session)
  {
    if ( m_evh )
      m_evh->OnInsaneError ( IERR ( err ) );
    return false;
  }

  lis_scan_parameters parameters; // DO NOT use a POINTER here.
  err = session->get_scan_parameters(session, &parameters);
  if (err)
  {
    if ( m_evh )
      m_evh->OnInsaneError ( IERR ( err ) );
    return false;
  }

  /*
   * format is troublesome: always 0.
   * But for LineArt, in the logs, sane_get_parameters() returns format=1 (v4l)
   * or format=2 (remote).
   */
  // lis_img_format format = parameters.format; // guaranteed, but always 0, even for LineArt.
  const int lineArtFactor = (m_mode == string("LineArt") ? 3 : 1); // insane always outputs RGB.
  int imageWidth = parameters.width; // pixels, guaranteed.
  int imageHeight = parameters.height; // pixels, not guaranteed.
  size_t imageSize = parameters.image_size * lineArtFactor; // bytes, not guaranteed.
  InsaneWorkerEvent::ImageAttributes imageAttributes;
  imageAttributes.size = imageSize;
  imageAttributes.width = imageWidth;
  imageAttributes.height = imageHeight;

  // This file is valid raw pixels. It can be converted with rawtoppm and rawtopgm.
  uint pageIndex = startIndex;
  string filePath = makeFileName(pageIndex);
  const int bytesPerRow = imageSize / imageHeight;
  /*
   * Needs confirmation.
   * LineArt : 1 pixel = 1 bit - maximum resolution = 9600
   * Gray : 1 pixel = 1 byte - maximum resolution = 2400
   * Color : 1 pixel = 3 bytes - maximum resolution = 600
   * 
   * A4, LineArt, 4800: 1690000620 bytes file OK (1.6 GiB).
   * Above that resolution:
   * std::bad_alloc - 1993034797 bytes (1.856 GiB) cannot be allocated
   * for one row. System with 64 GB RAM.
   */

  if (m_evh)
    m_evh->OnStartScanSession(startIndex, imageAttributes);
  do
  {
    ofstream outFile;
    if (m_evh)
      m_evh->OnPageStartScan(filePath, pageIndex, imageAttributes);
    do
    {
      if (gs_cancelRequested)
      {
        session->cancel(session);
        if (m_evh)
          m_evh->OnSessionCancelled(filePath);
        gs_cancelRequested = false;
        return false;
      }
      try
      {
        char * readBytes = new char[bytesPerRow];
        size_t bufferSize = bytesPerRow;
        err = session->scan_read(session, readBytes, &bufferSize); // bufferSize is in/out.
        if (LIS_IS_ERROR(err))
        {
          delete[] readBytes;
          if (m_evh)
            m_evh->OnSessionReadError(filePath);
          return false;
        }
        /*
        * bufferSize == 0 does not mean end_of_page or end of file.
        * But we get here when end_of_feed is false while there's nothing more to read.
        */
        if (bufferSize)
        {
          if (!outFile.is_open())
            outFile.open(filePath, ios::binary | ios::trunc);
          outFile.write((const char*) readBytes, bufferSize);
        }
        delete[] readBytes;
        }
      catch (std::bad_alloc& e)
      {
        m_rootSourceItem->close(m_rootSourceItem);
        cout << "ABORT: " << e.what() << " - could not allocate " << bytesPerRow << " bytes." << endl;
        if (m_evh)
          m_evh->OnError("Insufficient system RAM.");
        return false;
      }
    } while (!session->end_of_page(session));
    /*
     * end_of_feed may return false though there is no more to read.
     * If outFile is not open, nothing was read; don't call OnPageEndScan.
     */
    bool outFileWasOpen = outFile.is_open();
    // It may not have been opened.
    outFile.flush();
    outFile.close();
    if (m_evh && outFileWasOpen)
      m_evh->OnPageEndScan(filePath, pageIndex, imageAttributes);
    pageIndex += increment;
    if (m_sourceItem->type != LIS_ITEM_ADF) // v4l also
      break;
    filePath = makeFileName(pageIndex);
  } while( !session->end_of_feed(session));
  if (m_evh)
    m_evh->OnEndScanSession(pageIndex - increment, imageAttributes);

  /*
   * Don't close the child item.
   * A v4l device may become unusable after the first capture (its child source
   * item may have been faked by libinsane if it had none).
   * Real scanners sustain both situations so far.
   */
  m_rootSourceItem->close(m_rootSourceItem); // Root.
  return true;
}

// Determine the page extent.
bool InsaneWorker::GetBottomRight(std::pair<double, double>& br)
{
  int res = paperinit();
  if (res != PAPER_OK)
  {
    const string msg = "Could not initialise the paper library.";
    cerr << msg << endl;
    if (m_evh)
      m_evh->OnError(msg);
    return false;
  }
  
  const paper * p = paperinfo(m_paperSize.c_str());
  if (!p)
  {
    string msg = "Failed to find the requested paper; attempt to use a default paper size.";
    cerr << msg << endl;
    if (m_evh)
      m_evh->OnError(msg);
    p = defaultpaper();
    if (!p)
    {
      msg = "Failed to find a default paper size; using the default scanner sizes.";
      cerr << msg << endl;
      if (m_evh)
        m_evh->OnError(msg);
      return false;
    }
  }

  int unit = paperunit(p);
  double conversionFactor = 1.0;
  if (unit == PAPER_UNIT_MM)
    conversionFactor = 1.0;
  else if (unit == PAPER_UNIT_IN)
    conversionFactor = 25.4;
  else
  {
    const string msg = "The measurement unit of the paper size is not handled; using the default scanner sizes.";
    cerr << msg << endl;
    if (m_evh)
      m_evh->OnError(msg);
    return false;
  }

  br.first = paperwidth(p) * conversionFactor;
  br.second = paperheight(p) * conversionFactor;

  res = paperdone();
  if (res != PAPER_OK)
  {
    const string msg = "Could not cleanly end the paper library.";
    cerr << msg << endl;
    if (m_evh)
      m_evh->OnError(msg);
  }
  return true;
}


std::string InsaneWorker::ToLower(const std::string& input)
{
  // We are dealing with single byte characters.
  string output;
  for ( char c : input )
    output.append ( 1, std::tolower ( c ) );
  return output;
}

void InsaneWorker::Cancel()
{
  gs_cancelRequested = true;
}

std::pair<int, int> InsaneWorker::UpdateStartAndIncrement(const int startPageIndex, const int increment,
                                                          const bool adf, const bool doubleSided, const int total)
{
  int newStartPageIndex = startPageIndex;
  int newIncrement = increment;
  int totalEven = total;
  if (total % 2)
    totalEven++;
  // Scanning forward before max.
  if ((increment > 0) && adf && doubleSided && (startPageIndex < (totalEven - 2)))
  {
    newIncrement = 2;
    newStartPageIndex += newIncrement;
  }
  // Scanning forward at max.
  else if ((increment > 0) && adf && doubleSided && (startPageIndex == (totalEven - 2)))
  {
    newIncrement = -2;
    newStartPageIndex++;
  }
  // Scanning backward.
  else if ((increment < 0) && adf && doubleSided && (startPageIndex <= (totalEven - 1)))
  {
    newIncrement = -2;
    newStartPageIndex += newIncrement;
  }
  else
  {
    newIncrement = 1;
    newStartPageIndex++;
  }
  
  std::pair<int, int> result = {newStartPageIndex, newIncrement};
  return result;
}

// ----------------------------------------------------------------------------
InsaneWorkerEvent::InsaneWorkerEvent()
{}

InsaneWorkerEvent::~InsaneWorkerEvent()
{}

void InsaneWorkerEvent::OnInsaneError ( const std::string& message )
{}

void InsaneWorkerEvent::OnError ( const std::string& message )
{}

void InsaneWorkerEvent::OnSessionCancelled(const std::string& filePath)
{}

void InsaneWorkerEvent::OnSessionReadError(const std::string& filePath)
{}

void InsaneWorkerEvent::OnPageStartScan(const std::string& filePath,uint pageIndex, const ImageAttributes& imageAttributes)
{}

void InsaneWorkerEvent::OnPageEndScan(const std::string& filePath, uint pageIndex, const ImageAttributes& imageAttributes)
{}

void InsaneWorkerEvent::OnStartScanSession(uint pageIndex, const ImageAttributes& imageAttributes)
{}

void InsaneWorkerEvent::OnEndScanSession(uint pageIndex, const ImageAttributes& imageAttributes)
{}