import
  future, options, os, posix, sequtils, strutils, tables,
  "../args", "../aur", "../common", "../config", "../format", "../lists",
    "../package", "../pacman", "../utils",
  "../wrapper/alpm"

type
  BaseTarget = tuple[
    base: string,
    version: string,
    destination: string,
    aurGitUrl: Option[string],
    gitRepo: Option[GitRepo]
  ]

  CloneResult = tuple[
    base: string,
    path: string,
    files: seq[string],
    destination: string
  ]

proc getFilesOrClear(base: string, repoPath: string, gitSubdir: Option[string]):
  (seq[string], Option[string]) =
  let rawFiles = getGitFiles(repoPath, gitSubdir, false)
    .filter(f => f != ".gitignore" and f != ".SRCINFO" and f.find('/') < 0)
    .map(f => gitSubdir.map(s => s & "/" & f).get(f))

  if rawFiles.len > 0:
    (rawFiles, none(string))
  else:
    removeDirQuiet(repoPath)
    (newSeq[string](), some(tr"$#: failed to clone git repository" % [base]))

proc cloneRepositories(config: Config, targets: seq[BaseTarget],
  update: (int, int) -> void): (List[CloneResult], List[string]) =
  proc cloneNext(index: int, results: List[CloneResult], messages: List[string]):
    (List[CloneResult], List[string]) =
    update(index, targets.len)

    if index >= targets.len:
      (results.reversed, messages.reversed)
    else:
      let target = targets[index]
      let repoPath = repoPath(config.tmpRootCurrent, target.base)
      removeDirQuiet(repoPath)

      if target.aurGitUrl.isSome:
        let (cloneCode, cerror) = cloneAurRepo(config,
          target.base, target.aurGitUrl.unsafeGet, false)

        if cloneCode != 0:
          cloneNext(index + 1, results, toSeq(cerror.items) ^& messages)
        else:
          let (files, ferror) = getFilesOrClear(target.base, repoPath, none(string))
          if ferror.isSome:
            cloneNext(index + 1, results, ferror.unsafeGet ^& messages)
          else:
            cloneNext(index + 1, (target.base, repoPath, files,
              target.destination) ^& results, messages)
      elif target.gitRepo.isSome:
        let gitRepo = target.gitRepo.unsafeGet
        let cerror = clonePackageRepo(config, target.base,
          target.version, gitRepo, false)

        if cerror.isSome:
          cloneNext(index + 1, results, cerror.unsafeGet ^& messages)
        else:
          let (files, ferror) = getFilesOrClear(target.base, repoPath, some(gitRepo.path))
          if ferror.isSome:
            cloneNext(index + 1, results, ferror.unsafeGet ^& messages)
          else:
            cloneNext(index + 1, (target.base, repoPath, files,
              target.destination) ^& results, messages)
      else:
        let message = tr"$#: repository not found" % [target.base]
        cloneNext(index + 1, results, message ^& messages)

  cloneNext(0, nil, nil)

proc copyFiles(config: Config, quiet: bool, results: seq[CloneResult]): List[string] =
  proc copyNext(index: int, messages: List[string]): List[string] =
    if index >= results.len:
      messages.reversed
    else:
      let res = results[index]
      discard mkdir(res.destination, 0o755)

      let error = try:
        for f in res.files:
          let index = f.rfind('/')
          let name = if index >= 0: f[index + 1 .. ^1] else: f
          let dest = if res.destination == ".": name else: res.destination & "/" & name
          moveFile(res.path & "/" & f, dest)
          printFile(config.color, quiet, res.base, dest)
        none(string)
      except OSError:
        some(tr"$#: failed to move files" % [res.base])

      copyNext(index + 1, toSeq(error.items) ^& messages)

  copyNext(0, nil)

proc cloneAndCopy(config: Config, quiet: bool,
  fullTargets: seq[FullPackageTarget[RpcPackageInfo]]): int =
  let baseTargets = fullTargets.foldl(block:
    let bases = a.map(x => x.base)
    if b.isAurTargetFull:
      let rpcInfo = b.pkgInfo.get
      if rpcInfo.base in bases:
        a
      else:
        a & (rpcInfo.base, rpcInfo.version, b.destination.get(rpcInfo.base),
          some(rpcInfo.gitUrl), none(GitRepo))
    else:
      let foundInfo = b.foundInfos[0]
      let pkg = foundInfo.pkg.get
      if pkg.base in bases:
        a
      else:
        let git = lookupGitRepo(foundInfo.repo, pkg.base, pkg.arch.get)
        a & (pkg.base, pkg.version, b.destination.get(pkg.base),
          none(string), git),
    newSeq[BaseTarget]())

  let (update, terminate) = if quiet:
      (proc (a: int, b: int) {.closure.} = discard, proc () {.closure.} = discard)
    else:
      printProgressShare(config.progressBar, tr"cloning repositories")

  let (results, rerrors) = cloneRepositories(config, baseTargets, update)
  terminate()
  for e in rerrors: printError(config.color, e)

  let cerrors = copyFiles(config, quiet, toSeq(results.items))
  for e in cerrors: printError(config.color, e)

  for result in results:
    removeDirQuiet(result.path)
  discard rmdir(config.tmpRootCurrent)

  if rerrors != nil and cerrors != nil:
    1
  else:
    0

proc handleSyncSource*(args: seq[Argument], config: Config): int =
  discard checkAndRefresh(config.color, args)

  let quiet = args.check(%%%"quiet")
  let targets = args.packageTargets(true)

  if targets.len == 0:
    printError(config.color, trp("no targets specified (use -h for help)\n"))
    1
  else:
    let (syncTargets, checkAurNames) = withAlpm(config.root, config.db,
      config.dbs, config.arch, handle, dbs, errors):
      for e in errors: printError(config.color, e)
      findSyncTargets(handle, dbs, targets, false, false)

    let (rpcInfos, aerrors) = getRpcPackageInfos(checkAurNames)
    for e in aerrors: printError(config.color, e)

    let notFoundTargets = filterNotFoundSyncTargets(syncTargets,
      rpcInfos, initTable[string, PackageReference]())

    if notFoundTargets.len > 0:
      printSyncNotFound(config, notFoundTargets)
      1
    else:
      let fullTargets = mapAurTargets[RpcPackageInfo](syncTargets, rpcInfos)
      cloneAndCopy(config, quiet, fullTargets)