// File:        pagerenderer.cpp
// Description: PAGE XML rendering interface
// Author:      Jan Kamlah

// (C) Copyright 2024
// 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.

#include "errcode.h" // for ASSERT_HOST
#include "helpers.h" // for copy_string
#include "tprintf.h" // for tprintf

#include <tesseract/baseapi.h>
#include <tesseract/renderer.h>

#include <ctime>
#include <iomanip>
#include <memory>
#include <regex>
#include <sstream> // for std::stringstream
#include <unordered_set>

#include <allheaders.h>
#if (LIBLEPT_MAJOR_VERSION == 1 && LIBLEPT_MINOR_VERSION >= 83) || \
    LIBLEPT_MAJOR_VERSION > 1
#  include <array_internal.h>
#  include <pix_internal.h>
#endif

namespace tesseract {

///
/// Slope and offset between two points
///
static void GetSlopeAndOffset(float x0, float y0, float x1, float y1, float *m,
                              float *b) {
  float slope;

  slope = ((y1 - y0) / (x1 - x0));
  *m = slope;
  *b = y0 - slope * x0;
}

///
/// Write coordinates in the form of a points to a stream
///
static void AddPointsToPAGE(Pta *pts, std::stringstream &str) {
  int num_pts;

  str << "<Coords points=\"";
  num_pts = ptaGetCount(pts);
  for (int p = 0; p < num_pts; ++p) {
    int x, y;
    ptaGetIPt(pts, p, &x, &y);
    if (p != 0) {
      str << " ";
    }
    str << std::to_string(x) << "," << std::to_string(y);
  }
  str << "\"/>\n";
}

///
/// Convert bbox information to top and bottom polygon
///
static void AddPointToWordPolygon(
    const ResultIterator *res_it, PageIteratorLevel level, Pta *word_top_pts,
    Pta *word_bottom_pts, tesseract::WritingDirection writing_direction) {
  int left, top, right, bottom;

  res_it->BoundingBox(level, &left, &top, &right, &bottom);

  if (writing_direction != WRITING_DIRECTION_TOP_TO_BOTTOM) {
    ptaAddPt(word_top_pts, left, top);
    ptaAddPt(word_top_pts, right, top);

    ptaAddPt(word_bottom_pts, left, bottom);
    ptaAddPt(word_bottom_pts, right, bottom);

  } else {
    // Transform from ttb to ltr
    ptaAddPt(word_top_pts, top, right);
    ptaAddPt(word_top_pts, bottom, right);

    ptaAddPt(word_bottom_pts, top, left);
    ptaAddPt(word_bottom_pts, bottom, left);
  }
}

///
/// Transpose polygonline, destroy old and return new pts
///
static Pta *TransposePolygonline(Pta *pts) {
  Pta *pts_transposed;

  pts_transposed = ptaTranspose(pts);
  ptaDestroy(&pts);
  return pts_transposed;
}

///
/// Reverse polygonline, destroy old and return new pts
///
static Pta *ReversePolygonline(Pta *pts, int type) {
  Pta *pts_reversed;

  pts_reversed = ptaReverse(pts, type);
  ptaDestroy(&pts);
  return pts_reversed;
}

///
/// Destroy old and create new pts
///
static Pta *DestroyAndCreatePta(Pta *pts) {
  ptaDestroy(&pts);
  return ptaCreate(0);
}

///
/// Recalculate linepolygon
/// Create a hull for overlapping areas
///
static Pta *RecalcPolygonline(Pta *pts, bool upper) {
  int num_pts, num_bin, index = 0;
  int x0, y0, x1, y1;
  float x_min, y_min, x_max, y_max;
  NUMA *bin_line;
  Pta *pts_recalc;

  ptaGetMinMax(pts, &x_min, &y_min, &x_max, &y_max);
  num_bin = x_max - x_min;
  bin_line = numaCreate(num_bin + 1);

  for (int p = 0; p <= num_bin; ++p) {
    bin_line->array[p] = -1.0f;
  }

  num_pts = ptaGetCount(pts);

  if (num_pts == 2) {
    pts_recalc = ptaCopy(pts);
    ptaDestroy(&pts);
    return pts_recalc;
  }

  do {
    ptaGetIPt(pts, index, &x0, &y0);
    ptaGetIPt(pts, index + 1, &x1, &y1);
    for (int p = x0 - x_min; p <= x1 - x_min; ++p) {
      if (!upper) {
        if (bin_line->array[p] == -1.0f || y0 > bin_line->array[p]) {
          bin_line->array[p] = y0;
        }
      } else {
        if (bin_line->array[p] == -1.0f || y0 < bin_line->array[p]) {
          bin_line->array[p] = y0;
        }
      }
    }
    index += 2;
  } while (index < num_pts - 1);

  pts_recalc = ptaCreate(0);

  int y = static_cast<int>(bin_line->array[0]);
  ptaAddPt(pts_recalc, x_min, y);
  for (int p = 1; p <= num_bin; ++p) {
    if (p == num_bin) {
      ptaAddPt(pts_recalc, x_min + p, y);
      break;
    } else if (y != static_cast<int>(bin_line->array[p])) {
      if (y != -1) {
        ptaAddPt(pts_recalc, x_min + p, y);
      }
      y = static_cast<int>(bin_line->array[p]);
      if (y != -1) {
        ptaAddPt(pts_recalc, x_min + p, y);
      }
    }
  }

  numaDestroy(&bin_line);
  ptaDestroy(&pts);
  return pts_recalc;
}

///
/// Create a rectangle hull around a single line
///
static Pta *PolygonToBoxCoords(Pta *pts) {
  Pta *pts_box;
  float x_min, y_min, x_max, y_max;

  pts_box = ptaCreate(0);
  ptaGetMinMax(pts, &x_min, &y_min, &x_max, &y_max);
  ptaAddPt(pts_box, x_min, y_min);
  ptaAddPt(pts_box, x_max, y_min);
  ptaAddPt(pts_box, x_max, y_max);
  ptaAddPt(pts_box, x_min, y_max);
  ptaDestroy(&pts);
  return pts_box;
}

///
/// Create a rectangle polygon round the existing multiple lines
///
static void UpdateBlockPoints(Pta *block_top_pts, Pta *block_bottom_pts,
                              Pta *line_top_pts, Pta *line_bottom_pts, int lcnt,
                              int last_word_in_cblock) {
  int num_pts;
  int x, y;

  // Create a hull around all lines
  if (lcnt == 0 && last_word_in_cblock) {
    ptaJoin(block_top_pts, line_top_pts, 0, -1);
    ptaJoin(block_bottom_pts, line_bottom_pts, 0, -1);
  } else if (lcnt == 0) {
    ptaJoin(block_top_pts, line_top_pts, 0, -1);
    num_pts = ptaGetCount(line_bottom_pts);
    ptaGetIPt(line_bottom_pts, num_pts - 1, &x, &y);
    ptaAddPt(block_top_pts, x, y);
    ptaGetIPt(line_bottom_pts, 0, &x, &y);
    ptaAddPt(block_bottom_pts, x, y);
  } else if (last_word_in_cblock) {
    ptaGetIPt(line_top_pts, 0, &x, &y);
    ptaAddPt(block_bottom_pts, x, y);
    ptaJoin(block_bottom_pts, line_bottom_pts, 0, -1);
    num_pts = ptaGetCount(line_top_pts);
    ptaGetIPt(line_top_pts, num_pts - 1, &x, &y);
    ptaAddPt(block_top_pts, x, y);
  } else {
    ptaGetIPt(line_top_pts, 0, &x, &y);
    ptaAddPt(block_bottom_pts, x, y);
    ptaGetIPt(line_bottom_pts, 0, &x, &y);
    ptaAddPt(block_bottom_pts, x, y);
    num_pts = ptaGetCount(line_top_pts);
    ptaGetIPt(line_top_pts, num_pts - 1, &x, &y);
    ptaAddPt(block_top_pts, x, y);
    num_pts = ptaGetCount(line_bottom_pts);
    ptaGetIPt(line_bottom_pts, num_pts - 1, &x, &y);
    ptaAddPt(block_top_pts, x, y);
  };
}

///
/// Simplify polygonlines (only expanding not shrinking) (Due to recalculation
/// currently not necessary)
///
static void SimplifyLinePolygon(Pta *polyline, int tolerance, bool upper) {
  int x0, y0, x1, y1, x2, y2, x3, y3, index = 1;
  float m, b, y_min, y_max;

  while (index <= polyline->n - 2) {
    ptaGetIPt(polyline, index - 1, &x0, &y0);
    ptaGetIPt(polyline, index, &x1, &y1);
    ptaGetIPt(polyline, index + 1, &x2, &y2);
    if (index + 2 < polyline->n) {
      // Delete two point indentations
      ptaGetIPt(polyline, index + 2, &x3, &y3);
      if (abs(x3 - x0) <= tolerance * 2) {
        GetSlopeAndOffset(x0, y0, x3, y3, &m, &b);

        if (upper && (m * x1 + b) < y1 && (m * x2 + b) < y2) {
          ptaRemovePt(polyline, index + 1);
          ptaRemovePt(polyline, index);
          continue;
        } else if (!upper && (m * x1 + b) > y1 && (m * x2 + b) > y2) {
          ptaRemovePt(polyline, index + 1);
          ptaRemovePt(polyline, index);
          continue;
        }
      }
    }
    // Delete one point indentations
    if (abs(y0 - y1) <= tolerance && abs(y1 - y2) <= tolerance) {
      GetSlopeAndOffset(x0, y0, x2, y2, &m, &b);
      if (upper && (m * x1 + b) <= y1) {
        ptaRemovePt(polyline, index);
        continue;
      } else if (!upper && (m * x1 + b) >= y1) {
        ptaRemovePt(polyline, index);
        continue;
      }
    }
    // Delete near by points
    if (x1 != x0 && abs(y1 - y0) < 4 && abs(x1 - x0) <= tolerance) {
      if (upper) {
        y_min = std::min(y0, y1);
        GetSlopeAndOffset(x0, y_min, x2, y2, &m, &b);
        if ((m * x1 + b) <= y1) {
          polyline->y[index - 1] = std::min(y0, y1);
          ptaRemovePt(polyline, index);
          continue;
        }
      } else {
        y_max = std::max(y0, y1);
        GetSlopeAndOffset(x0, y_max, x2, y2, &m, &b);
        if ((m * x1 + b) >= y1) {
          polyline->y[index - 1] = y_max;
          ptaRemovePt(polyline, index);
          continue;
        }
      }
    }
    index++;
  }
}

///
/// Directly write bounding box information as coordinates a stream
///
static void AddBoxToPAGE(const ResultIterator *it, PageIteratorLevel level,
                         std::stringstream &page_str) {
  int left, top, right, bottom;

  it->BoundingBox(level, &left, &top, &right, &bottom);
  page_str << "<Coords points=\"" << left << "," << top << " " << right << ","
           << top << " " << right << "," << bottom << " " << left << ","
           << bottom << "\"/>\n";
}

///
/// Join ltr and rtl polygon information
///
static void AppendLinePolygon(Pta *pts_ltr, Pta *pts_rtl, Pta *ptss,
                              tesseract::WritingDirection writing_direction) {
  // If writing direction is NOT right-to-left, handle the left-to-right case.
  if (writing_direction != WRITING_DIRECTION_RIGHT_TO_LEFT) {
    if (ptaGetCount(pts_rtl) != 0) {
      ptaJoin(pts_ltr, pts_rtl, 0, -1);
      DestroyAndCreatePta(pts_rtl);
    }
    ptaJoin(pts_ltr, ptss, 0, -1);
  } else {
    // For right-to-left, work with a copy of ptss initially.
    PTA *ptsd = ptaCopy(ptss);
    if (ptaGetCount(pts_rtl) != 0) {
      ptaJoin(ptsd, pts_rtl, 0, -1);
    }
    ptaDestroy(&pts_rtl);
    ptaCopy(ptsd);
  }
}

///
/// Convert baseline to points and add to polygon
///
static void AddBaselineToPTA(const ResultIterator *it, PageIteratorLevel level,
                             Pta *baseline_pts) {
  int x1, y1, x2, y2;

  it->Baseline(level, &x1, &y1, &x2, &y2);
  ptaAddPt(baseline_pts, x1, y1);
  ptaAddPt(baseline_pts, x2, y2);
}

///
/// Directly write baseline information as baseline points a stream
///
static void AddBaselinePtsToPAGE(Pta *baseline_pts, std::stringstream &str) {
  int x, y, num_pts = baseline_pts->n;

  str << "<Baseline points=\"";
  for (int p = 0; p < num_pts; ++p) {
    ptaGetIPt(baseline_pts, p, &x, &y);
    if (p != 0) {
      str << " ";
    }
    str << std::to_string(x) << "," << std::to_string(y);
  }
  str << "\"/>\n";
}

///
/// Sort baseline points ascending and deleting duplicates
///
static Pta *SortBaseline(Pta *baseline_pts) {
  int num_pts, index = 0;
  float x0, y0, x1, y1;
  Pta *sorted_baseline_pts;

  sorted_baseline_pts =
      ptaSort(baseline_pts, L_SORT_BY_X, L_SORT_INCREASING, nullptr);

  do {
    ptaGetPt(sorted_baseline_pts, index, &x0, &y0);
    ptaGetPt(sorted_baseline_pts, index + 1, &x1, &y1);
    if (x0 >= x1) {
      sorted_baseline_pts->y[index] = std::min(y0, y1);
      ptaRemovePt(sorted_baseline_pts, index + 1);
    } else {
      index++;
    }
    num_pts = ptaGetCount(sorted_baseline_pts);
  } while (index < num_pts - 1);

  ptaDestroy(&baseline_pts);
  return sorted_baseline_pts;
}

///
/// Clip baseline to range of the exsitings polygon and simplifies the baseline
/// linepolygon
///
static Pta *ClipAndSimplifyBaseline(Pta *bottom_pts, Pta *baseline_pts,
                                    tesseract::WritingDirection writing_direction) {
  int num_pts;
  float m, b, x0, y0, x1, y1;
  float x_min, y_min, x_max, y_max;
  Pta *baseline_clipped_pts;

  ptaGetMinMax(bottom_pts, &x_min, &y_min, &x_max, &y_max);
  num_pts = ptaGetCount(baseline_pts);
  baseline_clipped_pts = ptaCreate(0);

  // Clip Baseline
  for (int p = 0; p < num_pts; ++p) {
    ptaGetPt(baseline_pts, p, &x0, &y0);
    if (x0 < x_min) {
      if (p + 1 < num_pts) {
        ptaGetPt(baseline_pts, p + 1, &x1, &y1);
        if (x1 < x_min) {
          continue;
        } else {
          GetSlopeAndOffset(x0, y0, x1, y1, &m, &b);
          y0 = int(x_min * m + b);
          x0 = x_min;
        }
      }
    } else if (x0 > x_max) {
      if (ptaGetCount(baseline_clipped_pts) > 0 && p > 0) {
        ptaGetPt(baseline_pts, p - 1, &x1, &y1);
        // See comment above
        GetSlopeAndOffset(x1, y1, x0, y0, &m, &b);
        y0 = int(x_max * m + b);
        x0 = x_max;
        ptaAddPt(baseline_clipped_pts, x0, y0);
        break;
      }
    }
    ptaAddPt(baseline_clipped_pts, x0, y0);
  }
  if (writing_direction == WRITING_DIRECTION_TOP_TO_BOTTOM) {
    SimplifyLinePolygon(baseline_clipped_pts, 3, 0);
  } else {
    SimplifyLinePolygon(baseline_clipped_pts, 3, 1);
  }
  SimplifyLinePolygon(
      baseline_clipped_pts, 3,
      writing_direction == WRITING_DIRECTION_TOP_TO_BOTTOM ? 0 : 1);

  // Check the number of points in baseline_clipped_pts after processing
  int clipped_pts_count = ptaGetCount(baseline_clipped_pts);

  if (clipped_pts_count < 2) {
    // If there's only one point in baseline_clipped_pts, duplicate it
    ptaDestroy(&baseline_clipped_pts); // Clean up the created but unused Pta
    baseline_clipped_pts = ptaCreate(0);
    ptaAddPt(baseline_clipped_pts, x_min, y_min);
    ptaAddPt(baseline_clipped_pts, x_max, y_min);
  }

  ptaDestroy(&baseline_pts);
  return baseline_clipped_pts;
}

///
/// Fit the baseline points into the existing polygon
///
#if 0 // unused
static Pta *FitBaselineIntoLinePolygon(Pta *bottom_pts, Pta *baseline_pts,
                                       tesseract::WritingDirection writing_direction) {
  int num_pts, num_bin, x0, y0, x1, y1;
  float m, b;
  float x_min, y_min, x_max, y_max;
  float delta_median, delta_median_Q1, delta_median_Q3;
  NUMA *bin_line, *poly_bl_delta;
  Pta *baseline_recalc_pts, *baseline_clipped_pts;

  ptaGetMinMax(bottom_pts, &x_min, &y_min, &x_max, &y_max);
  num_bin = x_max - x_min;
  bin_line = numaCreate(num_bin + 1);

  for (int p = 0; p < num_bin + 1; ++p) {
    bin_line->array[p] = -1.;
  }

  num_pts = ptaGetCount(bottom_pts);
  // Create an interpolated polygon with stepsize 1.
  for (int index = 0; index < num_pts - 1; ++index) {
    ptaGetIPt(bottom_pts, index, &x0, &y0);
    ptaGetIPt(bottom_pts, index + 1, &x1, &y1);
    if (x0 >= x1) {
      continue;
    }
    if (y0 == y1) {
      for (int p = x0 - x_min; p < x1 - x_min + 1; ++p) {
        if (bin_line->array[p] == -1. || y0 > bin_line->array[p]) {
          bin_line->array[p] = y0;
        }
      }
    } else {
      GetSlopeAndOffset(x0, y0, x1, y1, &m, &b);
      for (int p = x0 - x_min; p < x1 - x_min + 1; ++p) {
        if (bin_line->array[p] == -1. ||
            ((p + x_min) * m + b) > bin_line->array[p]) {
          bin_line->array[p] = ((p + x_min) * m + b);
        }
      }
    }
  }

  num_pts = ptaGetCount(baseline_pts);
  baseline_clipped_pts = ptaCreate(0);
  poly_bl_delta = numaCreate(0);

  // Clip Baseline and create a set of deltas between baseline and polygon
  for (int p = 0; p < num_pts; ++p) {
    ptaGetIPt(baseline_pts, p, &x0, &y0);

    if (x0 < x_min) {
      ptaGetIPt(baseline_pts, p + 1, &x1, &y1);
      if (x1 < x_min) {
        continue;
      } else {
        GetSlopeAndOffset(x0, y0, x1, y1, &m, &b);
        y0 = int(x_min * m + b);
        x0 = x_min;
      }
    } else if (x0 > x_max) {
      if (ptaGetCount(baseline_clipped_pts) > 0) {
        ptaGetIPt(baseline_pts, p - 1, &x1, &y1);
        GetSlopeAndOffset(x1, y1, x0, y0, &m, &b);
        y0 = int(x_max * m + b);
        x0 = x_max;
        int x_val = x0 - x_min;
        numaAddNumber(poly_bl_delta, abs(bin_line->array[x_val] - y0));
        ptaAddPt(baseline_clipped_pts, x0, y0);
        break;
      }
    }
    int x_val = x0 - x_min;
    numaAddNumber(poly_bl_delta, abs(bin_line->array[x_val] - y0));
    ptaAddPt(baseline_clipped_pts, x0, y0);
  }

  ptaDestroy(&baseline_pts);

  // Calculate quartiles to find outliers
  numaGetMedian(poly_bl_delta, &delta_median);
  numaGetRankValue(poly_bl_delta, 0.25, nullptr, 0, &delta_median_Q1);
  numaGetRankValue(poly_bl_delta, 0.75, nullptr, 0, &delta_median_Q3);

  // Fit baseline into the polygon
  // Todo: Needs maybe some adjustments to suppress fitting to superscript
  // glyphs
  baseline_recalc_pts = ptaCreate(0);
  num_pts = ptaGetCount(baseline_clipped_pts);
  for (int p = 0; p < num_pts; ++p) {
    ptaGetIPt(baseline_clipped_pts, p, &x0, &y0);
    int x_val = x0 - x_min;
    // Delete outliers with IQR
    if (abs(y0 - bin_line->array[x_val]) >
            1.5 * delta_median_Q3 + delta_median &&
        p != 0 && p != num_pts - 1) {
      continue;
    }
    if (writing_direction == WRITING_DIRECTION_TOP_TO_BOTTOM) {
      if (y0 < bin_line->array[x_val]) {
        ptaAddPt(baseline_recalc_pts, x0, bin_line->array[x_val]);
      } else {
        ptaAddPt(baseline_recalc_pts, x0, y0);
      }
    } else {
      if (y0 > bin_line->array[x_val]) {
        ptaAddPt(baseline_recalc_pts, x0, bin_line->array[x_val]);
      } else {
        ptaAddPt(baseline_recalc_pts, x0, y0);
      }
    }
  }
  // Return recalculated baseline if this fails return the bottom line as
  // baseline
  numaDestroy(&bin_line);
  ptaDestroy(&baseline_clipped_pts);
  if (ptaGetCount(baseline_recalc_pts) < 2) {
    ptaDestroy(&baseline_recalc_pts);
    return ptaCopy(bottom_pts);
  } else {
    return baseline_recalc_pts;
  }
}
#endif

/// Convert writing direction to string representation
static const char *WritingDirectionToStr(int wd) {
  switch (wd) {
    case 0:
      return "left-to-right";
    case 1:
      return "right-to-left";
    case 2:
      return "top-to-bottom";
    default:
      return "bottom-to-top";
  }
}
///
/// Append the PAGE XML for the beginning of the document
///
bool TessPAGERenderer::BeginDocumentHandler() {
  // Delay the XML output because we need the name of the image file.
  begin_document = true;
  return true;
}

///
/// Append the PAGE XML for the layout of the image
///
bool TessPAGERenderer::AddImageHandler(TessBaseAPI *api) {
  if (begin_document) {
    AppendString(
        "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n"
        "<PcGts "
        "xmlns=\"http://schema.primaresearch.org/PAGE/gts/pagecontent/"
        "2019-07-15\" "
        "xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" "
        "xsi:schemaLocation=\"http://schema.primaresearch.org/PAGE/gts/"
        "pagecontent/2019-07-15 "
        "http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15/"
        "pagecontent.xsd\">\n"
        "\t<Metadata");

    // If a URL is used to recognize an image add it as <Metadata
    // externalRef="url">
    if (std::regex_search(api->GetInputName(),
                          std::regex("^(https?|ftp|ssh):"))) {
      AppendString(" externalRef=\"");
      AppendString(api->GetInputName());
      AppendString("\" ");
    }

    AppendString(
        ">\n"
        "\t\t<Creator>Tesseract - ");
    AppendString(TESSERACT_VERSION_STR);
    // If gmtime conversion is problematic maybe l_getFormattedDate can be used
    // here
    // char *datestr = l_getFormattedDate();
    std::time_t now = std::time(nullptr);
    std::tm *now_tm = std::gmtime(&now);
    char mbstr[100];
    std::strftime(mbstr, sizeof(mbstr), "%Y-%m-%dT%H:%M:%S", now_tm);
    AppendString(
        "</Creator>\n"
        "\t\t<Created>");
    AppendString(mbstr);
    AppendString("</Created>\n");
    AppendString("\t\t<LastChange>");
    AppendString(mbstr);
    AppendString(
        "</LastChange>\n"
        "\t</Metadata>\n");
    begin_document = false;
  }

  const std::unique_ptr<const char[]> text(api->GetPAGEText(imagenum()));
  if (text == nullptr) {
    return false;
  }

  AppendString(text.get());

  return true;
}

///
/// Append the PAGE XML for the end of the document
///
bool TessPAGERenderer::EndDocumentHandler() {
  AppendString("</PcGts>\n");
  return true;
}

TessPAGERenderer::TessPAGERenderer(const char *outputbase)
    : TessResultRenderer(outputbase, "page.xml"), begin_document(false) {}

///
/// Make an XML-formatted string with PAGE markup from the internal
/// data structures.
///
char *TessBaseAPI::GetPAGEText(int page_number) {
  return GetPAGEText(nullptr, page_number);
}

///
/// Make an XML-formatted string with PAGE markup from the internal
/// data structures.
///
char *TessBaseAPI::GetPAGEText(ETEXT_DESC *monitor, int page_number) {
  if (tesseract_ == nullptr ||
      (page_res_ == nullptr && Recognize(monitor) < 0)) {
    return nullptr;
  }

  int rcnt = 0, lcnt = 0, wcnt = 0;

  if (input_file_.empty()) {
    SetInputName(nullptr);
  }

  // Used variables

  std::stringstream reading_order_str;
  std::stringstream region_content;
  std::stringstream line_content;
  std::stringstream word_content;
  std::stringstream line_str;
  std::stringstream line_inter_str;
  std::stringstream word_str;
  std::stringstream page_str;

  float x1, y1, x2, y2;

  tesseract::Orientation orientation_block = ORIENTATION_PAGE_UP;
  tesseract::WritingDirection writing_direction_block =
      WRITING_DIRECTION_LEFT_TO_RIGHT;
  tesseract::TextlineOrder textline_order_block;

  Pta *block_top_pts = ptaCreate(0);
  Pta *block_bottom_pts = ptaCreate(0);
  Pta *line_top_ltr_pts = ptaCreate(0);
  Pta *line_bottom_ltr_pts = ptaCreate(0);
  Pta *line_top_rtl_pts = ptaCreate(0);
  Pta *line_bottom_rtl_pts = ptaCreate(0);
  Pta *word_top_pts = ptaCreate(0);
  Pta *word_bottom_pts = ptaCreate(0);
  Pta *word_baseline_pts = ptaCreate(0);
  Pta *line_baseline_rtl_pts = ptaCreate(0);
  Pta *line_baseline_ltr_pts = ptaCreate(0);
  Pta *line_baseline_pts = ptaCreate(0);

  bool POLYGONFLAG;
  GetBoolVariable("page_xml_polygon", &POLYGONFLAG);
  int LEVELFLAG;
  GetIntVariable("page_xml_level", &LEVELFLAG);

  if (LEVELFLAG != 0 && LEVELFLAG != 1) {
    tprintf(
        "For now, only line level and word level are available, and the level "
        "is reset to line level.\n");
    LEVELFLAG = 0;
  }

  // Use "C" locale (needed for int values larger than 999).
  page_str.imbue(std::locale::classic());
  reading_order_str << "\t<Page " << "imageFilename=\"" << GetInputName();
  // AppendString(api->GetInputName());
  reading_order_str << "\" " << "imageWidth=\"" << rect_width_ << "\" "
                    << "imageHeight=\"" << rect_height_ << "\">\n";
  std::size_t ro_id = std::hash<std::string>{}(GetInputName());
  reading_order_str << "\t\t<ReadingOrder>\n"
                    << "\t\t\t<OrderedGroup id=\"ro" << ro_id
                    << "\" caption=\"Regions reading order\">\n";

  std::unique_ptr<ResultIterator> res_it(GetIterator());

  float block_conf = 0;
  float line_conf = 0;

  while (!res_it->Empty(RIL_BLOCK)) {
    if (res_it->Empty(RIL_WORD)) {
      res_it->Next(RIL_WORD);
      continue;
    }

    auto block_type = res_it->BlockType();

    switch (block_type) {
      case PT_FLOWING_IMAGE:
      case PT_HEADING_IMAGE:
      case PT_PULLOUT_IMAGE: {
        // Handle all kinds of images.
        page_str << "\t\t<GraphicRegion id=\"r" << rcnt++ << "\">\n";
        page_str << "\t\t\t";
        AddBoxToPAGE(res_it.get(), RIL_BLOCK, page_str);
        page_str << "\t\t</GraphicRegion>\n";
        res_it->Next(RIL_BLOCK);
        continue;
      }
      case PT_HORZ_LINE:
      case PT_VERT_LINE:
        // Handle horizontal and vertical lines.
        page_str << "\t\t<SeparatorRegion id=\"r" << rcnt++ << "\">\n";
        page_str << "\t\t\t";
        AddBoxToPAGE(res_it.get(), RIL_BLOCK, page_str);
        page_str << "\t\t</SeparatorRegion>\n";
        res_it->Next(RIL_BLOCK);
        continue;
      case PT_NOISE:
        tprintf("TODO: Please report image which triggers the noise case.\n");
        ASSERT_HOST(false);
      default:
        break;
    }

    if (res_it->IsAtBeginningOf(RIL_BLOCK)) {
      // Add Block to reading order
      reading_order_str << "\t\t\t\t<RegionRefIndexed " << "index=\"" << rcnt
                        << "\" " << "regionRef=\"r" << rcnt << "\"/>\n";

      float deskew_angle;
      res_it->Orientation(&orientation_block, &writing_direction_block,
                          &textline_order_block, &deskew_angle);
      block_conf = res_it->Confidence(RIL_BLOCK) / 100;
      page_str << "\t\t<TextRegion id=\"r" << rcnt << "\" " << "custom=\""
               << "readingOrder {index:" << rcnt << ";} ";
      if (writing_direction_block != WRITING_DIRECTION_LEFT_TO_RIGHT) {
        page_str << "readingDirection {"
                 << WritingDirectionToStr(writing_direction_block) << ";} ";
      }
      page_str << "orientation {" << orientation_block << ";}\">\n";
      page_str << "\t\t\t";
      if ((!POLYGONFLAG || (orientation_block != ORIENTATION_PAGE_UP &&
                            orientation_block != ORIENTATION_PAGE_DOWN)) &&
          LEVELFLAG == 0) {
        AddBoxToPAGE(res_it.get(), RIL_BLOCK, page_str);
      }
    }

    // Writing direction changes at a per-word granularity
    // tesseract::WritingDirection writing_direction_before;
    auto writing_direction = writing_direction_block;
    if (writing_direction_block != WRITING_DIRECTION_TOP_TO_BOTTOM) {
      switch (res_it->WordDirection()) {
        case DIR_LEFT_TO_RIGHT:
          writing_direction = WRITING_DIRECTION_LEFT_TO_RIGHT;
          break;
        case DIR_RIGHT_TO_LEFT:
          writing_direction = WRITING_DIRECTION_RIGHT_TO_LEFT;
          break;
        default:
          break;
      }
    }

    bool ttb_flag = (writing_direction == WRITING_DIRECTION_TOP_TO_BOTTOM);
    // TODO: Rework polygon handling if line is skewed (90 or 180 degress),
    // for now using LinePts
    bool skewed_flag = (orientation_block != ORIENTATION_PAGE_UP &&
                        orientation_block != ORIENTATION_PAGE_DOWN);

    if (res_it->IsAtBeginningOf(RIL_TEXTLINE)) {
      // writing_direction_before = writing_direction;
      line_conf = res_it->Confidence(RIL_TEXTLINE) / 100;
      char *utf8text = res_it->GetUTF8Text(RIL_TEXTLINE);
      std::string textline = utf8text;
      delete[] utf8text;
      if (textline.back() == '\n') {
        textline.erase(textline.length() - 1);
      }
      line_content << HOcrEscape(textline.c_str());
      line_str << "\t\t\t<TextLine id=\"r" << rcnt << "l" << lcnt << "\" ";
      if (writing_direction != WRITING_DIRECTION_LEFT_TO_RIGHT &&
          writing_direction != writing_direction_block) {
        line_str << "readingDirection=\""
                 << WritingDirectionToStr(writing_direction) << "\" ";
      }
      line_str << "custom=\"" << "readingOrder {index:" << lcnt << ";}\">\n";
      // If level is linebased, get the line polygon and baseline
      if (LEVELFLAG == 0 && (!POLYGONFLAG || skewed_flag)) {
        AddPointToWordPolygon(res_it.get(), RIL_TEXTLINE, line_top_ltr_pts,
                              line_bottom_ltr_pts, writing_direction);
        AddBaselineToPTA(res_it.get(), RIL_TEXTLINE, line_baseline_pts);
        if (ttb_flag) {
          line_baseline_pts = TransposePolygonline(line_baseline_pts);
        }
      }
    }

    // Get information if word is last in line and if its last in the region
    bool last_word_in_line = res_it->IsAtFinalElement(RIL_TEXTLINE, RIL_WORD);
    bool last_word_in_cblock = res_it->IsAtFinalElement(RIL_BLOCK, RIL_WORD);

    float word_conf = res_it->Confidence(RIL_WORD) / 100;

    // Create word stream if word level output is active
    if (LEVELFLAG > 0) {
      word_str << "\t\t\t\t<Word id=\"r" << rcnt << "l" << lcnt << "w" << wcnt
               << "\" readingDirection=\""
               << WritingDirectionToStr(writing_direction) << "\" "
               << "custom=\"" << "readingOrder {index:" << wcnt << ";}\">\n";
      if ((!POLYGONFLAG || skewed_flag) || ttb_flag) {
        AddPointToWordPolygon(res_it.get(), RIL_WORD, word_top_pts, word_bottom_pts,
                              writing_direction);
      }
    }

    if (POLYGONFLAG && !skewed_flag && ttb_flag && LEVELFLAG == 0) {
      AddPointToWordPolygon(res_it.get(), RIL_WORD, word_top_pts, word_bottom_pts,
                            writing_direction);
    }

    // Get the word baseline information
    AddBaselineToPTA(res_it.get(), RIL_WORD, word_baseline_pts);

    // Get the word text content and polygon
    do {
      const std::unique_ptr<const char[]> grapheme(
          res_it->GetUTF8Text(RIL_SYMBOL));
      if (grapheme && grapheme[0] != 0) {
        word_content << HOcrEscape(grapheme.get()).c_str();
        if (POLYGONFLAG && !skewed_flag && !ttb_flag) {
          AddPointToWordPolygon(res_it.get(), RIL_SYMBOL, word_top_pts,
                                word_bottom_pts, writing_direction);
        }
      }
      res_it->Next(RIL_SYMBOL);
    } while (!res_it->Empty(RIL_BLOCK) && !res_it->IsAtBeginningOf(RIL_WORD));

    if (LEVELFLAG > 0 || (POLYGONFLAG && !skewed_flag)) {
      // Sort wordpolygons
      word_top_pts = RecalcPolygonline(word_top_pts, 1 - ttb_flag);
      word_bottom_pts = RecalcPolygonline(word_bottom_pts, 0 + ttb_flag);

      // AppendLinePolygon
      AppendLinePolygon(line_top_ltr_pts, line_top_rtl_pts, word_top_pts,
                        writing_direction);
      AppendLinePolygon(line_bottom_ltr_pts, line_bottom_rtl_pts,
                        word_bottom_pts, writing_direction);

      // Word level polygon
      word_bottom_pts = ReversePolygonline(word_bottom_pts, 1);
      ptaJoin(word_top_pts, word_bottom_pts, 0, -1);
    }

    // Reverse the word baseline direction for rtl
    if (writing_direction == WRITING_DIRECTION_RIGHT_TO_LEFT) {
      word_baseline_pts = ReversePolygonline(word_baseline_pts, 1);
    }

    // Write word information to the output
    if (LEVELFLAG > 0) {
      word_str << "\t\t\t\t\t";
      if (ttb_flag) {
        word_top_pts = TransposePolygonline(word_top_pts);
      }
      AddPointsToPAGE(word_top_pts, word_str);
      word_str << "\t\t\t\t\t";
      AddBaselinePtsToPAGE(word_baseline_pts, word_str);
      word_str << "\t\t\t\t\t<TextEquiv index=\"1\" conf=\""
               << std::setprecision(4) << word_conf << "\">\n"
               << "\t\t\t\t\t\t<Unicode>" << word_content.str()
               << "</Unicode>\n"
               << "\t\t\t\t\t</TextEquiv>\n"
               << "\t\t\t\t</Word>\n";
    }
    if (LEVELFLAG > 0 || (POLYGONFLAG && !skewed_flag)) {
      // Add wordbaseline to linebaseline
      if (ttb_flag) {
        word_baseline_pts = TransposePolygonline(word_baseline_pts);
      }
      ptaJoin(line_baseline_pts, word_baseline_pts, 0, -1);
    }
    word_baseline_pts = DestroyAndCreatePta(word_baseline_pts);

    // Reset word pts arrays
    word_top_pts = DestroyAndCreatePta(word_top_pts);
    word_bottom_pts = DestroyAndCreatePta(word_bottom_pts);

    // Check why this combination of words is not working as expected!
    // Write the word contents to the line
#if 0
    if (!last_word_in_line && writing_direction_before != writing_direction &&
        writing_direction < 2 && writing_direction_before < 2 &&
        res_it->WordDirection()) {
      if (writing_direction_before == WRITING_DIRECTION_LEFT_TO_RIGHT) {
        // line_content << "‏" << word_content.str();
      } else {
        // line_content << "‎" << word_content.str();
      }
    } else {
      // line_content << word_content.str();
    }
    // Check if WordIsNeutral
    if (res_it->WordDirection()) {
      writing_direction_before = writing_direction;
    }
#endif
    word_content.str("");
    wcnt++;

    // Write line information to the output
    if (last_word_in_line) {
      // Combine ltr and rtl lines
      if (ptaGetCount(line_top_rtl_pts) != 0) {
        ptaJoin(line_top_ltr_pts, line_top_rtl_pts, 0, -1);
        line_top_rtl_pts = DestroyAndCreatePta(line_top_rtl_pts);
      }
      if (ptaGetCount(line_bottom_rtl_pts) != 0) {
        ptaJoin(line_bottom_ltr_pts, line_bottom_rtl_pts, 0, -1);
        line_bottom_rtl_pts = DestroyAndCreatePta(line_bottom_rtl_pts);
      }
      if ((POLYGONFLAG && !skewed_flag) || LEVELFLAG > 0) {
        // Recalc Polygonlines
        line_top_ltr_pts = RecalcPolygonline(line_top_ltr_pts, 1 - ttb_flag);
        line_bottom_ltr_pts =
            RecalcPolygonline(line_bottom_ltr_pts, 0 + ttb_flag);

        // Smooth the polygonline
        SimplifyLinePolygon(line_top_ltr_pts, 5, 1 - ttb_flag);
        SimplifyLinePolygon(line_bottom_ltr_pts, 5, 0 + ttb_flag);

        // Fit linepolygon matching the baselinepoints
        line_baseline_pts = SortBaseline(line_baseline_pts);

        // Fitting baseline into polygon is currently deactivated because
        // it tends to push the baseline directly under superscripts,
        // but the baseline is always inside the polygon maybe it will be useful
        // for something line_baseline_pts =
        // FitBaselineIntoLinePolygon(line_bottom_ltr_pts, line_baseline_pts,
        // writing_direction); and it only cut it to the length and simplifies
        // the linepolyon
        line_baseline_pts = ClipAndSimplifyBaseline(
            line_bottom_ltr_pts, line_baseline_pts, writing_direction);

        // Update polygon of the block
        UpdateBlockPoints(block_top_pts, block_bottom_pts, line_top_ltr_pts,
                          line_bottom_ltr_pts, lcnt, last_word_in_cblock);
      }
      // Line level polygon
      line_bottom_ltr_pts = ReversePolygonline(line_bottom_ltr_pts, 1);
      ptaJoin(line_top_ltr_pts, line_bottom_ltr_pts, 0, -1);
      line_bottom_ltr_pts = DestroyAndCreatePta(line_bottom_ltr_pts);

      if (LEVELFLAG > 0 && !(POLYGONFLAG && !skewed_flag)) {
        line_top_ltr_pts = PolygonToBoxCoords(line_top_ltr_pts);
      }

      // Write level points
      line_str << "\t\t\t\t";
      if (ttb_flag) {
        line_top_ltr_pts = TransposePolygonline(line_top_ltr_pts);
      }
      AddPointsToPAGE(line_top_ltr_pts, line_str);
      line_top_ltr_pts = DestroyAndCreatePta(line_top_ltr_pts);

      // Write Baseline
      line_str << "\t\t\t\t";
      if (ttb_flag) {
        line_baseline_pts = TransposePolygonline(line_baseline_pts);
      }
      AddBaselinePtsToPAGE(line_baseline_pts, line_str);
      line_baseline_pts = DestroyAndCreatePta(line_baseline_pts);

      // Add word information if word level output is active
      line_str << word_str.str();
      word_str.str("");
      // Write Line TextEquiv
      line_str << "\t\t\t\t<TextEquiv index=\"1\" conf=\""
               << std::setprecision(4) << line_conf << "\">\n"
               << "\t\t\t\t\t<Unicode>" << line_content.str() << "</Unicode>\n"
               << "\t\t\t\t</TextEquiv>\n";
      line_str << "\t\t\t</TextLine>\n";
      region_content << line_content.str();
      line_content.str("");
      if (!last_word_in_cblock) {
        region_content << '\n';
      }
      lcnt++;
      wcnt = 0;
    }

    // Write region information to the output
    if (last_word_in_cblock) {
      if ((POLYGONFLAG && !skewed_flag) || LEVELFLAG > 0) {
        page_str << "<Coords points=\"";
        block_bottom_pts = ReversePolygonline(block_bottom_pts, 1);
        ptaJoin(block_top_pts, block_bottom_pts, 0, -1);
        if (ttb_flag) {
          block_top_pts = TransposePolygonline(block_top_pts);
        }
        ptaGetMinMax(block_top_pts, &x1, &y1, &x2, &y2);
        page_str << static_cast<uint32_t>(x1) << "," << static_cast<uint32_t>(y1) << ' '
                 << static_cast<uint32_t>(x2) << "," << static_cast<uint32_t>(y1) << ' '
                 << static_cast<uint32_t>(x2) << "," << static_cast<uint32_t>(y2) << ' '
                 << static_cast<uint32_t>(x1) << "," << static_cast<uint32_t>(y2)
                 << "\"/>\n";
        block_top_pts = DestroyAndCreatePta(block_top_pts);
        block_bottom_pts = DestroyAndCreatePta(block_bottom_pts);
      }
      page_str << line_str.str();
      line_str.str("");
      page_str << "\t\t\t<TextEquiv index=\"1\" conf=\"" << std::setprecision(4)
               << block_conf << "\">\n"
               << "\t\t\t\t<Unicode>" << region_content.str() << "</Unicode>\n"
               << "\t\t\t</TextEquiv>\n";
      page_str << "\t\t</TextRegion>\n";
      region_content.str("");
      rcnt++;
      lcnt = 0;
    }
  }

  // Destroy all point information
  ptaDestroy(&block_top_pts);
  ptaDestroy(&block_bottom_pts);
  ptaDestroy(&line_top_ltr_pts);
  ptaDestroy(&line_bottom_ltr_pts);
  ptaDestroy(&line_top_rtl_pts);
  ptaDestroy(&line_bottom_rtl_pts);
  ptaDestroy(&word_top_pts);
  ptaDestroy(&word_bottom_pts);
  ptaDestroy(&word_baseline_pts);
  ptaDestroy(&line_baseline_rtl_pts);
  ptaDestroy(&line_baseline_ltr_pts);
  ptaDestroy(&line_baseline_pts);

  reading_order_str << "\t\t\t</OrderedGroup>\n"
                    << "\t\t</ReadingOrder>\n";

  reading_order_str << page_str.str();
  page_str.str("");
  reading_order_str << "\t</Page>\n";
  const std::string &text = reading_order_str.str();
  reading_order_str.str("");

  return copy_string(text);
}

} // namespace tesseract
