{
  defineModule, peek, Promise, dashCase, upperCamelCase,
  ErrorWithInfo, log, merge, present, find, each, w
  mergeInto
  currentSecond
  snakeCase,
  isString
} = require 'art-standard-lib'
Path = require 'path'

dirReader = require './DirReader'
{cacheable} = require './WorkingCache'

normalizeName = cacheable "normalizeName", upperCamelCase

realRequire = eval 'require'

{findSourceRootSync} = require './SourceRoots'
###
  2018-07-21 Optimization TODO:

  I think if we simplify the semantics such that matches are defined as:
    normalizeName(dirName) == normalizeName(moduleName)
  AND
    # this is the change:
    normalizeName(fileName.split(".")[0]) == normalizeName(moduleName)

  Then we can probably make much better use of caching:
    Read the dir in and create a map:
      normalizedName: name
    (where normalizedName here means for files, we strip the extensions)

  Then, we don't have to scan the dir every time!

  NOTE: I think if we have >= 2 files which map to the same noramlized name
  we encode that in the map somehow and can therefore raise the same
  exception we already do.
###
defineModule module, class ModuleResolver

  ###
    IN:
      moduleBaseName: the string before the first '/'
      modulePathArray: every other sub-string, split by '/'
        This is only used to determine if there is addutional pathing
        that must be resolved. It makes a difference what the
        require path looks like.
  ###
  @getNpmPackageName: (moduleBaseName, modulePathArray) ->
    if /^@/.test moduleBaseName
      [a, b] = moduleBaseName.split /\//
      try absolutePath =  Path.dirname realRequire.resolve name = "@#{dashCase a}/#{dashCase b}"
      try absolutePath ?= Path.dirname realRequire.resolve name = "@#{snakeCase a}/#{snakeCase b}"
    else
      try absolutePath =  Path.dirname realRequire.resolve name = dashCase moduleBaseName
      try absolutePath ?= Path.dirname realRequire.resolve name = snakeCase moduleBaseName

    try absolutePath ?= Path.dirname realRequire.resolve name = moduleBaseName
    catch
      throw new ErrorWithInfo "ModuleResolver: Could not find requested npm package: #{moduleBaseName}",
        npmPackageNamesAttempted: [moduleBaseName, dashCase moduleBaseName]

    if modulePathArray?.length > 0
      [requireString] = name.split '/'
      absolutePath = findSourceRootSync absolutePath
    else
      requireString = name
    {requireString, absolutePath}

  @findModuleSync: (moduleName, options) =>

    if /\//.test moduleName
      [base, modulePathArray...] = for mod in [denormalizedBase, denormalizedBase2] = moduleName.split "/"
        normalizeName mod

      if /^@/.test moduleName
        base = "@#{base}/#{modulePathArray[0]}"
        denormalizedBase = "#{denormalizedBase}/#{denormalizedBase2}"
        [_, modulePathArray...] = modulePathArray

    else denormalizedBase = moduleName

    {requireString, absolutePath} = @_findModuleBaseSync denormalizedBase, modulePathArray, options

    if modulePathArray
      for sub in modulePathArray
        if matchingName = @_matchingNameInDirectorySync sub, absolutePath, options
          absolutePath  = Path.join absolutePath, matchingName
          requireString = "#{requireString}/#{matchingName}"
        else
          throw new ErrorWithInfo "Could not find pathed submodule inside npm package: #{requireString}",
            npmPackage: requireString
            localNpmPackageLocation: absolutePath
            submodulePath: sub
            normalized: normalizeName sub
            dirItems: dirReader.read absolutePath

    {requireString, absolutePath}

  @findModule: (moduleName, options) =>
    Promise.then => @findModuleSync moduleName, options

  maybeCouldHaveCached = {}
  @_findModuleBaseSync: (moduleBaseName, modulePathArray, options) =>
    normalizedModuleName = upperCamelCase moduleBaseName

    {sourceFile, sourceDir, sourceFiles, sourceRoot} = options if options
    sourceFile ||= sourceFiles?[0]

    if sourceFile || sourceDir
      directory = sourceDir = dirReader.resolve sourceDir || Path.dirname sourceFile
      sourceRoot ||= findSourceRootSync sourceDir
      sourceRoot = sourceRoot && dirReader.resolve sourceRoot
      absoluteSourceFilePath = sourceFile && Path.join sourceDir, Path.parse(sourceFile).name

    absolutePath = null
    shouldContinue = present sourceRoot
    while shouldContinue
      if (matchingName = @_matchingNameInDirectorySync normalizedModuleName, directory, options) &&
          absoluteSourceFilePath != absolutePath = Path.join directory, matchingName
        shouldContinue = false

      else
        absolutePath = null
        if directory == sourceRoot
          if normalizedModuleName == normalizeName peek sourceRoot.split "/"
            absolutePath = sourceRoot
          shouldContinue = false

        else
          directory = Path.dirname directory

    if absolutePath
      requireString = Path.relative sourceDir, absolutePath
      switch requireString
        when "..", "." then requireString = "#{requireString}/"
      requireString = "./#{requireString}" unless requireString.match /^\./
      {requireString, absolutePath}
    else
      try
        @getNpmPackageName moduleBaseName, modulePathArray
      catch e
        if e.info
          mergeInto e.info, {sourceDir, sourceRoot}
        throw e

  ###
    Notes about "." names-with-dots.

      Essentially, dots are treated as word-boundaries.

      Files:
        We need to manage extensions. Current rule:
          Full match example: FooCaf matches foo.caf
          PartialMatch must fully match on dot-boundaries:
            Foo.BarFood.caf does NOT match FooBar, but does match FooBarFood
          PartialMatch must match starting at the first character:
            Foo.BarFood.caf does NOT match BarFood but does match Foo

      Dirs:
        Dirs must fully match:
          Art.Foo.Bar matches ArtFooBar BUT NOT ArtFoo

    Future:
      I'd like to be able to treat "."s in dir-names as-if they were '/' (slashes)
      Basically, this parallels how NeptuneNamespaces interprets them.
      It should work identically to as-if there were nested dirs.

      Given these files:

        MyFile1.caf
        Foo/Bar/MyFile2.caf

      OR these files:

        MyFile1.caf
        Foo.Bar/MyFile2.caf

      Then:
        # inside MyFile1.caf
        # this works:
        &Foo/Bar/MyFile2

    returns false or name, if it matches
  ###
  @getMatchingName: getMatchingName = (normalizedModuleName, name, isDir) ->

    if normalizedModuleName == normalizedTestName = normalizeName name
      name

    else unless isDir
      if 0 == normalizedTestName.indexOf normalizedModuleName
        foundLegalStop = false
        offset = 0

        for stop, i in stops = name.split '.'
          stop = normalizeName stop
          offset += stop.length
          if normalizedModuleName.length == offset
            return stops.slice(0, i + 1).join '.'

      false

  # PRIVATE
  @_matchingNameInDirectorySync: (normalizedModuleName, directory, options) ->
    matchingName = null
    unless isString directory
      throw new ErrorWithInfo "Directory must be a string"
    for name in dirReader.read directory
      if newMatchingName = getMatchingName normalizedModuleName, name, dirReader.isDir Path.join directory, name
        if matchingName && matchingName != newMatchingName
          throw new ErrorWithInfo """
            More than one matching module name with
            a) different actual base-names (#{matchingName} != #{newMatchingName}) and
            b) for the same normalized name (#{normalizedModuleName})
            """,
            directory:            directory
            firstMatch:           matchingName
            secondMatch:          newMatchingName
            normalizedModuleName: normalizedModuleName

        matchingName = newMatchingName
    matchingName