#' Wrapper for generator functions

#' 

#' For a detailed description see the data generator [tutorial](https://deepg.de/articles/data_generator.html).

#' Will choose one of the generators from \code{\link{generator_fasta_lm}}, 

#' \code{\link{generator_fasta_label_folder}}, \code{\link{generator_fasta_label_header_csv}}, 

#' \code{\link{generator_rds}}, \code{\link{generator_random}}, \code{\link{generator_dummy}} or 

#' \code{\link{generator_fasta_lm}} according to the \code{train_type} and \code{random_sampling}

#' arguments.

#'

#' @inheritParams train_model

#' @inheritParams generator_fasta_lm

#' @inheritParams generator_fasta_label_folder

#' @inheritParams generator_fasta_label_header_csv

#' @inheritParams generator_rds

#' @inheritParams generator_random

#' @inheritParams generator_initialize

#' @param path_file_logVal Path to csv file logging used validation files.

#' @examplesIf reticulate::py_module_available("tensorflow")

#' # create dummy fasta files

#' fasta_path <- tempfile()

#' dir.create(fasta_path)

#' create_dummy_data(file_path = fasta_path,

#'                   num_files = 3,

#'                   seq_length = 10,

#'                   num_seq = 5,

#'                   vocabulary = c("a", "c", "g", "t"))

#' 

#' gen <- get_generator(path = fasta_path,

#'                      maxlen = 5, train_type = "lm",

#'                      output_format = "target_right",

#'                      step = 3, batch_size = 7)

#' z <- gen()

#' x <- z[[1]]

#' y <- z[[2]]

#' dim(x)

#' dim(y)

#' 

#' @returns A generator function.

#' @export

get_generator <- function(path = NULL,

                          train_type,

                          batch_size,

                          maxlen,

                          step = NULL,

                          shuffle_file_order = FALSE,

                          vocabulary = c("A", "C", "G", "T"),

                          seed = 1,

                          proportion_entries = NULL,

                          shuffle_input = FALSE,

                          format = "fasta",

                          path_file_log = NULL,

                          reverse_complement = FALSE,

                          n_gram = NULL,

                          n_gram_stride = NULL,

                          output_format = "target_right",

                          ambiguous_nuc = "zero",

                          proportion_per_seq = NULL,

                          skip_amb_nuc = NULL,

                          use_quality_score = FALSE,

                          padding = FALSE,

                          added_label_path = NULL,

                          target_from_csv = NULL,

                          add_input_as_seq = NULL,

                          max_samples = NULL,

                          concat_seq = NULL,

                          target_len = 1,

                          file_filter = NULL,

                          use_coverage = NULL,

                          sample_by_file_size = FALSE,

                          add_noise = NULL,

                          random_sampling = FALSE,

                          set_learning = NULL,

                          file_limit = NULL,

                          reverse_complement_encoding = FALSE,

                          read_data = FALSE,

                          target_split = NULL,

                          path_file_logVal = NULL,

                          model = NULL,

                          vocabulary_label = NULL,

                          masked_lm = NULL,

                          val = FALSE,

                          return_int = FALSE,

                          verbose = TRUE,

                          delete_used_files = FALSE,

                          reshape_xy = NULL) {

  if (random_sampling) {

    if (use_quality_score) stop("use_quality_score not implemented for random sampling")

    if (read_data) stop("read_data not implemented for random sampling")

    if (!is.null(use_coverage)) stop("use_coverage not implemented for random sampling")

    if (!is.null(add_noise)) stop("add_noise not implemented for random sampling")

  }

  if (train_type %in% c("label_rds", "lm_rds") & format != "rds") {

    warning(paste("train_type is", train_type, "but format is not 'rds'"))

  }

  # adjust batch size

  if ((length(batch_size) == 1) && (batch_size %% length(path) != 0) & train_type == "label_folder") {

    batch_size <- ceiling(batch_size/length(path)) * length(path)

    if (!val) {

      message(paste("Batch size needs to be multiple of number of targets. Setting batch_size to", batch_size))

    }

  }

  if (is.null(step)) step <- maxlen

  if (train_type == "dummy_gen") {

    #gen <- generator_dummy(model, ifelse(is.null(set_learning), batch_size, new_batch_size))

    gen <- generator_dummy(model, batch_size)

    removeLog <- FALSE

  }

  if (!is.null(added_label_path) & is.null(add_input_as_seq)) {

    add_input_as_seq <- rep(FALSE, length(added_label_path))

  }

  # language model

  if (train_type == "lm" & random_sampling) {

    gen <- generator_random(

      train_type = "lm",

      output_format = output_format,

      seed = seed[1],

      format = format,

      reverse_complement = reverse_complement,

      reverse_complement_encoding = reverse_complement_encoding,

      path = path,

      batch_size = batch_size,

      maxlen = maxlen,

      ambiguous_nuc = ambiguous_nuc,

      padding = padding,

      vocabulary = vocabulary,

      number_target_nt = target_len,

      target_split = target_split,

      target_from_csv = target_from_csv,

      n_gram = n_gram,

      n_gram_stride = n_gram_stride,

      sample_by_file_size = sample_by_file_size,

      max_samples = max_samples,

      skip_amb_nuc = skip_amb_nuc,

      vocabulary_label = vocabulary_label,

      shuffle_input = shuffle_input,

      proportion_entries = proportion_entries,

      return_int = return_int,

      concat_seq = concat_seq,

      reshape_xy = reshape_xy)

  } 

  if (train_type == "lm" & !random_sampling) {

    gen <- generator_fasta_lm(path_corpus = path, batch_size = batch_size,

                              maxlen = maxlen, step = step, shuffle_file_order = shuffle_file_order,

                              vocabulary = vocabulary, seed = seed[1], proportion_entries = proportion_entries,

                              shuffle_input = shuffle_input, format = format, n_gram_stride = n_gram_stride,

                              path_file_log = path_file_log, reverse_complement = reverse_complement, 

                              output_format = output_format, ambiguous_nuc = ambiguous_nuc,

                              proportion_per_seq = proportion_per_seq, skip_amb_nuc = skip_amb_nuc,

                              use_quality_score = use_quality_score, padding = padding, n_gram = n_gram,

                              added_label_path = added_label_path, add_input_as_seq = add_input_as_seq,

                              max_samples = max_samples, concat_seq = concat_seq, target_len = target_len,

                              file_filter = file_filter, use_coverage = use_coverage, return_int = return_int,

                              sample_by_file_size = sample_by_file_size, add_noise = add_noise,

                              reshape_xy = reshape_xy)

  }

  # label by folder

  if (train_type %in% c("label_folder", "masked_lm") & random_sampling) {

    gen <- generator_random(

      train_type = train_type,

      seed = seed[1],

      format = format,

      reverse_complement = reverse_complement,

      path = path,

      batch_size = batch_size,

      maxlen = maxlen,

      ambiguous_nuc = ambiguous_nuc,

      padding = padding,

      vocabulary = vocabulary,

      number_target_nt = NULL,

      n_gram = n_gram,

      n_gram_stride = n_gram_stride,

      sample_by_file_size = sample_by_file_size,

      max_samples = max_samples,

      skip_amb_nuc = skip_amb_nuc,

      shuffle_input = shuffle_input,

      set_learning = set_learning,

      reverse_complement_encoding = reverse_complement_encoding,

      vocabulary_label = vocabulary_label,

      proportion_entries = proportion_entries,

      masked_lm = masked_lm,

      return_int = return_int,

      concat_seq = concat_seq,

      reshape_xy = reshape_xy)

  } 

  if (train_type == "label_folder" & !random_sampling) {

    gen_list <- generator_initialize(directories = path, format = format, batch_size = batch_size, maxlen = maxlen, vocabulary = vocabulary,

                                     verbose = verbose, shuffle_file_order = shuffle_file_order, step = step, seed = seed[1],

                                     shuffle_input = shuffle_input, file_limit = file_limit, skip_amb_nuc = skip_amb_nuc,

                                     path_file_log = path_file_log, reverse_complement = reverse_complement,

                                     reverse_complement_encoding = reverse_complement_encoding, return_int = return_int,

                                     ambiguous_nuc = ambiguous_nuc, proportion_per_seq = proportion_per_seq,

                                     read_data = read_data, use_quality_score = use_quality_score, val = val,

                                     padding = padding, max_samples = max_samples, concat_seq = concat_seq,

                                     added_label_path = added_label_path, add_input_as_seq = add_input_as_seq, use_coverage = use_coverage,

                                     set_learning = set_learning, proportion_entries = proportion_entries,

                                     sample_by_file_size = sample_by_file_size, n_gram = n_gram, n_gram_stride = n_gram_stride,

                                     add_noise = add_noise, reshape_xy = reshape_xy)

    gen <- generator_fasta_label_folder_wrapper(val = val, path = path, 

                                                batch_size = batch_size, voc_len = length(vocabulary),

                                                gen_list = gen_list,

                                                maxlen = maxlen, set_learning = set_learning)

  }

  if (train_type == "masked_lm" & !random_sampling) {

    stopifnot(!is.null(masked_lm))

    gen <- generator_fasta_label_folder(path_corpus = unlist(path),

                                        format = format,

                                        batch_size = batch_size,

                                        maxlen = maxlen,

                                        vocabulary = vocabulary,

                                        shuffle_file_order = shuffle_file_order,

                                        step = step,

                                        seed = seed,

                                        shuffle_input = shuffle_input,

                                        file_limit = file_limit,

                                        path_file_log = path_file_log,

                                        reverse_complement = reverse_complement,

                                        reverse_complement_encoding = reverse_complement_encoding,

                                        num_targets = 1,

                                        ones_column = 1,

                                        ambiguous_nuc = ambiguous_nuc,

                                        proportion_per_seq = proportion_per_seq,

                                        read_data = read_data,

                                        use_quality_score = use_quality_score,

                                        padding = padding,

                                        added_label_path = added_label_path,

                                        add_input_as_seq = add_input_as_seq,

                                        skip_amb_nuc = skip_amb_nuc,

                                        max_samples = max_samples,

                                        concat_seq = concat_seq,

                                        file_filter = NULL,

                                        return_int = return_int,

                                        use_coverage = use_coverage,

                                        proportion_entries = proportion_entries,

                                        sample_by_file_size = sample_by_file_size,

                                        n_gram = n_gram,

                                        n_gram_stride = n_gram_stride,

                                        masked_lm = masked_lm,

                                        add_noise = add_noise,

                                        reshape_xy = reshape_xy) 

  }

  if ((train_type == "label_csv" | train_type == "label_header") & !random_sampling) {

    gen <- generator_fasta_label_header_csv(path_corpus = path, format = format, batch_size = batch_size, maxlen = maxlen,

                                            vocabulary = vocabulary, verbose = verbose, shuffle_file_order = shuffle_file_order, step = step,

                                            seed = seed[1], shuffle_input = shuffle_input, return_int = return_int,

                                            path_file_log = path_file_log, vocabulary_label = vocabulary_label, reverse_complement = reverse_complement,

                                            ambiguous_nuc = ambiguous_nuc, proportion_per_seq = proportion_per_seq,

                                            read_data = read_data, use_quality_score = use_quality_score, padding = padding,

                                            added_label_path = added_label_path, add_input_as_seq = add_input_as_seq,

                                            skip_amb_nuc = skip_amb_nuc, max_samples = max_samples, concat_seq = concat_seq,

                                            target_from_csv = target_from_csv, target_split = target_split, file_filter = file_filter,

                                            use_coverage = use_coverage, proportion_entries = proportion_entries,

                                            sample_by_file_size = sample_by_file_size, n_gram = n_gram, n_gram_stride = n_gram_stride,

                                            add_noise = add_noise, reverse_complement_encoding = reverse_complement_encoding,

                                            reshape_xy = reshape_xy)

  }

  if ((train_type == "label_csv" | train_type == "label_header") & random_sampling) {

    gen <- generator_random(

      train_type = train_type, 

      output_format = output_format,

      seed = seed[1],

      format = format,

      reverse_complement = reverse_complement,

      reverse_complement_encoding = reverse_complement_encoding,

      path = path,

      batch_size = batch_size,

      maxlen = maxlen,

      ambiguous_nuc = ambiguous_nuc,

      padding = padding,

      vocabulary = vocabulary,

      number_target_nt = NULL,

      n_gram = n_gram,

      n_gram_stride = n_gram_stride,

      sample_by_file_size = sample_by_file_size,

      max_samples = max_samples,

      skip_amb_nuc = skip_amb_nuc,

      vocabulary_label = vocabulary_label,

      target_from_csv = target_from_csv,

      target_split = target_split,

      verbose = verbose,

      shuffle_input = shuffle_input,

      proportion_entries = proportion_entries,

      return_int = return_int,

      concat_seq = concat_seq,

      reshape_xy = reshape_xy)

  }

  if (train_type %in% c("label_rds", "lm_rds")) {

    reverse_complement <- FALSE

    step <- 1

    if (train_type == "label_rds") target_len <- NULL

    gen <- generator_rds(rds_folder = path, batch_size = batch_size, path_file_log = path_file_log,

                         max_samples = max_samples, proportion_per_seq = proportion_per_seq,

                         sample_by_file_size = sample_by_file_size, add_noise = add_noise,

                         reverse_complement_encoding = reverse_complement_encoding, seed = seed[1],

                         target_len = target_len, n_gram = n_gram, n_gram_stride = n_gram_stride,

                         delete_used_files = delete_used_files, reshape_xy = reshape_xy)

  }

  return(gen)

}