/**********************************************************************
 * File:        blread.cpp  (Formerly pdread.c)
 * Description: Friend function of BLOCK to read the uscan pd file.
 * Author:		Ray Smith
 * Created:		Mon Mar 18 14:39:00 GMT 1991
 *
 * (C) Copyright 1991, Hewlett-Packard Ltd.
 ** 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 "mfcpch.h"
#include          <stdlib.h>
#ifdef __UNIX__
#include          <assert.h>
#endif
#include          "scanutils.h"
#include          "fileerr.h"
#include          "imgtiff.h"
#include          "pdclass.h"
#include          "rwpoly.h"
#include          "blread.h"

#define PD_EXT        ".pd"
#define VEC_EXT       ".vec"     //accupage file
#define HPD_EXT       ".bl"      //hand pd file
                                 //unlv zone file
#define UNLV_EXT            ".uzn"
#define BLOCK_EXPANSION   8      //boundary expansion
#define EXTERN

EXTERN BOOL_EVAR (ignore_weird_blocks, TRUE, "Don't read weird blocks");

static TBOX convert_vec_block(                        //make non-rect block
                             VEC_ENTRY *entries,     //vectors
                             uinT16 entry_count,     //no of entries
                             inT32 ysize,            //image size
                             ICOORDELT_IT *left_it,  //block sides
                             ICOORDELT_IT *right_it);

/**********************************************************************
 * BLOCK::read_pd_file
 *
 * Read a whole pd file to make a list of blocks, or return false.
 **********************************************************************/

BOOL8 read_pd_file(                    //print list of sides
                   STRING name,        //basename of file
                   inT32 xsize,        //image size
                   inT32 ysize,        //image size
                   BLOCK_LIST *blocks  //output list
                  ) {
  FILE *pdfp;                    //file pointer
  BLOCK *block;                  //current block
  inT32 block_count;             //no of blocks
  inT32 junk_count;              //no of junks to read
  inT32 junks[4];                //junk elements
  inT32 vertex_count;            //boundary vertices
  inT32 xcoord;                  //current coords
  inT32 ycoord;
  inT32 prevx;                   //previous coords
  inT32 prevy;
  BLOCK_IT block_it = blocks;    //block iterator
  ICOORDELT_LIST dummy;          //for constructor
  ICOORDELT_IT left_it = &dummy; //iterator
  ICOORDELT_IT right_it = &dummy;//iterator

  if (read_hpd_file (name, xsize, ysize, blocks))
    return TRUE;                 //succeeded
  if (read_vec_file (name, xsize, ysize, blocks))
    return TRUE;                 //succeeded
  if (read_unlv_file (name, xsize, ysize, blocks))
    return TRUE;                 //succeeded
  name += PD_EXT;                //add extension
  if ((pdfp = fopen (name.string (), "r")) == NULL) {
                                 //make rect block
    return FALSE;                //didn't read one
  }
  else {
    if (fread (&block_count, sizeof (block_count), 1, pdfp) != 1)
      READFAILED.error ("read_pd_file", EXIT, "Block count");
    tprintf ("%d blocks in .pd file.\n", block_count);
    while (block_count > 0) {
      if (fread (&junk_count, sizeof (junk_count), 1, pdfp) != 1)
        READFAILED.error ("read_pd_file", EXIT, "Junk count");
      if (fread (&vertex_count, sizeof (vertex_count), 1, pdfp) != 1)
        READFAILED.error ("read_pd_file", EXIT, "Vertex count");
      block = new BLOCK;         //make a block
                                 //on end of list
      block_it.add_to_end (block);
      left_it.set_to_list (&block->leftside);
      right_it.set_to_list (&block->rightside);

                                 //read a pair
      get_pd_vertex (pdfp, xsize, ysize, &block->box, xcoord, ycoord);
      vertex_count -= 2;         //count read ones
      prevx = xcoord;
      do {
        if (xcoord == prevx) {
          if (!right_it.empty ()) {
            if (right_it.data ()->x () <= xcoord + BLOCK_EXPANSION)
              right_it.data ()->set_y (right_it.data ()->y () +
                BLOCK_EXPANSION);
            else
              right_it.data ()->set_y (right_it.data ()->y () -
                BLOCK_EXPANSION);
          }
          right_it.
            add_before_then_move (new
            ICOORDELT (xcoord + BLOCK_EXPANSION,
            ycoord));
        }
        prevx = xcoord;          //remember previous
        prevy = ycoord;
        get_pd_vertex (pdfp, xsize, ysize, &block->box, xcoord, ycoord);
        vertex_count -= 2;       //count read ones
      }
      while (ycoord <= prevy);
      right_it.data ()->set_y (right_it.data ()->y () - BLOCK_EXPANSION);

                                 //start of left
      left_it.add_to_end (new ICOORDELT (prevx - BLOCK_EXPANSION, prevy - BLOCK_EXPANSION));

      do {
        prevx = xcoord;          //remember previous
        get_pd_vertex (pdfp, xsize, ysize, &block->box, xcoord, ycoord);
        vertex_count -= 2;
        if (xcoord != prevx && vertex_count > 0) {
          if (xcoord > prevx)
            left_it.
              add_to_end (new
              ICOORDELT (xcoord - BLOCK_EXPANSION,
              ycoord + BLOCK_EXPANSION));
          else
            left_it.
              add_to_end (new
              ICOORDELT (xcoord - BLOCK_EXPANSION,
              ycoord - BLOCK_EXPANSION));
        }
        else if (vertex_count == 0)
          left_it.add_to_end (new ICOORDELT (prevx - BLOCK_EXPANSION,
              ycoord + BLOCK_EXPANSION));
      }
      while (vertex_count > 0);  //until all read

      while (junk_count > 0) {
        if (fread (junks, sizeof (inT32), 4, pdfp) != 4)
          READFAILED.error ("read_pd_file", EXIT, "Junk coords");
        junk_count--;
      }
      block_count--;             //count read blocks
    }
  }
  fclose(pdfp);
  return TRUE;                   //read one
}


/**********************************************************************
 * get_pd_vertex
 *
 * Read a pair of coords, invert the y and clip to image limits.
 * Also update the bounding box.
 *
 * Read a whole pd file to make a list of blocks, or use the whole page.
 **********************************************************************/

void get_pd_vertex(                //get new vertex
                   FILE *pdfp,     //file to read
                   inT32 xsize,    //image size
                   inT32 ysize,    //image size
                   TBOX *box,       //bounding box
                   inT32 &xcoord,  //output coords
                   inT32 &ycoord) {
  TBOX new_coord;                 //expansion box

                                 //get new coords
  if (fread (&xcoord, sizeof (xcoord), 1, pdfp) != 1)
    READFAILED.error ("read_pd_file", EXIT, "Xcoord");
  if (fread (&ycoord, sizeof (ycoord), 1, pdfp) != 1)
    READFAILED.error ("read_pd_file", EXIT, "Xcoord");
  ycoord = ysize - ycoord;       //invert y
  if (xcoord < BLOCK_EXPANSION)
    xcoord = BLOCK_EXPANSION;    //clip to limits
  if (xcoord > xsize - BLOCK_EXPANSION)
    xcoord = xsize - BLOCK_EXPANSION;
  if (ycoord < BLOCK_EXPANSION)
    ycoord = BLOCK_EXPANSION;
  if (ycoord > ysize - BLOCK_EXPANSION)
    ycoord = ysize - BLOCK_EXPANSION;

  new_coord =
    TBOX (ICOORD (xcoord - BLOCK_EXPANSION, ycoord - BLOCK_EXPANSION),
    ICOORD (xcoord + BLOCK_EXPANSION, ycoord + BLOCK_EXPANSION));
  (*box) += new_coord;
}


/**********************************************************************
 * BLOCK::read_hpd_file
 *
 * Read a whole hpd file to make a list of blocks.
 * Return FALSE if the .vec fiel cannot be found
 **********************************************************************/

BOOL8 read_hpd_file(                    //print list of sides
                    STRING name,        //basename of file
                    inT32 xsize,        //image size
                    inT32 ysize,        //image size
                    BLOCK_LIST *blocks  //output list
                   ) {
  FILE *pdfp;                    //file pointer
  PAGE_BLOCK_LIST *page_blocks;
  inT32 block_no;                //no of blocks
  BLOCK_IT block_it = blocks;    //block iterator

  name += HPD_EXT;               //add extension
  if ((pdfp = fopen (name.string (), "r")) == NULL) {
    return FALSE;                //can't find it
  }
  fclose(pdfp);
  page_blocks = read_poly_blocks (name.string ());
  block_no = 0;
  scan_hpd_blocks (name.string (), page_blocks, block_no, &block_it);
  tprintf ("Text region count=%d\n", block_no);
  return TRUE;                   //read one
}


/**********************************************************************
 * BLOCK::scan_hpd_blocks
 *
 * Read a whole hpd file to make a list of blocks.
 * Return FALSE if the .vec fiel cannot be found
 **********************************************************************/

void scan_hpd_blocks(                               //print list of sides
                     const char *name,              //block label
                     PAGE_BLOCK_LIST *page_blocks,  //head of full pag
                     inT32 &block_no,               //no of blocks
                     BLOCK_IT *block_it             //block iterator
                    ) {
  BLOCK *block;                  //current block
                                 //page blocks
  PAGE_BLOCK_IT pb_it = page_blocks;
  PAGE_BLOCK *current_block;
  TEXT_REGION_IT tr_it;
  TEXT_BLOCK *tb;
  TEXT_REGION *tr;
  TBOX *block_box;                //from text region

  for (pb_it.mark_cycle_pt (); !pb_it.cycled_list (); pb_it.forward ()) {
    current_block = pb_it.data ();
    if (current_block->type () == PB_TEXT) {
      tb = (TEXT_BLOCK *) current_block;
      if (!tb->regions ()->empty ()) {
        tr_it.set_to_list (tb->regions ());
        for (tr_it.mark_cycle_pt ();
        !tr_it.cycled_list (); tr_it.forward ()) {
          block_no++;
          tr = tr_it.data ();
          block_box = tr->bounding_box ();
          block = new BLOCK (name, TRUE, 0, 0,
            block_box->left (), block_box->bottom (),
            block_box->right (), block_box->top ());
          block->hand_block = tr;
          block->hand_poly = tr;
          block_it->add_after_then_move (block);
        }
      }
    }
    else if (current_block->type () == PB_WEIRD
      && !ignore_weird_blocks
    && ((WEIRD_BLOCK *) current_block)->id_no () > 0) {
      block_no++;
      block_box = current_block->bounding_box ();
      block = new BLOCK (name, TRUE, 0, 0,
        block_box->left (), block_box->bottom (),
        block_box->right (), block_box->top ());
      block->hand_block = NULL;
      block->hand_poly = current_block;
      block_it->add_after_then_move (block);
    }
    if (!current_block->child ()->empty ())
      scan_hpd_blocks (name, current_block->child (), block_no, block_it);
  }
}


/**********************************************************************
 * BLOCK::read_vec_file
 *
 * Read a whole vec file to make a list of blocks.
 * Return FALSE if the .vec fiel cannot be found
 **********************************************************************/

BOOL8 read_vec_file(                    //print list of sides
                    STRING name,        //basename of file
                    inT32 xsize,        //image size
                    inT32 ysize,        //image size
                    BLOCK_LIST *blocks  //output list
                   ) {
  FILE *pdfp;                    //file pointer
  BLOCK *block;                  //current block
  inT32 block_no;                //no of blocks
  inT32 block_index;             //current blocks
  inT32 vector_count;            //total vectors
  VEC_HEADER header;             //file header
  BLOCK_HEADER *vec_blocks;      //blocks from file
  VEC_ENTRY *vec_entries;        //vectors from file
  BLOCK_IT block_it = blocks;    //block iterator
  ICOORDELT_IT left_it;          //iterators
  ICOORDELT_IT right_it;

  name += VEC_EXT;               //add extension
  if ((pdfp = fopen (name.string (), "r")) == NULL) {
    return FALSE;                //can't find it
  }
  if (fread (&header, sizeof (header), 1, pdfp) != 1)
    READFAILED.error ("read_vec_file", EXIT, "Header");
                                 //from intel
  header.filesize = reverse32 (header.filesize);
  header.bytesize = reverse16 (header.bytesize);
  header.arraysize = reverse16 (header.arraysize);
  header.width = reverse16 (header.width);
  header.height = reverse16 (header.height);
  header.res = reverse16 (header.res);
  header.bpp = reverse16 (header.bpp);
  tprintf ("%d blocks in %s file:", header.arraysize, VEC_EXT);
  vector_count = header.filesize - header.arraysize * sizeof (BLOCK_HEADER);
  vector_count /= sizeof (VEC_ENTRY);
  vec_blocks =
    (BLOCK_HEADER *) alloc_mem (header.arraysize * sizeof (BLOCK_HEADER));
  vec_entries = (VEC_ENTRY *) alloc_mem (vector_count * sizeof (VEC_ENTRY));
  xsize = header.width;          //real image size
  ysize = header.height;
  if (fread (vec_blocks, sizeof (BLOCK_HEADER), header.arraysize, pdfp)
    != static_cast<size_t>(header.arraysize))
    READFAILED.error ("read_vec_file", EXIT, "Blocks");
  if (fread (vec_entries, sizeof (VEC_ENTRY), vector_count, pdfp)
    != static_cast<size_t>(vector_count))
    READFAILED.error ("read_vec_file", EXIT, "Vectors");
  for (block_index = 0; block_index < header.arraysize; block_index++) {
    vec_blocks[block_index].offset =
      reverse16 (vec_blocks[block_index].offset);
    vec_blocks[block_index].order =
      reverse16 (vec_blocks[block_index].order);
    vec_blocks[block_index].entries =
      reverse16 (vec_blocks[block_index].entries);
    vec_blocks[block_index].charsize =
      reverse16 (vec_blocks[block_index].charsize);
  }
  for (block_index = 0; block_index < vector_count; block_index++) {
    vec_entries[block_index].start =
      ICOORD (reverse16 (vec_entries[block_index].start.x ()),
      reverse16 (vec_entries[block_index].start.y ()));
    vec_entries[block_index].end =
      ICOORD (reverse16 (vec_entries[block_index].end.x ()),
      reverse16 (vec_entries[block_index].end.y ()));
  }
  for (block_no = 1; block_no <= header.arraysize; block_no++) {
    for (block_index = 0; block_index < header.arraysize; block_index++) {
      if (vec_blocks[block_index].order == block_no
      && vec_blocks[block_index].valid) {
        block = new BLOCK;
        left_it.set_to_list (&block->leftside);
        right_it.set_to_list (&block->rightside);
        block->box =
          convert_vec_block (&vec_entries
          [vec_blocks[block_index].offset],
          vec_blocks[block_index].entries, ysize,
          &left_it, &right_it);
        block->set_xheight (vec_blocks[block_index].charsize);
                                 //on end of list
        block_it.add_to_end (block);
        //                              tprintf("Block at (%d,%d)->(%d,%d) has index %d and order %d\n",
        //                                      block->box.left(),
        //                                      block->box.bottom(),
        //                                      block->box.right(),
        //                                      block->box.top(),
        //                                      block_index,vec_blocks[block_index].order);
      }
    }
  }
  free_mem(vec_blocks);
  free_mem(vec_entries);
  tprintf ("%d valid\n", block_it.length ());
  fclose(pdfp);
  return TRUE;                   //read one
}


/**********************************************************************
 * BLOCK::convert_vec_block
 *
 * Read a whole vec file to make a list of blocks.
 * Return FALSE if the .vec fiel cannot be found
 **********************************************************************/

static TBOX convert_vec_block(                        //make non-rect block
                             VEC_ENTRY *entries,     //vectors
                             uinT16 entry_count,     //no of entries
                             inT32 ysize,            //image size
                             ICOORDELT_IT *left_it,  //block sides
                             ICOORDELT_IT *right_it) {
  TBOX block_box;                 //bounding box
  TBOX vec_box;                   //box of vec
  ICOORD box_point;              //expanded coord
  ICOORD shift_vec;              //for box expansion
  ICOORD prev_pt;                //previous coord
  ICOORD end_pt;                 //end of vector
  inT32 vertex_index;            //boundary vertices

  for (vertex_index = 0; vertex_index < entry_count; vertex_index++) {
    entries[vertex_index].start = ICOORD (entries[vertex_index].start.x (),
      ysize - 1 -
      entries[vertex_index].start.y ());
    entries[vertex_index].end =
      ICOORD (entries[vertex_index].end.x (),
      ysize - 1 - entries[vertex_index].end.y ());
    vec_box = TBOX (entries[vertex_index].start, entries[vertex_index].end);
    block_box += vec_box;        //find total bounds
  }

  for (vertex_index = 0; vertex_index < entry_count
    && (entries[vertex_index].start.y () != block_box.bottom ()
    || entries[vertex_index].end.y () != block_box.bottom ());
    vertex_index++);
  ASSERT_HOST (vertex_index < entry_count);
  prev_pt = entries[vertex_index].start;
  end_pt = entries[vertex_index].end;
  do {
    for (vertex_index = 0; vertex_index < entry_count
      && entries[vertex_index].start != end_pt; vertex_index++);
                                 //found start of vertical
    ASSERT_HOST (vertex_index < entry_count);
    box_point = entries[vertex_index].start;
    if (box_point.x () <= prev_pt.x ())
      shift_vec = ICOORD (-BLOCK_EXPANSION, -BLOCK_EXPANSION);
    else
      shift_vec = ICOORD (-BLOCK_EXPANSION, BLOCK_EXPANSION);
    left_it->add_to_end (new ICOORDELT (box_point + shift_vec));
    prev_pt = box_point;
    for (vertex_index = 0; vertex_index < entry_count
      && entries[vertex_index].start != end_pt; vertex_index++);
                                 //found horizontal
    ASSERT_HOST (vertex_index < entry_count);
    end_pt = entries[vertex_index].end;
  }
  while (end_pt.y () < block_box.top ());
  shift_vec = ICOORD (-BLOCK_EXPANSION, BLOCK_EXPANSION);
  left_it->add_to_end (new ICOORDELT (end_pt + shift_vec));

  for (vertex_index = 0; vertex_index < entry_count
    && (entries[vertex_index].start.y () != block_box.top ()
    || entries[vertex_index].end.y () != block_box.top ());
    vertex_index++);
  ASSERT_HOST (vertex_index < entry_count);
  prev_pt = entries[vertex_index].start;
  end_pt = entries[vertex_index].end;
  do {
    for (vertex_index = 0; vertex_index < entry_count
      && entries[vertex_index].start != end_pt; vertex_index++);
                                 //found start of vertical
    ASSERT_HOST (vertex_index < entry_count);
    box_point = entries[vertex_index].start;
    if (box_point.x () < prev_pt.x ())
      shift_vec = ICOORD (BLOCK_EXPANSION, -BLOCK_EXPANSION);
    else
      shift_vec = ICOORD (BLOCK_EXPANSION, BLOCK_EXPANSION);
    right_it->add_before_then_move (new ICOORDELT (box_point + shift_vec));
    prev_pt = box_point;
    for (vertex_index = 0; vertex_index < entry_count
      && entries[vertex_index].start != end_pt; vertex_index++);
                                 //found horizontal
    ASSERT_HOST (vertex_index < entry_count);
    end_pt = entries[vertex_index].end;
  }
  while (end_pt.y () > block_box.bottom ());
  shift_vec = ICOORD (BLOCK_EXPANSION, -BLOCK_EXPANSION);
  right_it->add_before_then_move (new ICOORDELT (end_pt + shift_vec));

  shift_vec = ICOORD (BLOCK_EXPANSION, BLOCK_EXPANSION);
  box_point = block_box.botleft () - shift_vec;
  end_pt = block_box.topright () + shift_vec;
  return TBOX (box_point, end_pt);
}


/**********************************************************************
 * read_unlv_file
 *
 * Read a whole unlv zone file to make a list of blocks.
 **********************************************************************/

BOOL8 read_unlv_file(                    //print list of sides
                     STRING name,        //basename of file
                     inT32 xsize,        //image size
                     inT32 ysize,        //image size
                     BLOCK_LIST *blocks  //output list
                    ) {
  FILE *pdfp;                    //file pointer
  BLOCK *block;                  //current block
  int x;                         //current top-down coords
  int y;
  int width;                     //of current block
  int height;
  BLOCK_IT block_it = blocks;    //block iterator

  name += UNLV_EXT;              //add extension
  if ((pdfp = fopen (name.string (), "r")) == NULL) {
    return FALSE;                //didn't read one
  }
  else {
    while (fscanf (pdfp, "%d %d %d %d %*s", &x, &y, &width, &height) >= 4) {
                                 //make rect block
      block = new BLOCK (name.string (), TRUE, 0, 0,
                         (inT16) x, (inT16) (ysize - y - height),
                         (inT16) (x + width), (inT16) (ysize - y));
                                 //on end of list
      block_it.add_to_end (block);
    }
    fclose(pdfp);
  }
  return true;
}