text: 'use strict'
  
  const fs = require('graceful-fs')
  const path = require('path')
  const mkdirs = require('../mkdirs').mkdirs
  const pathExists = require('../path-exists').pathExists
  const utimesMillis = require('../util/utimes').utimesMillis
  const stat = require('../util/stat')
  
  function copy (src, dest, opts, cb) {
    if (typeof opts === 'function' && !cb) {
      cb = opts
      opts = {}
    } else if (typeof opts === 'function') {
      opts = { filter: opts }
    }
  
    cb = cb || function () {}
    opts = opts || {}
  
    opts.clobber = 'clobber' in opts ? !!opts.clobber : true // default to true for now
    opts.overwrite = 'overwrite' in opts ? !!opts.overwrite : opts.clobber // overwrite falls back to clobber
  
    // Warn about using preserveTimestamps on 32-bit node
    if (opts.preserveTimestamps && process.arch === 'ia32') {
      console.warn(`fs-extra: Using the preserveTimestamps option in 32-bit node is not recommended;\n
      see https://github.com/jprichardson/node-fs-extra/issues/269`)
    }
  
    stat.checkPaths(src, dest, 'copy', opts, (err, stats) => {
      if (err) return cb(err)
      const { srcStat, destStat } = stats
      stat.checkParentPaths(src, srcStat, dest, 'copy', err => {
        if (err) return cb(err)
        if (opts.filter) return handleFilter(checkParentDir, destStat, src, dest, opts, cb)
        return checkParentDir(destStat, src, dest, opts, cb)
      })
    })
  }
  
  function checkParentDir (destStat, src, dest, opts, cb) {
    const destParent = path.dirname(dest)
    pathExists(destParent, (err, dirExists) => {
      if (err) return cb(err)
      if (dirExists) return getStats(destStat, src, dest, opts, cb)
      mkdirs(destParent, err => {
        if (err) return cb(err)
        return getStats(destStat, src, dest, opts, cb)
      })
    })
  }
  
  function handleFilter (onInclude, destStat, src, dest, opts, cb) {
    Promise.resolve(opts.filter(src, dest)).then(include => {
      if (include) return onInclude(destStat, src, dest, opts, cb)
      return cb()
    }, error => cb(error))
  }
  
  function startCopy (destStat, src, dest, opts, cb) {
    if (opts.filter) return handleFilter(getStats, destStat, src, dest, opts, cb)
    return getStats(destStat, src, dest, opts, cb)
  }
  
  function getStats (destStat, src, dest, opts, cb) {
    const stat = opts.dereference ? fs.stat : fs.lstat
    stat(src, (err, srcStat) => {
      if (err) return cb(err)
  
      if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts, cb)
      else if (srcStat.isFile() ||
               srcStat.isCharacterDevice() ||
               srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts, cb)
      else if (srcStat.isSymbolicLink()) return onLink(destStat, src, dest, opts, cb)
      else if (srcStat.isSocket()) return cb(new Error(`Cannot copy a socket file: ${src}`))
      else if (srcStat.isFIFO()) return cb(new Error(`Cannot copy a FIFO pipe: ${src}`))
      return cb(new Error(`Unknown file: ${src}`))
    })
  }
  
  function onFile (srcStat, destStat, src, dest, opts, cb) {
    if (!destStat) return copyFile(srcStat, src, dest, opts, cb)
    return mayCopyFile(srcStat, src, dest, opts, cb)
  }
  
  function mayCopyFile (srcStat, src, dest, opts, cb) {
    if (opts.overwrite) {
      fs.unlink(dest, err => {
        if (err) return cb(err)
        return copyFile(srcStat, src, dest, opts, cb)
      })
    } else if (opts.errorOnExist) {
      return cb(new Error(`'${dest}' already exists`))
    } else return cb()
  }
  
  function copyFile (srcStat, src, dest, opts, cb) {
    fs.copyFile(src, dest, err => {
      if (err) return cb(err)
      if (opts.preserveTimestamps) return handleTimestampsAndMode(srcStat.mode, src, dest, cb)
      return setDestMode(dest, srcStat.mode, cb)
    })
  }
  
  function handleTimestampsAndMode (srcMode, src, dest, cb) {
    // Make sure the file is writable before setting the timestamp
    // otherwise open fails with EPERM when invoked with 'r+'
    // (through utimes call)
    if (fileIsNotWritable(srcMode)) {
      return makeFileWritable(dest, srcMode, err => {
        if (err) return cb(err)
        return setDestTimestampsAndMode(srcMode, src, dest, cb)
      })
    }
    return setDestTimestampsAndMode(srcMode, src, dest, cb)
  }
  
  function fileIsNotWritable (srcMode) {
    return (srcMode & 0o200) === 0
  }
  
  function makeFileWritable (dest, srcMode, cb) {
    return setDestMode(dest, srcMode | 0o200, cb)
  }
  
  function setDestTimestampsAndMode (srcMode, src, dest, cb) {
    setDestTimestamps(src, dest, err => {
      if (err) return cb(err)
      return setDestMode(dest, srcMode, cb)
    })
  }
  
  function setDestMode (dest, srcMode, cb) {
    return fs.chmod(dest, srcMode, cb)
  }
  
  function setDestTimestamps (src, dest, cb) {
    // The initial srcStat.atime cannot be trusted
    // because it is modified by the read(2) system call
    // (See https://nodejs.org/api/fs.html#fs_stat_time_values)
    fs.stat(src, (err, updatedSrcStat) => {
      if (err) return cb(err)
      return utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime, cb)
    })
  }
  
  function onDir (srcStat, destStat, src, dest, opts, cb) {
    if (!destStat) return mkDirAndCopy(srcStat.mode, src, dest, opts, cb)
    return copyDir(src, dest, opts, cb)
  }
  
  function mkDirAndCopy (srcMode, src, dest, opts, cb) {
    fs.mkdir(dest, err => {
      if (err) return cb(err)
      copyDir(src, dest, opts, err => {
        if (err) return cb(err)
        return setDestMode(dest, srcMode, cb)
      })
    })
  }
  
  function copyDir (src, dest, opts, cb) {
    fs.readdir(src, (err, items) => {
      if (err) return cb(err)
      return copyDirItems(items, src, dest, opts, cb)
    })
  }
  
  function copyDirItems (items, src, dest, opts, cb) {
    const item = items.pop()
    if (!item) return cb()
    return copyDirItem(items, item, src, dest, opts, cb)
  }
  
  function copyDirItem (items, item, src, dest, opts, cb) {
    const srcItem = path.join(src, item)
    const destItem = path.join(dest, item)
    stat.checkPaths(srcItem, destItem, 'copy', opts, (err, stats) => {
      if (err) return cb(err)
      const { destStat } = stats
      startCopy(destStat, srcItem, destItem, opts, err => {
        if (err) return cb(err)
        return copyDirItems(items, src, dest, opts, cb)
      })
    })
  }
  
  function onLink (destStat, src, dest, opts, cb) {
    fs.readlink(src, (err, resolvedSrc) => {
      if (err) return cb(err)
      if (opts.dereference) {
        resolvedSrc = path.resolve(process.cwd(), resolvedSrc)
      }
  
      if (!destStat) {
        return fs.symlink(resolvedSrc, dest, cb)
      } else {
        fs.readlink(dest, (err, resolvedDest) => {
          if (err) {
            // dest exists and is a regular file or directory,
            // Windows may throw UNKNOWN error. If dest already exists,
            // fs throws error anyway, so no need to guard against it here.
            if (err.code === 'EINVAL' || err.code === 'UNKNOWN') return fs.symlink(resolvedSrc, dest, cb)
            return cb(err)
          }
          if (opts.dereference) {
            resolvedDest = path.resolve(process.cwd(), resolvedDest)
          }
          if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
            return cb(new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`))
          }
  
          // do not copy if src is a subdir of dest since unlinking
          // dest in this case would result in removing src contents
          // and therefore a broken symlink would be created.
          if (destStat.isDirectory() && stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
            return cb(new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`))
          }
          return copyLink(resolvedSrc, dest, cb)
        })
      }
    })
  }
  
  function copyLink (resolvedSrc, dest, cb) {
    fs.unlink(dest, err => {
      if (err) return cb(err)
      return fs.symlink(resolvedSrc, dest, cb)
    })
  }
  
  module.exports = copy
  