## #' Page Dimensions

## #'

## #' Dimensions for mapping page dimensions to text dimensions

## #' @references https://www.ietf.org/rfc/rfc0678.txt

## #' @export

## #' @rdname pagedims

## lpi_vert <- 6

## #' @export

## #' @rdname pagedims

## cpi_horiz <- 10

## #' @export

## #' @rdname pagedims

## horiz_margin_chars <- 13

## #' @export

## #' @rdname pagedims

## horiz_margin_inches <- horiz_margin_chars / cpi_horiz

## #' @export

## #' @rdname pagedims

## vert_margin_lines <- 6

## #' @export

## #' @rdname pagedims

## vert_margin_inches <- vert_margin_lines / lpi_vert

## #' Physical Page dimensions to chars x lines

## #'

## #' Calculate number of lines long and characters wide a page size is,

## #' after excluding margins

## #' @export

## #' @examples

## #' phys_page_to_lc()

## phys_page_to_lc <- function(width = 8.5, len = 11,

##                             h_margin = horiz_margin_inches,

##                             v_margin = vert_margin_inches) {

##     lgl_width <- width - h_margin

##     lgl_len <- len - v_margin

##     c(chars_wide = floor(lgl_width * cpi_horiz),

##       lines_long = floor(lgl_len * lpi_vert))

## }

#' Pagination

#'

#' @section Pagination Algorithm:

#'

#' Pagination is performed independently in the vertical and horizontal

#' directions based solely on a *pagination data frame*, which includes the

#' following information for each row/column:

#'

#'   - Number of lines/characters rendering the row will take **after

#'     word-wrapping** (`self_extent`)

#'   - The indices (`reprint_inds`) and number of lines (`par_extent`)

#'     of the rows which act as **context** for the row

#'   - The row's number of siblings and position within its siblings

#'

#' Given `lpp` (`cpp`) is already adjusted for rendered elements which

#' are not rows/columns and a data frame of pagination information,

#' pagination is performed via the following algorithm with `start = 1`.

#'

#' Core Pagination Algorithm:

#'

#' 1. Initial guess for pagination position is `start + lpp` (`start + cpp`)

#' 2. While the guess is not a valid pagination position, and `guess > start`,

#'    decrement guess and repeat.

#'      - An error is thrown if all possible pagination positions between

#'        `start` and `start + lpp` (`start + cpp`) would be `< start`

#'        after decrementing

#' 3. Retain pagination index

#' 4. If pagination point was less than `NROW(tt)` (`ncol(tt)`), set

#'    `start` to `pos + 1`, and repeat steps (1) - (4).

#'

#' Validating Pagination Position:

#'

#' Given an (already adjusted) `lpp` or `cpp` value, a pagination is invalid if:

#'

#'   - The rows/columns on the page would take more than (adjusted) `lpp` lines/`cpp`

#'     characters to render **including**:

#'       - word-wrapping

#'       - (vertical only) context repetition

#'   - (vertical only) footnote messages and/or section divider lines

#'     take up too many lines after rendering rows

#'   - (vertical only) row is a label or content (row-group summary) row

#'   - (vertical only) row at the pagination point has siblings, and

#'     it has less than `min_siblings` preceding or following siblings

#'   - pagination would occur within a sub-table listed in `nosplitin`

#'

#' @name pagination_algo

NULL

#' Create a row of a pagination data frame

#'

#' @inheritParams open_font_dev

#' @param nm (`string`)\cr name.

#' @param lab (`string`)\cr label.

#' @param rnum (`numeric(1)`)\cr absolute row number.

#' @param pth (`character` or `NULL`)\cr path within larger table.

#' @param sibpos (`integer(1)`)\cr position among sibling rows.

#' @param nsibs (`integer(1)`)\cr number of siblings (including self).

#' @param extent (`numeric(1)`)\cr number of lines required to print the row.

#' @param colwidths (`numeric`)\cr column widths.

#' @param repext (`integer(1)`)\cr number of lines required to reprint all context for this row if it appears directly

#'   after pagination.

#' @param repind (`integer`)\cr vector of row numbers to be reprinted if this row appears directly after pagination.

#' @param indent (`integer`)\cr indent.

#' @param rclass (`string`)\cr class of row object.

#' @param nrowrefs (`integer(1)`)\cr number of row referential footnotes for this row.

#' @param ncellrefs (`integer(1)`)\cr number of cell referential footnotes for the cells in this row.

#' @param nreflines (`integer(1)`)\cr total number of lines required by all referential footnotes.

#' @param force_page (`flag`)\cr currently ignored.

#' @param page_title (`flag`)\cr currently ignored.

#' @param trailing_sep (`string`)\cr the string to use as a separator below this row during printing.

#'   If `NA_character_`, no separator is used.

#' @param row (`ANY`)\cr object representing the row, which is used for default values of `nm`, `lab`,

#'   `extent`, and `rclass` if provided. Must have methods for `obj_name`, `obj_label`, and `nlines`, to retrieve

#'   default values of `nm`, `lab`, and `extent`, respectively.

#'

#' @return A single row `data.frame` with the appropriate columns for a pagination info data frame.

#'

#' @export

pagdfrow <- function(row,

                     nm = obj_name(row),

                     lab = obj_label(row),

                     rnum,

                     pth,

                     sibpos = NA_integer_,

                     nsibs = NA_integer_,

                     extent = nlines(row, colwidths, fontspec = fontspec),

                     colwidths = NULL,

                     repext = 0L,

                     repind = integer(),

                     indent = 0L,

                     rclass = class(row),

                     nrowrefs = 0L,

                     ncellrefs = 0L,

                     nreflines = 0L,

                     # ref_df = .make_ref_df(NULL, NULL),

                     force_page = FALSE,

                     page_title = NA_character_,

                     trailing_sep = NA_character_,

                     fontspec) {

    # ref_info_df = I(list(ref_df)),

  )

}

calc_ref_nlines_df <- function(pagdf) {

  ## XXX XXX XXX this is dangerous and wrong!!!

  }

  }

}

build_fail_msg <- function(row, lines, raw_rowlines,

                           allowed_lines, lpp, decoration_lines,

                           start, guess, rep_ext, n_reprint,

                           reflines, n_refs, sectlines) {

      ),

    )

  } else { ## !row

      ),

    )

  }

}

valid_pag <- function(pagdf,

                      guess,

                      start,

                      rlpp,

                      lpp, # for informational purposes only

                      context_lpp, # for informational purposes only (headers/footers)

                      min_sibs,

                      nosplit = NULL,

                      div_height = 1L,

                      verbose = FALSE,

                      row = TRUE,

                      have_col_fnotes = FALSE,

                      col_gap,

                      has_rowlabels) {

  # FALSE output from this function means that another guess is taken till success or failure

    )

  }

  # Fix for counting the right number of lines when there is wrapping on a keycols

  }

  }

  ## self extent includes reflines

  ## self extent does ***not*** currently include trailing sep for rows

  ## self extent does ***not*** currently include col_gap for columns

  ## we don't include the trailing_sep for guess because if we paginate here it won't be printed

  } else { ## columns

  }

      )

    }

  }

  # Special cases: is it a label or content row?

    # check if it has children; if no children then valid

      }

        )

      }

    } else {

      }

    }

  }

  # Siblings handling

  # okpos <- min(min_sibs + 1, rw[["n_siblings"]])

        )

      }

        )

      }

    }

    }

  }

    ## paths end at the leaf name which is *always* different

          )

        }

      }

    }

  }

  # Usual output when found

  }

}

find_pag <- function(pagdf,

                     current_page,

                     start,

                     guess,

                     rlpp,

                     lpp_or_cpp,

                     context_lpp_or_cpp,

                     min_siblings,

                     nosplitin = character(),

                     verbose = FALSE,

                     row = TRUE,

                     have_col_fnotes = FALSE,

                     div_height = 1L,

                     do_error = FALSE,

                     col_gap,

                     has_rowlabels) {

    } else {

    }

  }

  )) {

  }

    # Repeat pagination process to see what went wrong with verbose on

      )

    }

      ),

    )

  }

}

#' Find pagination indices from pagination info data frame

#'

#' Pagination methods should typically call the `make_row_df` method

#' for their object and then call this function on the resulting

#' pagination info `data.frame`.

#'

#' @param pagdf (`data.frame`)\cr a pagination info `data.frame` as created by

#'   either `make_rows_df` or `make_cols_df`.

#' @param rlpp (`numeric`)\cr maximum number of *row* lines per page (not including header materials), including

#'   (re)printed header and context rows.

#' @param lpp_or_cpp (`numeric`)\cr total maximum number of *row* lines or content (column-wise characters) per page

#'   (including header materials and context rows). This is only for informative results with `verbose = TRUE`.

#'   It will print `NA` if not specified by the pagination machinery.

#' @param context_lpp_or_cpp (`numeric`)\cr total number of context *row* lines or content (column-wise characters)

#'   per page (including header materials). Uses `NA` if not specified by the pagination machinery and is only

#'   for informative results with `verbose = TRUE`.

#' @param min_siblings (`numeric`)\cr minimum sibling rows which must appear on either side of pagination row for a

#'   mid-subtable split to be valid. Defaults to 2 for tables. It is automatically turned off (set to 0) for listings.

#' @param nosplitin (`character`)\cr list of names of subtables where page breaks are not allowed, regardless of other

#'   considerations. Defaults to none.

#' @param verbose (`flag`)\cr whether additional informative messages about the search for

#'   pagination breaks should be shown. Defaults to `FALSE`.

#' @param row (`flag`)\cr whether pagination is happening in row space (`TRUE`, the default) or column

#'   space (`FALSE`).

#' @param have_col_fnotes (`flag`)\cr whether the table-like object being rendered has column-associated

#'   referential footnotes.

#' @param div_height (`numeric(1)`)\cr the height of the divider line when the associated object is rendered.

#'   Defaults to `1`.

#' @param col_gap (`numeric(1)`)\cr width of gap between columns, in same units as extent in `pagdf` (spaces

#'   under a particular font specification).

#' @param has_rowlabels (`logical(1)`)\cr whether the object being paginated has row labels.

#'

#' @details `pab_indices_inner` implements the core pagination algorithm (see below)

#' for a single direction (vertical if `row = TRUE` (the default), horizontal otherwise)

#' based on the pagination data frame and (already adjusted for non-body rows/columns)

#' lines (or characters) per page.

#'

#' @inheritSection pagination_algo Pagination Algorithm

#'

#' @return A `list` containing a vector of row numbers, broken up by page.

#'

#' @examples

#' mypgdf <- basic_pagdf(row.names(mtcars))

#'

#' paginds <- pag_indices_inner(mypgdf, rlpp = 15, min_siblings = 0)

#' lapply(paginds, function(x) mtcars[x, ])

#'

#' @export

pag_indices_inner <- function(pagdf,

                              rlpp,

                              lpp_or_cpp = NA_integer_, context_lpp_or_cpp = NA_integer_, # Context number of lines

                              min_siblings,

                              nosplitin = character(),

                              verbose = FALSE,

                              row = TRUE,

                              have_col_fnotes = FALSE,

                              div_height = 1L,

                              col_gap = 3L,

                              has_rowlabels) {

      } else {

      }

    }

    )

    )))

  }

}

#' Find column indices for vertical pagination

#'

#' @inheritParams pag_indices_inner

#' @inheritParams open_font_dev

#' @inheritParams format_value

#' @param obj (`ANY`)\cr object to be paginated. Must have a [matrix_form()] method.

#' @param cpp (`numeric(1)`)\cr number of characters per page (width).

#' @param colwidths (`numeric`)\cr vector of column widths (in characters) for use in vertical pagination.

#' @param rep_cols (`numeric(1)`)\cr number of *columns* (not including row labels) to be repeated on every page.

#'   Defaults to 0.

#'

#' @return A `list` partitioning the vector of column indices into subsets for 1 or more horizontally paginated pages.

#'

#' @examples

#' mf <- basic_matrix_form(df = mtcars)

#' colpaginds <- vert_pag_indices(mf, fontspec = font_spec())

#' lapply(colpaginds, function(j) mtcars[, j, drop = FALSE])

#'

#' @export

vert_pag_indices <- function(obj,

                             cpp = 40,

                             colwidths = NULL,

                             verbose = FALSE,

                             rep_cols = 0L,

                             fontspec,

                             nosplitin = character(),

                             round_type = c("iec", "sas")) {

  }

  }

  # rep_extent <- pdf$par_extent[nrow(pdf)]

      "]"

    )

  }

    # cpp - sum(clwds[seq_len(rep_cols)]),

  )

}

mpf_infer_cinfo <- function(mf, colwidths = NULL, rep_cols = num_rep_cols(mf), fontspec, colpaths = NULL) {

  }

  }

  }

      )

    }

  )

      ## nocov start

      stop(

        "Got non-null colpaths with length not equal to number of columns (",

        length(colpaths),

        "!=",

        NROW(pdf),

        ") during MatrixPrintForm construction. Please contact the maintainers."

      )

      ## nocov end

    }

  }

}

#' Basic/spoof pagination info data frame

#'

#' Returns a minimal pagination info `data.frame` (with no info on siblings, footnotes, etc.).

#'

#' @inheritParams test_matrix_form

#' @inheritParams open_font_dev

#' @param rnames (`character`)\cr vector of row names.

#' @param labs (`character`)\cr vector of row labels. Defaults to `rnames`.

#' @param rnums (`integer`)\cr vector of row numbers. Defaults to `seq_along(rnames)`.

#' @param extents (`integer`)\cr number of lines each row requires to print. Defaults to 1 for all rows.

#' @param rclass (`character`)\cr class(es) for the rows. Defaults to `"DataRow"`.

#' @param paths (`list`)\cr list of paths to the rows. Defaults to `lapply(rnames, function(x) c(parent_path, x))`.

#'

#' @return A `data.frame` suitable for use in both the `MatrixPrintForm` constructor and the pagination machinery.

#'

#' @examples

#' basic_pagdf(c("hi", "there"))

#'

#' @export

basic_pagdf <- function(rnames,

                        labs = rnames,

                        rnums = seq_along(rnames),

                        extents = 1L,

                        rclass = "DataRow",

                        parent_path = NULL,

                        paths = lapply(rnames, function(x) c(parent_path, x)),

                        fontspec = font_spec()) {

  )

    # These things are used in the simple case of a split, hence having labels.

    # To improve and extend to other cases

  }

}

## write paginate() which operates **solely** on a MatrixPrintForm obj

page_size_spec <- function(lpp, cpp, max_width,

                           font_family,

                           font_size,

                           lineheight,

                           fontspec = font_spec(

                             font_family = font_family,

                             font_size = font_size,

                             lineheight = lineheight

                           )) {

}

get_font_spec <- function(obj) {

  }

}

calc_lcpp <- function(page_type = NULL,

                      landscape = FALSE,

                      pg_width = page_dim(page_type)[if (landscape) 2 else 1],

                      pg_height = page_dim(page_type)[if (landscape) 1 else 2],

                      fontspec = font_spec(),

                      ## font_family = "Courier",

                      ## font_size = 8, # grid parameters

                      cpp = NA_integer_,

                      lpp = NA_integer_,

                      tf_wrap = TRUE,

                      max_width = NULL,

                      ## lineheight = 1,

                      margins = c(bottom = .5, left = .75, top = .5, right = .75),

                      colwidths,

                      col_gap,

                      inset) {

    ## font_family = font_family,

    ## font_size = font_size,

    ## lineheight = lineheight,

  )

  }

  }

    ## font_family = font_family,

    ## font_size = font_size,

    ## lineheight = lineheight

  )

}

calc_rlpp <- function(pg_size_spec, mf, colwidths, tf_wrap, verbose) {

    ## +1 is for blank line between subtitles and divider

    ## dh is for divider line **between subtitles and column labels**

    ## other divider line is accounted for in cinfo_lines

    } else {

    }

  } else {

  }

  ## dh for divider line between column labels and table body

    )

  }

    )

  }

    } ## space between main and prov footer.

  }

  ## this time its for the divider between the footers and whatever is above them

  ## (either table body or referential footnotes)

  }

  ## this time its for the divider between the referential footnotes and

  ## the table body IFF we have any, otherwise that divider+blanks pace doesn't get drawn

  }

    )

  }