/**********************************************************************
 * File:        pageres.cpp  (Formerly page_res.c)
 * Description: Results classes used by control.c
 * Author:		Phil Cheatle
 * Created:     Tue Sep 22 08:42:49 BST 1992
 *
 * (C) Copyright 1992, 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          "pageres.h"
#include          "notdll.h"

ELISTIZE (BLOCK_RES)
CLISTIZE (BLOCK_RES) ELISTIZE (ROW_RES) ELISTIZE (WERD_RES)
/*************************************************************************
 * PAGE_RES::PAGE_RES
 *
 * Constructor for page results
 *************************************************************************/
PAGE_RES::PAGE_RES(                            //recursive construct
                   BLOCK_LIST *the_block_list  //real page
                  ) {
  BLOCK_IT block_it(the_block_list);
  BLOCK_RES_IT block_res_it(&block_res_list);

  char_count = 0;
  rej_count = 0;
  rejected = FALSE;

  for (block_it.mark_cycle_pt ();
  !block_it.cycled_list (); block_it.forward ()) {
    block_res_it.add_to_end (new BLOCK_RES (block_it.data ()));
  }
}


/*************************************************************************
 * BLOCK_RES::BLOCK_RES
 *
 * Constructor for BLOCK results
 *************************************************************************/

BLOCK_RES::BLOCK_RES(                  //recursive construct
                     BLOCK *the_block  //real BLOCK
                    ) {
  ROW_IT row_it (the_block->row_list ());
  ROW_RES_IT row_res_it(&row_res_list);

  char_count = 0;
  rej_count = 0;
  font_class = -1;               //not assigned
  x_height = -1.0;
  font_assigned = FALSE;
  bold = FALSE;
  italic = FALSE;
  row_count = 0;

  block = the_block;

  for (row_it.mark_cycle_pt (); !row_it.cycled_list (); row_it.forward ()) {
    row_res_it.add_to_end (new ROW_RES (row_it.data ()));
  }
}


/*************************************************************************
 * ROW_RES::ROW_RES
 *
 * Constructor for ROW results
 *************************************************************************/

ROW_RES::ROW_RES(              //recursive construct
                 ROW *the_row  //real ROW
                ) {
  WERD_IT word_it (the_row->word_list ());
  WERD_RES_IT word_res_it(&word_res_list);
  WERD_RES *combo = NULL;        //current combination of fuzzies
  WERD_RES *word_res;            //current word
  WERD *copy_word;

  char_count = 0;
  rej_count = 0;
  whole_word_rej_count = 0;
  font_class = -1;
  font_class_score = -1.0;
  bold = FALSE;
  italic = FALSE;

  row = the_row;

  for (word_it.mark_cycle_pt (); !word_it.cycled_list (); word_it.forward ()) {
    word_res = new WERD_RES (word_it.data ());
    word_res->x_height = the_row->x_height();

    if (word_res->word->flag (W_FUZZY_NON)) {
      ASSERT_HOST (combo != NULL);
      word_res->part_of_combo = TRUE;
      combo->copy_on (word_res);
    }
    if (word_it.data_relative (1)->flag (W_FUZZY_NON)) {
      if (combo == NULL) {
        copy_word = new WERD;
                                 //deep copy
        *copy_word = *(word_it.data ());
        combo = new WERD_RES (copy_word);
        combo->x_height = the_row->x_height();
        combo->combination = TRUE;
        word_res_it.add_to_end (combo);
      }
      word_res->part_of_combo = TRUE;
    }
    else
      combo = NULL;
    word_res_it.add_to_end (word_res);
  }
}


WERD_RES & WERD_RES::operator= ( //assign word_res
const WERD_RES & source          //from this
) {
  this->ELIST_LINK::operator= (source);
  if (source.combination) {
    word = new WERD;
    *word = *(source.word);      //deep copy
  }
  else
    word = source.word;          //pt to same word

  if (source.outword != NULL) {
    outword = new WERD;
    *outword = *(source.outword);//deep copy
  }
  else
    outword = NULL;

  denorm = source.denorm;
  if (source.best_choice != NULL) {
    best_choice = new WERD_CHOICE;
    *best_choice = *(source.best_choice);
    raw_choice = new WERD_CHOICE;
    *raw_choice = *(source.raw_choice);
  }
  else {
    best_choice = NULL;
    raw_choice = NULL;
  }
  if (source.ep_choice != NULL) {
    ep_choice = new WERD_CHOICE;
    *ep_choice = *(source.ep_choice);
  }
  else
    ep_choice = NULL;
  reject_map = source.reject_map;
  tess_failed = source.tess_failed;
  tess_accepted = source.tess_accepted;
  tess_would_adapt = source.tess_would_adapt;
  done = source.done;
  unlv_crunch_mode = source.unlv_crunch_mode;
  italic = source.italic;
  bold = source.bold;
  font1 = source.font1;
  font1_count = source.font1_count;
  font2 = source.font2;
  font2_count = source.font2_count;
  x_height = source.x_height;
  caps_height = source.caps_height;
  guessed_x_ht = source.guessed_x_ht;
  guessed_caps_ht = source.guessed_caps_ht;
  combination = source.combination;
  part_of_combo = source.part_of_combo;
  reject_spaces = source.reject_spaces;
  return *this;
}


WERD_RES::~WERD_RES () {
  if (combination)
    delete word;
  if (outword != NULL)
    delete outword;
  if (best_choice != NULL) {
    delete best_choice;
    delete raw_choice;
  }
  if (ep_choice != NULL) {
    delete ep_choice;
  }
}


/*************************************************************************
 * PAGE_RES_IT::restart_page
 *
 * Set things up at the start of the page
 *************************************************************************/

WERD_RES *PAGE_RES_IT::restart_page() {
  block_res_it.set_to_list (&page_res->block_res_list);
  block_res_it.mark_cycle_pt ();
  prev_block_res = NULL;
  prev_row_res = NULL;
  prev_word_res = NULL;
  block_res = NULL;
  row_res = NULL;
  word_res = NULL;
  next_block_res = NULL;
  next_row_res = NULL;
  next_word_res = NULL;
  internal_forward(TRUE);
  return internal_forward (FALSE);
}


/*************************************************************************
 * PAGE_RES_IT::internal_forward
 *
 * Find the next word on the page. Empty blocks and rows are skipped.
 * The iterator maintains pointers to block, row and word for the previous,
 * current and next words.  These are correct, regardless of block/row
 * boundaries. NULL values denote start and end of the page.
 *************************************************************************/

WERD_RES *PAGE_RES_IT::internal_forward(BOOL8 new_block) {
  BOOL8 found_next_word = FALSE;
  BOOL8 new_row = FALSE;

  prev_block_res = block_res;
  prev_row_res = row_res;
  prev_word_res = word_res;
  block_res = next_block_res;
  row_res = next_row_res;
  word_res = next_word_res;

  while (!found_next_word && !block_res_it.cycled_list ()) {
    if (new_block) {
      new_block = FALSE;
      row_res_it.set_to_list (&block_res_it.data ()->row_res_list);
      row_res_it.mark_cycle_pt ();
      new_row = TRUE;
    }
    while (!found_next_word && !row_res_it.cycled_list ()) {
      if (new_row) {
        new_row = FALSE;
        word_res_it.set_to_list (&row_res_it.data ()->word_res_list);
        word_res_it.mark_cycle_pt ();
      }
      while (!found_next_word && !word_res_it.cycled_list ()) {
        next_block_res = block_res_it.data ();
        next_row_res = row_res_it.data ();
        next_word_res = word_res_it.data ();
        found_next_word = TRUE;
        do {
          word_res_it.forward ();
        }
        while (word_res_it.data ()->part_of_combo);
      }
      if (!found_next_word) {    //end of row reached
        row_res_it.forward ();
        new_row = TRUE;
      }
    }
    if (!found_next_word) {      //end of block reached
      block_res_it.forward ();
      new_block = TRUE;
    }
  }
  if (!found_next_word) {        //end of page reached
    next_block_res = NULL;
    next_row_res = NULL;
    next_word_res = NULL;
  }
  return word_res;
}


/*************************************************************************
 * PAGE_RES_IT::forward_block
 *
 * Move to the first word of the next block
 * Can be followed by subsequent calls to forward() BUT at the first word in
 * the block, the prev block, row and word are all NULL.
 *************************************************************************/

WERD_RES *PAGE_RES_IT::forward_block() {
  if (block_res == next_block_res) {
    block_res_it.forward ();;
    block_res = NULL;
    row_res = NULL;
    word_res = NULL;
    next_block_res = NULL;
    next_row_res = NULL;
    next_word_res = NULL;
    internal_forward(TRUE);
  }
  return internal_forward (FALSE);
}


void PAGE_RES_IT::rej_stat_word() {
  inT16 chars_in_word;
  inT16 rejects_in_word = 0;

  chars_in_word = word_res->reject_map.length ();
  page_res->char_count += chars_in_word;
  block_res->char_count += chars_in_word;
  row_res->char_count += chars_in_word;

  rejects_in_word = word_res->reject_map.reject_count ();

  page_res->rej_count += rejects_in_word;
  block_res->rej_count += rejects_in_word;
  row_res->rej_count += rejects_in_word;
  if (chars_in_word == rejects_in_word)
    row_res->whole_word_rej_count += rejects_in_word;
}