#' @title Predict ICH Segmentation
#' @description Will preprocess and predict the ICH voxels
#'
#' @param img CT image, object of class \code{nifti} or
#' character filename
#' @param mask binary brain mask, object of class \code{nifti} or
#' character filename
#' @param model model to use for prediction,
#' either the random forest (rf) or logistic
#' @param save_imgs Logical to save all images that are created as
#' predictors
#' @param outdir Output directory of saved images, needs to be set
#' if \code{save_imgs = TRUE}
#' @param stub Basename to write image names if \code{save_imgs = TRUE}
#' @param verbose Print diagnostic output
#' @param shiny Should shiny progress be called?
#' @param roi Filename of ROI, which will be transformed
#' @param erode_mask Should the brain mask be eroded?
#' @param outfile filename for native-space, smoothed,
#' thresholded image.
#' @param ... Additional options passsed to \code{\link{ich_preprocess}}
#'
#' @return List of output prediction/probability images
#' @export
#' @importFrom fslr have.fsl
ich_segment = function(img,
                       ...,
                       verbose = TRUE,
                       shiny = FALSE,
                       model = c("rf", "logistic", "big_rf"),
                       outfile = NULL) {

  model = match.arg(model)

  L = ich_process_predictors(
    img = img,
    ...,
    verbose = verbose,
    roi = NULL)
  df = L$img.pred$df
  nim = L$img.pred$nim
  L$img.pred = NULL
  preprocess = L$preprocess
  rm(list = "L");   gc()


  # data(MOD)
  ##############################################################
  # Making prediction images
  ##############################################################
  # grabbing the environment to extract exported stuff
  if (verbose) {
    msg = "# Running ich_predict"
    message(msg)
  }
  if (shiny) {
    shiny::setProgress(message = msg, value = 3/3 - 0.3)
  }
  L = ich_predict(df = df,
                  nim = nim,
                  model = model,
                  native_img = img,
                  native = TRUE,
                  verbose = verbose,
                  transformlist = preprocess$invtransforms,
                  interpolator = preprocess$interpolator,
                  shiny = shiny,
                  outfile = outfile)
  L$preprocess = preprocess
  if (shiny) {
    shiny::setProgress(value = 3/3)
  }
  return(L)

}


#' @rdname ich_segment
#' @export
ich_process_predictors = function(
  img,
  mask = NULL,
  save_imgs = FALSE,
  outdir = NULL,
  stub = NULL,
  verbose = TRUE,
  shiny = FALSE,
  roi = NULL,
  erode_mask = TRUE,
  ...) {

  if (!have.fsl()) {
    stop("FSL Path Not Found!")
  }

  if (verbose) {
    msg = "# Processing The Data"
    message(msg)
  }
  if (shiny) {
    shiny::setProgress(message = msg, value = 0)
  }
  if (save_imgs) {
    if (is.character(img)) {
      if (is.null(stub)) {
        stub = paste0(nii.stub(img, bn = TRUE), "_reg_")
      }
    }
  }

  if (save_imgs) {
    stopifnot(!is.null(outdir))
    stopifnot(!is.null(stub))
  }
  if (is.null(outdir)) {
    outdir = tempdir()
  }

  trans_fname = trans_mask_fname = trans_roi_fname = ""
  if (save_imgs) {
    trans_fname = file.path(outdir, paste0(stub, "_", "image.nii.gz"))
    if (!is.null(roi)) {
      trans_roi_fname = file.path(outdir, paste0(stub, "_", "roi.nii.gz"))
    } else {
      trans_roi_fname = NULL
    }
    trans_mask_fname = file.path(outdir, paste0(stub, "_", "mask.nii.gz"))
  }

  fnames = c(trans_fname, trans_roi_fname, trans_mask_fname)

  if (!all(file.exists(fnames))) {
    # orig.img = img
    preprocess = ich_preprocess(
      img = img,
      mask = mask,
      verbose = verbose,
      shiny = shiny,
      roi = roi,
      ...)

    timg = preprocess$transformed_image
    troi = preprocess$transformed_roi
    tmask = preprocess$transformed_mask > 0.5

    if (save_imgs) {
      writenii(timg, trans_fname)
      if (!is.null(troi)) {
        writenii(troi, trans_roi_fname)
      }
      writenii(tmask, trans_mask_fname)
    }
  } else {
    timg = readnii(trans_fname)
    if (file.exists(trans_roi_fname)) {
      troi = readnii(trans_roi_fname)
    } else {
      troi = NULL
    }
    tmask = readnii(trans_mask_fname)
    preprocess = list(
      transformed_roi = troi,
      transformed_image = timg,
      transformed_mask = tmask
    )
  }


  L = list(
    preprocess = preprocess
  )
  rm(list = "preprocess"); gc()

  if (verbose) {
    msg = "# Making Predictors"
    message(msg)
  }
  if (shiny) {
    shiny::setProgress(message = msg, value = 1/3)
  }

  img.pred = make_predictors(
    timg, mask = tmask,
    roi = troi,
    save_imgs = save_imgs,
    stub = stub,
    outdir = outdir,
    verbose = verbose,
    shiny = shiny,
    erode_mask = erode_mask)
  L$img.pred = img.pred
  rm(list = "img.pred")
  gc()

  if (shiny) {
    shiny::setProgress(value = 2/3)
  }
  return(L)
}