/******************************************************************************
 ** Filename: clusttool.cpp
 ** Purpose:  Misc. tools for use with the clustering routines
 ** Author:   Dan Johnson
 **
 ** (c) Copyright Hewlett-Packard Company, 1988.
 ** 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
 ** http://www.apache.org/licenses/LICENSE-2.0
 ** 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.
 *****************************************************************************/

#define _USE_MATH_DEFINES // for M_PI

#include "clusttool.h"

#include <cmath>   // for M_PI, std::isnan
#include <locale>  // for std::locale::classic
#include <sstream> // for std::stringstream

namespace tesseract {

//---------------Global Data Definitions and Declarations--------------------
#define TOKENSIZE 80 ///< max size of tokens read from an input file
#define QUOTED_TOKENSIZE "79"
#define MAXSAMPLESIZE 65535 ///< max num of dimensions in feature space

/**
 * This routine reads N floats from the specified text file
 * and places them into Buffer.  If Buffer is nullptr, a buffer
 * is created and passed back to the caller.  If EOF is
 * encountered before any floats can be read, nullptr is
 * returned.
 * @param fp open text file to read floats from
 * @param N number of floats to read
 * @param Buffer pointer to buffer to place floats into
 * @return Pointer to buffer holding floats or nullptr if EOF
 * @note Globals: None
 */
static bool ReadNFloats(TFile *fp, uint16_t N, float Buffer[]) {
  const int kMaxLineSize = 1024;
  char line[kMaxLineSize];
  if (fp->FGets(line, kMaxLineSize) == nullptr) {
    tprintf("Hit EOF in ReadNFloats!\n");
    return false;
  }

  std::stringstream stream(line);
  // Use "C" locale (needed for float values Buffer[i]).
  stream.imbue(std::locale::classic());
  for (uint16_t i = 0; i < N; i++) {
    float f = NAN;
    stream >> f;
    if (std::isnan(f)) {
      tprintf("Read of %u floats failed!\n", N);
      return false;
    }
    Buffer[i] = f;
  }
  return true;
}

/**
 * This routine writes a text representation of N floats from
 * an array to a file.  All of the floats are placed on one line.
 * @param File open text file to write N floats to
 * @param N number of floats to write
 * @param Array array of floats to write
 */
static void WriteNFloats(FILE *File, uint16_t N, float Array[]) {
  for (int i = 0; i < N; i++) {
    fprintf(File, " %9.6f", Array[i]);
  }
  fprintf(File, "\n");
}

/**
 * This routine writes to the specified text file a word
 * which represents the ProtoStyle.  It does not append
 * a carriage return to the end.
 * @param File open text file to write prototype style to
 * @param ProtoStyle prototype style to write
 */
static void WriteProtoStyle(FILE *File, PROTOSTYLE ProtoStyle) {
  switch (ProtoStyle) {
    case spherical:
      fprintf(File, "spherical");
      break;
    case elliptical:
      fprintf(File, "elliptical");
      break;
    case mixed:
      fprintf(File, "mixed");
      break;
    case automatic:
      fprintf(File, "automatic");
      break;
  }
}

/**
 * This routine reads a single integer from the specified
 * file and checks to ensure that it is between 0 and
 * MAXSAMPLESIZE.
 * @param fp open text file to read sample size from
 * @return Sample size
 * @note Globals: None
 */
uint16_t ReadSampleSize(TFile *fp) {
  int SampleSize = 0;

  const int kMaxLineSize = 100;
  char line[kMaxLineSize];
  ASSERT_HOST(fp->FGets(line, kMaxLineSize) != nullptr);
  ASSERT_HOST(sscanf(line, "%d", &SampleSize) == 1);
  ASSERT_HOST(SampleSize >= 0 && SampleSize <= MAXSAMPLESIZE);
  return SampleSize;
}

/**
 * This routine reads textual descriptions of sets of parameters
 * which describe the characteristics of feature dimensions.
 *
 * @param fp open text file to read N parameter descriptions from
 * @param N number of parameter descriptions to read
 * @return Pointer to an array of parameter descriptors.
 * @note Globals: None
 */
PARAM_DESC *ReadParamDesc(TFile *fp, uint16_t N) {
  auto ParamDesc = new PARAM_DESC[N];
  for (int i = 0; i < N; i++) {
    const int kMaxLineSize = TOKENSIZE * 4;
    char line[kMaxLineSize];
    ASSERT_HOST(fp->FGets(line, kMaxLineSize) != nullptr);
    std::istringstream stream(line);
    // Use "C" locale (needed for float values Min, Max).
    stream.imbue(std::locale::classic());
    std::string linear_token;
    stream >> linear_token;
    std::string essential_token;
    stream >> essential_token;
    stream >> ParamDesc[i].Min;
    stream >> ParamDesc[i].Max;
    ASSERT_HOST(!stream.fail());
    ParamDesc[i].Circular = (linear_token[0] == 'c');
    ParamDesc[i].NonEssential = (essential_token[0] != 'e');
    ParamDesc[i].Range = ParamDesc[i].Max - ParamDesc[i].Min;
    ParamDesc[i].HalfRange = ParamDesc[i].Range / 2;
    ParamDesc[i].MidRange = (ParamDesc[i].Max + ParamDesc[i].Min) / 2;
  }
  return (ParamDesc);
}

/**
 * This routine reads a textual description of a prototype from
 * the specified file.
 *
 * @param fp open text file to read prototype from
 * @param N number of dimensions used in prototype
 * @return List of prototypes
 * @note Globals: None
 */
PROTOTYPE *ReadPrototype(TFile *fp, uint16_t N) {
  char sig_token[TOKENSIZE], shape_token[TOKENSIZE];
  int SampleCount;
  int i;

  const int kMaxLineSize = TOKENSIZE * 4;
  char line[kMaxLineSize];
  if (fp->FGets(line, kMaxLineSize) == nullptr ||
      sscanf(line, "%" QUOTED_TOKENSIZE "s %" QUOTED_TOKENSIZE "s %d", sig_token, shape_token,
             &SampleCount) != 3) {
    tprintf("Invalid prototype: %s\n", line);
    return nullptr;
  }
  auto Proto = new PROTOTYPE;
  Proto->Cluster = nullptr;
  Proto->Significant = (sig_token[0] == 's');

  switch (shape_token[0]) {
    case 's':
      Proto->Style = spherical;
      break;
    case 'e':
      Proto->Style = elliptical;
      break;
    case 'a':
      Proto->Style = automatic;
      break;
    default:
      tprintf("Invalid prototype style specification:%s\n", shape_token);
      Proto->Style = elliptical;
  }

  ASSERT_HOST(SampleCount >= 0);
  Proto->NumSamples = SampleCount;

  Proto->Mean.resize(N);
  ReadNFloats(fp, N, &Proto->Mean[0]);

  switch (Proto->Style) {
    case spherical:
      ReadNFloats(fp, 1, &(Proto->Variance.Spherical));
      Proto->Magnitude.Spherical = 1.0 / sqrt(2.0 * M_PI * Proto->Variance.Spherical);
      Proto->TotalMagnitude = std::pow(Proto->Magnitude.Spherical, static_cast<float>(N));
      Proto->LogMagnitude = log(static_cast<double>(Proto->TotalMagnitude));
      Proto->Weight.Spherical = 1.0 / Proto->Variance.Spherical;
      Proto->Distrib.clear();
      break;
    case elliptical:
      Proto->Variance.Elliptical = new float[N];
      ReadNFloats(fp, N, Proto->Variance.Elliptical);
      Proto->Magnitude.Elliptical = new float[N];
      Proto->Weight.Elliptical = new float[N];
      Proto->TotalMagnitude = 1.0;
      for (i = 0; i < N; i++) {
        Proto->Magnitude.Elliptical[i] = 1.0f / sqrt(2.0f * M_PI * Proto->Variance.Elliptical[i]);
        Proto->Weight.Elliptical[i] = 1.0f / Proto->Variance.Elliptical[i];
        Proto->TotalMagnitude *= Proto->Magnitude.Elliptical[i];
      }
      Proto->LogMagnitude = log(static_cast<double>(Proto->TotalMagnitude));
      Proto->Distrib.clear();
      break;
    default:
      delete Proto;
      tprintf("Invalid prototype style\n");
      return nullptr;
  }
  return Proto;
}

/**
 * This routine writes an array of dimension descriptors to
 * the specified text file.
 * @param File open text file to write param descriptors to
 * @param N number of param descriptors to write
 * @param ParamDesc array of param descriptors to write
 */
void WriteParamDesc(FILE *File, uint16_t N, const PARAM_DESC ParamDesc[]) {
  int i;

  for (i = 0; i < N; i++) {
    if (ParamDesc[i].Circular) {
      fprintf(File, "circular ");
    } else {
      fprintf(File, "linear   ");
    }

    if (ParamDesc[i].NonEssential) {
      fprintf(File, "non-essential ");
    } else {
      fprintf(File, "essential     ");
    }

    fprintf(File, "%10.6f %10.6f\n", ParamDesc[i].Min, ParamDesc[i].Max);
  }
}

/**
 * This routine writes a textual description of a prototype
 * to the specified text file.
 * @param File open text file to write prototype to
 * @param N number of dimensions in feature space
 * @param Proto prototype to write out
 */
void WritePrototype(FILE *File, uint16_t N, PROTOTYPE *Proto) {
  int i;

  if (Proto->Significant) {
    fprintf(File, "significant   ");
  } else {
    fprintf(File, "insignificant ");
  }
  WriteProtoStyle(File, static_cast<PROTOSTYLE>(Proto->Style));
  fprintf(File, "%6d\n\t", Proto->NumSamples);
  WriteNFloats(File, N, &Proto->Mean[0]);
  fprintf(File, "\t");

  switch (Proto->Style) {
    case spherical:
      WriteNFloats(File, 1, &(Proto->Variance.Spherical));
      break;
    case elliptical:
      WriteNFloats(File, N, Proto->Variance.Elliptical);
      break;
    case mixed:
      for (i = 0; i < N; i++) {
        switch (Proto->Distrib[i]) {
          case normal:
            fprintf(File, " %9s", "normal");
            break;
          case uniform:
            fprintf(File, " %9s", "uniform");
            break;
          case D_random:
            fprintf(File, " %9s", "random");
            break;
          case DISTRIBUTION_COUNT:
            ASSERT_HOST(!"Distribution count not allowed!");
        }
      }
      fprintf(File, "\n\t");
      WriteNFloats(File, N, Proto->Variance.Elliptical);
  }
}

} // namespace tesseract
