#' a local package to find its dependencies. If the package does not exist locally, 

#'        If this is specified to be \code{NULL}, the function will return the exact

#'        \code{Require} call needed to install all the packages at their current

#'        versions. This can be useful to add to a script to allow for reproducibility of

#'        a script.

#' @param exact Logical. If \code{TRUE}, the default, then for GitHub packages, it

#'        will install the exact SHA, rather than the head of the account/repo@branch. For

#'        CRAN packages, it will install the exact version. If \code{FALSE}, then GitHub

#'        packages will identify their branch if that had been specified upon installation, 

#'        not a SHA. If the package had been installed with reference to a SHA, then it

#'        will return the SHA as it does not know what branch it came from. 

#'        Similarly, CRAN packages will

#'        report their version and specify with a \code{>=}, allowing a subsequent user

#'        to install with a minimum version number, as opposed to an exact version number.

#' 

#' # Passing NULL --> results in output to console with exact Require call to 

#' #   achieve the packages installations

#' pkgSnapshot(NULL, libPaths = .libPaths()[1], exact = FALSE)

#' 

#' # Or shunt it to a file

#' sink("packages2.R")

#' pkgSnapshot(NULL, libPaths = .libPaths()[1])

#' sink()

#' 

#' # Will show "minimum package version"

#' pkgSnapshot(NULL, libPaths = .libPaths()[1], exact = FALSE)

                        purge = getOption("Require.purge", FALSE), exact = TRUE) {

    # aa <- pkgDep("SpaDES", recursive = T)

    # cc <- bb[bb$Package %in% extractPkgName(aa$SpaDES) & bb$LibPath == bb$LibPath[1],]

    } else {

    }

    # cat(ee, file = "packages.R")

    # source("packages.R")

  } else {

  }

        if (NROW(oldAvailableVersions) && "PackageUrl" %in% colnames(oldAvailableVersions)) {

          # packages installed locally via devtools::install will have no known source -- will be NA

          oldAvailableVersions[!is.na(OlderVersionsAvailable), OlderVersionsAvailableCh := as.character(package_version(OlderVersionsAvailable))]

  if (!is.null(rpackageFolder(getOption("Require.RPackageCache")))) {

    localFiles <- dir(rpackageFolder(getOption("Require.RPackageCache")), full.names = TRUE)

          # Here, we don't know what version it should be, so take latest from CRAN as the needed version

            # Checks -- if there is no versionSpec, it will be NA --> check "Version" next

            }

            # Checks -- if there is no versionSpec or Version, it will be "" --> check "AvailableVersion" next

            }

          }

            else 

#' @param other Any other keyword in a DESCRIPTION file that precedes a ":". The rest of the line will be

    # if (any(attempts >= maxAttempts)) {

    #   failedAttempts <- attempts[attempts >= maxAttempts]

    #   outRes[attempts >= maxAttempts] <- "Failed"  

    #   if (any(identical("message", names(warn[[1]]) ))) {

    #     if (is.character(warn[[1]]$message)) {

    #       outRes[attempts >= maxAttempts] <- warn[[1]]$message

    #     }   

    #   }

    # }

      # failedAttempts <- names(gitPkgs)

    }

}

rpackageFolder <- function(path = getOption("Require.RPackageCache"), exact = FALSE)  {

  if (!is.null(path)) {

    if (isTRUE(exact))

      return(path)

    path <- path[1]

    rversion <- paste0(R.version$major, ".", strsplit(R.version$minor, split = "\\.")[[1]][1])

    if (normPath(path) %in% normPath(strsplit(Sys.getenv("R_LIBS_SITE"), split = ":")[[1]])) {

      path

    } else {

      if (!endsWith(path, rversion))

        file.path(path, rversion)

      else 

        path

    }

  } else {

  }

}

checkLibPaths <- function(libPaths, ifMissing, exact = FALSE) {

  if (missing(libPaths)) {

    if (missing(ifMissing))

      return(.libPaths())

    else {

    }

  } else {

    pathsToCheck <- libPaths

  }

  unlist(lapply(pathsToCheck, function(lp) 

    checkPath(rpackageFolder(lp, exact = exact), create = TRUE)))

}

preparePkgNameToReport <- function(Package, packageFullName) {

#' in an R-version specific subfolder of 

#' \code{getOption("Require.RPackageCache")} whose default is `NULL`, meaning 

  libPaths <- checkLibPaths(libPaths = libPaths)

  # if (missing(libPaths))

  #   libPaths <- .libPaths()

  on.exit({suppressMessages(setLibPaths(origLibPaths, standAlone = TRUE, exact = TRUE))}, 

          add = TRUE)

    # some cases, original was without version, but due to a dependency that does have a version, 

    # it is no longer the same as orig package name

#' \code{c(libPath, tail(.libPaths(), 1))} if \code{standAlone = TRUE}. Currently,

#' the default is to make this new \code{.libPaths()} "sticky", meaning it becomes 

#' associated with the current directory even through a restart of R. It does this

#' by adding and/updating the .Rprofile file in the current directory. If this

#' current director is a project, then the project will have the new \code{.libPaths()}

#' associated with it, even through an R restart.

#' This details of this code were modified from \url{https://github.com/milesmcbain}.

#' @param updateRprofile Logical or Character string. If \code{TRUE}, then

#'   this function will put several lines of code in the current directory's \code{.Rprofile} 

#'   file setting up the package libraries for this and future sessions. If

#'   a character string, then this should be the path to an \code{.Rprofile} file.

#'   To reset back to normal, run \code{setLibPaths()} without a libPath. Default:

#'   \code{getOption("Require.updateRprofile", FALSE)}, meaning \code{FALSE}, but it

#'   can be set with an option or within a single call.

#' @param exact Logical. This function will automatically append the R version number to the

#'   \code{libPaths} to maintain separate R package libraries for each R version

#'   on the system. There are some cases where this behaviour is not desireable. 

#'   Set \code{exact} to \code{TRUE} to override this automatic appending and use

#'   the exact, unaltered \code{libPaths}. Default is \code{FALSE}

#' origDir <- setwd(tempdir())

#' setLibPaths("newProjectLib") # set a new R package library locally

#' setLibPaths() # reset it to original

#' setwd(origDir)

#' # Using standAlone = FALSE means that newly installed packages will be installed

#' #   in the new package library, but loading packages can come from any of the ones

#' #   listed in .libPaths()

#' # Can restart R, and changes will stay

#' 

#' # remove the custom .libPaths()

#' Require::setLibPaths() # reset to previous; remove from Rprofile because libPath arg is empty

setLibPaths <- function(libPaths, standAlone = TRUE, 

                        updateRprofile = getOption("Require.updateRprofile", FALSE),

                        exact = FALSE) {

  if (missing(libPaths)) {

    return(checkMissingLibPaths(libPaths, updateRprofile))

  } ## End missing

  libPaths <- checkLibPaths(libPaths, exact = exact)

  #libPaths <- checkPath(normPath(libPaths), create = TRUE)#, mustWork = TRUE)

  if (!is.null(updateRprofile)) {

    setLibPathsUpdateRprofile(libPaths, standAlone, updateRprofile)

  }

  if (getOption("Require.setupVerbose", TRUE)) 

    message(".libPaths() is now: ", paste(.libPaths(), collapse = ", "))

setLibPathsUpdateRprofile <- function(libPaths, standAlone = TRUE, updateRprofile = NULL) {

  updateRprofile <- checkTRUERprofile(updateRprofile)

  if (is.character(updateRprofile)) {

    newFile <- FALSE

    if (!file.exists(updateRprofile)) {

      newFile <- TRUE

      file.create(updateRprofile)

      if (file.exists(".gitignore")) {

        if (!isTRUE(any(grepl(".Rprofile", readLines(".gitignore")))))

      }

    }

    if (any(grepl(setLibPathsStartText, readLines(".Rprofile")))) {

    } else {

      bodyFn <- format(body(Require::setLibPaths))

      lineWCheckPath <- grepl("checkPath.normPath|checkLibPaths", bodyFn)

      bodyFn[lineWCheckPath] <- "    if (!dir.exists(libPaths[1])) dir.create(libPaths[1], recursive = TRUE)"

      lineWReturn <- grepl("return.*oldLibPaths", bodyFn)

      bodyFn <- bodyFn[!lineWReturn] 

      bodyFn <- gsub("tail", "utils::tail", bodyFn)

      bodyFn <- gsub("shim_env", ".shim_env", bodyFn)

      bodyFn <- gsub("shim_fun", ".shim_fun", bodyFn)

      bodyFn <- gsub("oldLibPaths", ".oldLibPaths", bodyFn)

      lineWMissing <- which(grepl("missing.libPaths", bodyFn))

      bodyFn <- bodyFn[-(lineWMissing:(lineWMissing+2))] 

      lineWRprofileToUpdate <- which(grepl("is\\.null\\(updateRprofile\\)", bodyFn))

      bodyFn <- bodyFn[-(lineWRprofileToUpdate:(lineWRprofileToUpdate+2))] 

      bodyFn <- gsub("\\<standAlone\\>", "._standAlone", bodyFn)

      bodyFn <- gsub("\\.libPaths", "origDotlibPaths", bodyFn)

      bodyFn <- gsub("\\<libPaths\\>", "._libPaths", bodyFn)

      bodyFn <- gsub("origDotlibPaths", ".libPaths", bodyFn)

      bodyFn <- c(paste0("\n",setLibPathsStartText," #### ",newFileTrigger, newFile,

                         " # DO NOT EDIT BETWEEN THESE LINES"),

                  "### DELETE THESE LINES BELOW TO RESTORE STANDARD R Package LIBRARY", 

                  paste0("### ", prevLibPathsText, paste(.libPaths(), collapse = ", ")),

                  paste0("._libPaths <- c('", paste(libPaths, collapse = "', '"), "')"), 

                  paste0("._standAlone <- ", standAlone), 

                  bodyFn, 

                  if (getOption("Require.setupVerbose", TRUE)) resetRprofileMessage(updateRprofile),

                  paste0(commentCharsForSetLibPaths, "end ####"))

      if (getOption("Require.setupVerbose", TRUE)) 

        message("Updating ", updateRprofile, "; this will set new libPaths for R packages even after restarting R")

      cat(bodyFn, file = ".Rprofile", append = TRUE, sep = "\n")

    }

  }

}

checkMissingLibPaths <- function(libPaths, updateRprofile = NULL) {

  if (!is.null(updateRprofile)) {

    if (updateRprofile == FALSE && missing(libPaths))

      updateRprofile <- TRUE

    updateRprofile <- checkTRUERprofile(updateRprofile)

    noChange <- FALSE

    if (is.character(updateRprofile)) {

      if (file.exists(updateRprofile)) {

        ll <- readLines(updateRprofile)

        bounds <- which(grepl("#### setLibPaths", ll))

        if (length(bounds)) {

          if (getOption("Require.setupVerbose", TRUE)) 

            message("removing custom libPaths in .Rprofile")

          if (identical("", ll[bounds[1] - 1])) {

            bounds[1] <- bounds[1] - 1

          }

          newFileLine <- grepl(newFileTrigger, ll)

          newFile <- gsub(paste0(".*", newFileTrigger, "([[:alpha:]]+) .*"), "\\1", ll[newFileLine])

          wasNew <- as.logical(newFile)

          prevLines <- grepl(prevLibPathsText, ll)

          prevLibPaths <- strsplit(gsub(paste0(".*", prevLibPathsText), "", ll[prevLines]), split = ", ")[[1]]

          setLibPaths(prevLibPaths, updateRprofile = FALSE, exact = TRUE)

          if (isTRUE(wasNew) && which(newFileLine) == 2) { # needs to be NEW and starts on 2nd line

            file.remove(updateRprofile) 

          } else {

          }

        } else {

        }

      } else {

      }

      if (isTRUE(noChange)) 

      return(invisible())

    }

  } 

}

resetRprofileMessage <- function(updateRprofile = ".Rprofile") {

  paste0("message(\"To reset libPaths to previous state, run: Require::setupOff() (or delete section in .Rprofile file)\") ")

}

checkTRUERprofile <- function(updateRprofile) {

  if (isTRUE(updateRprofile)) updateRprofile <- ".Rprofile"

  updateRprofile

}

prevLibPathsText <- "Previous .libPaths: "

commentCharsForSetLibPaths <- "#### setLibPaths "

setLibPathsStartText <- paste0(commentCharsForSetLibPaths, "start")

newFileTrigger <- "New File:"

alreadyInRprofileMessage <- "There is already a setLibPaths in the .Rprofile, skipping"

  while ((NROW(pkgDTDeps[[i]]) & recursive) || (recursive == FALSE & NROW(pkgDTDeps[[i]]) == 1)) {

    pkgDTDeps[[i + 1]] <- rbindlist(

    if (NROW(pkgDTDeps[[i + 1]]) > 0) { 

      pkgDTDeps[[i + 1]] <- cleanUp(pkgDTDeps[[i + 1]], includeBase = includeBase)

    if (NROW(pkgDTDeps[[i + 1]])) {

      if (length(unique(pkgDTDeps[[i + 1]]$which)) > 1) {

        set(pkgDTDeps[[i + 1]], NULL, "whichFac", 

            factor(pkgDTDeps[[i + 1]]$which, 

        setorderv(pkgDTDeps[[i + 1]], "whichFac")

        set(pkgDTDeps[[i + 1]], NULL, "whichFac", NULL)

      set(pkgDTDeps[[i + 1]], NULL, "hasVersionSpec", grepl(.grepVersionNumber, pkgDTDeps[[i + 1]]$packageFullName))

      pkgDTDeps[[i + 1]] <- keepOnlyMaxVersion(pkgDTDeps[[i + 1]])

    pkgDTComplete[[i + 1]] <- data.table::copy(pkgDTDeps[[i + 1]])

    if (NROW(pkgDTComplete[[i + 1]]) == 0)  {

    # alreadyDone <- pkgDTDeps[[i + 1]]$packageFullName %in% 

    #   pkgDTDeps[[i + 1]] <- pkgDTDeps[[i + 1]][alreadyDone == FALSE]

    #   pkgDTDeps[[i + 1]] <- pkgDTDeps[[i + 1]][0] 

    # pkgDTDeps[[i + 1]] <- pkgDTDeps[[i + 1]][!duplicated(pkgDTDeps[[i + 1]]$Package)] # remove imports where there is remotes

    message("available.packages() does not have correct information on package dependencies for ",

#' Setup a project library, cache, options

#' 

#' This can be placed as the first line of any/all scripts and it will

#' be create a reproducible, self-contained project with R packages. 

#' Some of these have direct relationships with \code{RequireOptions}

#' and arguments in \code{setLibPaths} and \code{Require}.

#' @param RPackageFolders One or more folders where R packages are 

#'   installed to and loaded from. In the case of more than one 

#'   folder provided, installation will only happen in the first one.

#' @param RPackageCache See \code{?RequireOptions}.

#' @param buildBinaries See \code{?RequireOptions}.

#' @inheritParams setLibPaths

#' @export

#' @rdname setup

#' 

#' @examples 

#' # Place this as the first line of a project

#' \dontrun{

#' Require::setup()

#' 

#' # To turn it off and return to normal

#' Require::setupOff()

#' }

#'   

setup <- function(RPackageFolders = getOption("RPackageFolders", "R"), 

                  RPackageCache = getOption("RPackageCache", "~/.cache/R/RequirePkgCache"), 

                  buildBinaries = getOption("buildBinaries", TRUE), 

                  standAlone = getOption("standAlone", TRUE)) {

  RPackageFolders <- checkPath(RPackageFolders, create = TRUE)

  RPackageCache <- checkPath(RPackageCache, create = TRUE)

  # hasCranCache <- any(dir.exists(file.path(.libPaths(), "crancache")))

  # usingCranCache <- FALSE

  # 

  # if (hasCranCache && !isFALSE(getOption("Require.useCranCache"))) { # if NULL or TRUE go here

  #   rvn <- paste0(R.version$major, '.', strsplit(R.version$minor, split = '\\.')[[1]][1])

  #   os <- tolower(.Platform$OS.type)

  #   extra <- file.path('cran','bin', os,'contrib', rvn, fsep = "/")

  #   usingCranCache <- !endsWith(RPackageCache, extra)

  #   if (usingCranCache) {

  #     if (interactive()) {

  #       message("crancache is installed; would you like to have Require and ",

  #               "crancache share the cache? If N, then Require will use ",

  #               RPackageCache)

  #       useSameCache <- readline("Use same cache? (Y or N)")

  #       if (identical(tolower(useSameCache), "y")) {

  #         stop(paste0("To use crancache cached packages, please rerun:\n",

  #                     "setup(RPackageCache = normalizePath(file.path(crancache::get_cache_dir(),'",extra,"'),

  #                            winslash = '/'))"))

  #       }

  #     }

  #   } else {

  #     usingCranCache <- TRUE

  #   }

  # }

  copyRequireAndDeps(RPackageFolders)

  newOpts <- list("Require.RPackageCache" = RPackageCache,

                  "Require.buildBinaries" = buildBinaries)#,

                  #"Require.useCranCache" = usingCranCache)

  opts <- options(newOpts)

  co <- capture.output(type = "message", 

                       setLibPaths(RPackageFolders, standAlone = standAlone, 

                                   updateRprofile = TRUE))

  if (!any(grepl(alreadyInRprofileMessage, co)))

    if (getOption("Require.setupVerbose", TRUE)) 

      silence <- lapply(co, message)

  ro <- RequireOptions()

  roNames <- names(newOpts)

  names(roNames) <- roNames

  nonStandardOpt <- !unlist(lapply(roNames, function(optNam) identical(ro[[optNam]], opts[[optNam]])))

  if (any(nonStandardOpt)) {

    rp <- readLines(".Rprofile")

    lineWithPrevious <- grepl("### Previous", rp)

    if (any(lineWithPrevious)) {

      lineWithPrevious <- which(lineWithPrevious)

      post <- seq(length(rp) - lineWithPrevious) + lineWithPrevious

      pre <- seq(lineWithPrevious)

      nameNonStandards <- names(nonStandardOpt)[nonStandardOpt]

      optsToAdd <- unlist(lapply(nameNonStandards, function(nns) {

        paste0("### Previous option: ", nns, " = ", opts[[nns]])

      }))

      newOptsToAdd <- unlist(lapply(nameNonStandards, function(nns) {

        paste0("options('", nns, "' = '", newOpts[[nns]], "')")

      }))

      newRP <- c(rp[pre], optsToAdd, newOptsToAdd, rp[post])

      cat(newRP, file = ".Rprofile", sep = "\n")

    }

  }

}

#' @rdname setup

#' @export

#' @param removePackages Logical. If \code{TRUE}, then all packages that

#'   were installed in the custom library will be deleted when \code{setupOff}

#'   is run. The default is \code{FALSE}, and when \code{TRUE} is selected,

#'   and it is an interactive session, the user will be prompted to confirm

#'   deletions.

setupOff <- function(removePackages = FALSE) {

  lps <- .libPaths()

  if (file.exists(".Rprofile")) {

    rp <- readLines(".Rprofile")

    lineWithPrevious <- grepl("### Previous option", rp)

    options(RequireOptions())

    if (any(lineWithPrevious)) {

      lineWithPrevious <- which(lineWithPrevious)

      silence <- lapply(lineWithPrevious, function(lwp) {

        opt <- gsub("### Previous option: ", "", rp[lwp])

        opt <- strsplit(opt, " = ")[[1]]

        newOpt <- list(opt[2])

        names(newOpt) <- opt[1]

        options(newOpt)

      })

    }

    setLibPaths()

    if (isTRUE(removePackages)) {

      } 

    }

  } else {

  }

}

copyRequireAndDeps <- function(RPackageFolders) {

  lps <- .libPaths()

  names(lps) <- lps

  pkgs <- c("Require", "remotes", "data.table")

  for (pkg in pkgs) {

    theNewPath <- file.path(rpackageFolder(RPackageFolders), pkg)

    newPathExists <- dir.exists(theNewPath)

    for (lp in lps) {

      thePath <- file.path(lp, pkg)

      pkgInstalledAlready <- dir.exists(thePath)

      if (isTRUE(pkgInstalledAlready)) {

        fromFiles <- dir(thePath, recursive = TRUE, full.names = TRUE)

        if (!newPathExists) {

          if (getOption("Require.setupVerbose", TRUE)) 

            message("Placing copy of ", pkg, " in ", RPackageFolders)

          dirs <- unique(dirname(fromFiles))

          dirs <- gsub(thePath, theNewPath, dirs)

          lapply(dirs, checkPath, create = TRUE)

        }

        toFiles <- gsub(thePath, theNewPath, fromFiles)

        if (newPathExists) {

          newPathVersion <- DESCRIPTIONFileVersionV(file.path(theNewPath, "DESCRIPTION"))

          oldPathVersion <- DESCRIPTIONFileVersionV(file.path(thePath, "DESCRIPTION"))

          comp <- compareVersion(newPathVersion, oldPathVersion)

          if (comp > -1) break

        }

        file.link(fromFiles, toFiles)

        break

      }

    }

  }

}

#' \code{modifyList} for multiple lists

#' \code{\link[base]{Reduce}}, so it can handle >2 lists.

#' The subsequent list elements that share a name will override 

#' previous list elements with that same name.

#' It also will handle the case where any list is a \code{NULL}