import * as Arr from "../Array.js"
import type * as Config from "../Config.js"
import type * as ConfigError from "../ConfigError.js"
import type * as ConfigProvider from "../ConfigProvider.js"
import type * as PathPatch from "../ConfigProviderPathPatch.js"
import * as Context from "../Context.js"
import type * as Effect from "../Effect.js"
import * as Either from "../Either.js"
import type { LazyArg } from "../Function.js"
import { dual, pipe } from "../Function.js"
import * as HashMap from "../HashMap.js"
import * as HashSet from "../HashSet.js"
import * as number from "../Number.js"
import * as Option from "../Option.js"
import { pipeArguments } from "../Pipeable.js"
import * as Predicate from "../Predicate.js"
import * as regexp from "../RegExp.js"
import type * as _config from "./config.js"
import * as configError from "./configError.js"
import * as pathPatch from "./configProvider/pathPatch.js"
import * as core from "./core.js"
import * as OpCodes from "./opCodes/config.js"
import * as StringUtils from "./string-utils.js"

type KeyComponent = ConfigProvider.ConfigProvider.KeyComponent

const concat = <A, B>(l: ReadonlyArray<A>, r: ReadonlyArray<B>): ReadonlyArray<A | B> => [...l, ...r]

/** @internal */
const ConfigProviderSymbolKey = "effect/ConfigProvider"

/** @internal */
export const ConfigProviderTypeId: ConfigProvider.ConfigProviderTypeId = Symbol.for(
  ConfigProviderSymbolKey
) as ConfigProvider.ConfigProviderTypeId

/** @internal */
export const configProviderTag: Context.Tag<ConfigProvider.ConfigProvider, ConfigProvider.ConfigProvider> = Context
  .GenericTag(
    "effect/ConfigProvider"
  )

/** @internal */
const FlatConfigProviderSymbolKey = "effect/ConfigProviderFlat"

/** @internal */
export const FlatConfigProviderTypeId: ConfigProvider.FlatConfigProviderTypeId = Symbol.for(
  FlatConfigProviderSymbolKey
) as ConfigProvider.FlatConfigProviderTypeId

/** @internal */
export const make = (
  options: {
    readonly load: <A>(config: Config.Config<A>) => Effect.Effect<A, ConfigError.ConfigError>
    readonly flattened: ConfigProvider.ConfigProvider.Flat
  }
): ConfigProvider.ConfigProvider => ({
  [ConfigProviderTypeId]: ConfigProviderTypeId,
  pipe() {
    return pipeArguments(this, arguments)
  },
  ...options
})

/** @internal */
export const makeFlat = (
  options: {
    readonly load: <A>(
      path: ReadonlyArray<string>,
      config: Config.Config.Primitive<A>,
      split: boolean
    ) => Effect.Effect<Array<A>, ConfigError.ConfigError>
    readonly enumerateChildren: (
      path: ReadonlyArray<string>
    ) => Effect.Effect<HashSet.HashSet<string>, ConfigError.ConfigError>
    readonly patch: PathPatch.PathPatch
  }
): ConfigProvider.ConfigProvider.Flat => ({
  [FlatConfigProviderTypeId]: FlatConfigProviderTypeId,
  patch: options.patch,
  load: (path, config, split = true) => options.load(path, config, split),
  enumerateChildren: options.enumerateChildren
})

/** @internal */
export const fromFlat = (flat: ConfigProvider.ConfigProvider.Flat): ConfigProvider.ConfigProvider =>
  make({
    load: (config) =>
      core.flatMap(fromFlatLoop(flat, Arr.empty(), config, false), (chunk) =>
        Option.match(Arr.head(chunk), {
          onNone: () =>
            core.fail(
              configError.MissingData(
                Arr.empty(),
                `Expected a single value having structure: ${config}`
              )
            ),
          onSome: core.succeed
        })),
    flattened: flat
  })

/** @internal */
export const fromEnv = (
  config?: Partial<ConfigProvider.ConfigProvider.FromEnvConfig>
): ConfigProvider.ConfigProvider => {
  const { pathDelim, seqDelim } = Object.assign({}, { pathDelim: "_", seqDelim: "," }, config)
  const makePathString = (path: ReadonlyArray<string>): string => pipe(path, Arr.join(pathDelim))
  const unmakePathString = (pathString: string): ReadonlyArray<string> => pathString.split(pathDelim)

  const getEnv = () =>
    typeof process !== "undefined" && "env" in process && typeof process.env === "object" ? process.env : {}

  const load = <A>(
    path: ReadonlyArray<string>,
    primitive: Config.Config.Primitive<A>,
    split = true
  ): Effect.Effect<Array<A>, ConfigError.ConfigError> => {
    const pathString = makePathString(path)
    const current = getEnv()
    const valueOpt = pathString in current ? Option.some(current[pathString]!) : Option.none()
    return pipe(
      valueOpt,
      core.mapError(() => configError.MissingData(path, `Expected ${pathString} to exist in the process context`)),
      core.flatMap((value) => parsePrimitive(value, path, primitive, seqDelim, split))
    )
  }

  const enumerateChildren = (
    path: ReadonlyArray<string>
  ): Effect.Effect<HashSet.HashSet<string>, ConfigError.ConfigError> =>
    core.sync(() => {
      const current = getEnv()
      const keys = Object.keys(current)
      const keyPaths = keys.map((value) => unmakePathString(value.toUpperCase()))
      const filteredKeyPaths = keyPaths.filter((keyPath) => {
        for (let i = 0; i < path.length; i++) {
          const pathComponent = pipe(path, Arr.unsafeGet(i))
          const currentElement = keyPath[i]
          if (currentElement === undefined || pathComponent !== currentElement) {
            return false
          }
        }
        return true
      }).flatMap((keyPath) => keyPath.slice(path.length, path.length + 1))
      return HashSet.fromIterable(filteredKeyPaths)
    })

  return fromFlat(makeFlat({ load, enumerateChildren, patch: pathPatch.empty }))
}

/** @internal */
export const fromMap = (
  map: Map<string, string>,
  config?: Partial<ConfigProvider.ConfigProvider.FromMapConfig>
): ConfigProvider.ConfigProvider => {
  const { pathDelim, seqDelim } = Object.assign({ seqDelim: ",", pathDelim: "." }, config)
  const makePathString = (path: ReadonlyArray<string>): string => pipe(path, Arr.join(pathDelim))
  const unmakePathString = (pathString: string): ReadonlyArray<string> => pathString.split(pathDelim)
  const mapWithIndexSplit = splitIndexInKeys(
    map,
    (str) => unmakePathString(str),
    makePathString
  )
  const load = <A>(
    path: ReadonlyArray<string>,
    primitive: Config.Config.Primitive<A>,
    split = true
  ): Effect.Effect<Array<A>, ConfigError.ConfigError> => {
    const pathString = makePathString(path)
    const valueOpt = mapWithIndexSplit.has(pathString) ?
      Option.some(mapWithIndexSplit.get(pathString)!) :
      Option.none()
    return pipe(
      valueOpt,
      core.mapError(() => configError.MissingData(path, `Expected ${pathString} to exist in the provided map`)),
      core.flatMap((value) => parsePrimitive(value, path, primitive, seqDelim, split))
    )
  }
  const enumerateChildren = (
    path: ReadonlyArray<string>
  ): Effect.Effect<HashSet.HashSet<string>, ConfigError.ConfigError> =>
    core.sync(() => {
      const keyPaths = Arr.fromIterable(mapWithIndexSplit.keys()).map(unmakePathString)
      const filteredKeyPaths = keyPaths.filter((keyPath) => {
        for (let i = 0; i < path.length; i++) {
          const pathComponent = pipe(path, Arr.unsafeGet(i))
          const currentElement = keyPath[i]
          if (currentElement === undefined || pathComponent !== currentElement) {
            return false
          }
        }
        return true
      }).flatMap((keyPath) => keyPath.slice(path.length, path.length + 1))
      return HashSet.fromIterable(filteredKeyPaths)
    })

  return fromFlat(makeFlat({ load, enumerateChildren, patch: pathPatch.empty }))
}

const extend = <A, B>(
  leftDef: (n: number) => A,
  rightDef: (n: number) => B,
  left: ReadonlyArray<A>,
  right: ReadonlyArray<B>
): [ReadonlyArray<A>, ReadonlyArray<B>] => {
  const leftPad = Arr.unfold(
    left.length,
    (index) =>
      index >= right.length ?
        Option.none() :
        Option.some([leftDef(index), index + 1])
  )
  const rightPad = Arr.unfold(
    right.length,
    (index) =>
      index >= left.length ?
        Option.none() :
        Option.some([rightDef(index), index + 1])
  )
  const leftExtension = concat(left, leftPad)
  const rightExtension = concat(right, rightPad)
  return [leftExtension, rightExtension]
}

const appendConfigPath = (path: ReadonlyArray<string>, config: Config.Config<unknown>): ReadonlyArray<string> => {
  let op = config as _config.ConfigPrimitive
  if (op._tag === "Nested") {
    const out = path.slice()
    while (op._tag === "Nested") {
      out.push(op.name)
      op = op.config as _config.ConfigPrimitive
    }
    return out
  }
  return path
}

const fromFlatLoop = <A>(
  flat: ConfigProvider.ConfigProvider.Flat,
  prefix: ReadonlyArray<string>,
  config: Config.Config<A>,
  split: boolean
): Effect.Effect<Array<A>, ConfigError.ConfigError> => {
  const op = config as _config.ConfigPrimitive
  switch (op._tag) {
    case OpCodes.OP_CONSTANT: {
      return core.succeed(Arr.of(op.value)) as Effect.Effect<Array<A>, ConfigError.ConfigError>
    }
    case OpCodes.OP_DESCRIBED: {
      return core.suspend(
        () => fromFlatLoop(flat, prefix, op.config, split)
      ) as unknown as Effect.Effect<Array<A>, ConfigError.ConfigError>
    }
    case OpCodes.OP_FAIL: {
      return core.fail(configError.MissingData(prefix, op.message)) as Effect.Effect<
        Array<A>,
        ConfigError.ConfigError
      >
    }
    case OpCodes.OP_FALLBACK: {
      return pipe(
        core.suspend(() => fromFlatLoop(flat, prefix, op.first, split)),
        core.catchAll((error1) => {
          if (op.condition(error1)) {
            return pipe(
              fromFlatLoop(flat, prefix, op.second, split),
              core.catchAll((error2) => core.fail(configError.Or(error1, error2)))
            )
          }
          return core.fail(error1)
        })
      ) as unknown as Effect.Effect<Array<A>, ConfigError.ConfigError>
    }
    case OpCodes.OP_LAZY: {
      return core.suspend(() => fromFlatLoop(flat, prefix, op.config(), split)) as Effect.Effect<
        Array<A>,
        ConfigError.ConfigError
      >
    }
    case OpCodes.OP_MAP_OR_FAIL: {
      return core.suspend(() =>
        pipe(
          fromFlatLoop(flat, prefix, op.original, split),
          core.flatMap(
            core.forEachSequential((a) =>
              pipe(
                op.mapOrFail(a),
                core.mapError(configError.prefixed(appendConfigPath(prefix, op.original)))
              )
            )
          )
        )
      ) as unknown as Effect.Effect<Array<A>, ConfigError.ConfigError>
    }
    case OpCodes.OP_NESTED: {
      return core.suspend(() =>
        fromFlatLoop(
          flat,
          concat(prefix, Arr.of(op.name)),
          op.config,
          split
        )
      ) as unknown as Effect.Effect<Array<A>, ConfigError.ConfigError>
    }
    case OpCodes.OP_PRIMITIVE: {
      return pipe(
        pathPatch.patch(prefix, flat.patch),
        core.flatMap((prefix) =>
          pipe(
            flat.load(prefix, op, split),
            core.flatMap((values) => {
              if (values.length === 0) {
                const name = pipe(Arr.last(prefix), Option.getOrElse(() => "<n/a>"))
                return core.fail(configError.MissingData([], `Expected ${op.description} with name ${name}`))
              }
              return core.succeed(values)
            })
          )
        )
      ) as unknown as Effect.Effect<Array<A>, ConfigError.ConfigError>
    }
    case OpCodes.OP_SEQUENCE: {
      return pipe(
        pathPatch.patch(prefix, flat.patch),
        core.flatMap((patchedPrefix) =>
          pipe(
            flat.enumerateChildren(patchedPrefix),
            core.flatMap(indicesFrom),
            core.flatMap((indices) => {
              if (indices.length === 0) {
                return core.suspend(() =>
                  core.map(fromFlatLoop(flat, prefix, op.config, true), Arr.of)
                ) as unknown as Effect.Effect<Array<A>, ConfigError.ConfigError>
              }
              return pipe(
                core.forEachSequential(
                  indices,
                  (index) => fromFlatLoop(flat, Arr.append(prefix, `[${index}]`), op.config, true)
                ),
                core.map((chunkChunk) => {
                  const flattened = Arr.flatten(chunkChunk)
                  if (flattened.length === 0) {
                    return Arr.of(Arr.empty<A>())
                  }
                  return Arr.of(flattened)
                })
              ) as unknown as Effect.Effect<Array<A>, ConfigError.ConfigError>
            })
          )
        )
      )
    }
    case OpCodes.OP_HASHMAP: {
      return core.suspend(() =>
        pipe(
          pathPatch.patch(prefix, flat.patch),
          core.flatMap((prefix) =>
            pipe(
              flat.enumerateChildren(prefix),
              core.flatMap((keys) => {
                return pipe(
                  keys,
                  core.forEachSequential((key) =>
                    fromFlatLoop(
                      flat,
                      concat(prefix, Arr.of(key)),
                      op.valueConfig,
                      split
                    )
                  ),
                  core.map((matrix) => {
                    if (matrix.length === 0) {
                      return Arr.of(HashMap.empty())
                    }
                    return pipe(
                      transpose(matrix),
                      Arr.map((values) => HashMap.fromIterable(Arr.zip(Arr.fromIterable(keys), values)))
                    )
                  })
                )
              })
            )
          )
        )
      ) as unknown as Effect.Effect<Array<A>, ConfigError.ConfigError>
    }
    case OpCodes.OP_ZIP_WITH: {
      return core.suspend(() =>
        pipe(
          fromFlatLoop(flat, prefix, op.left, split),
          core.either,
          core.flatMap((left) =>
            pipe(
              fromFlatLoop(flat, prefix, op.right, split),
              core.either,
              core.flatMap((right) => {
                if (Either.isLeft(left) && Either.isLeft(right)) {
                  return core.fail(configError.And(left.left, right.left))
                }
                if (Either.isLeft(left) && Either.isRight(right)) {
                  return core.fail(left.left)
                }
                if (Either.isRight(left) && Either.isLeft(right)) {
                  return core.fail(right.left)
                }
                if (Either.isRight(left) && Either.isRight(right)) {
                  const path = pipe(prefix, Arr.join("."))
                  const fail = fromFlatLoopFail(prefix, path)
                  const [lefts, rights] = extend(
                    fail,
                    fail,
                    pipe(left.right, Arr.map(Either.right)),
                    pipe(right.right, Arr.map(Either.right))
                  )
                  return pipe(
                    lefts,
                    Arr.zip(rights),
                    core.forEachSequential(([left, right]) =>
                      pipe(
                        core.zip(left, right),
                        core.map(([left, right]) => op.zip(left, right))
                      )
                    )
                  )
                }
                throw new Error(
                  "BUG: ConfigProvider.fromFlatLoop - please report an issue at https://github.com/Effect-TS/effect/issues"
                )
              })
            )
          )
        )
      ) as unknown as Effect.Effect<Array<A>, ConfigError.ConfigError>
    }
  }
}

const fromFlatLoopFail =
  (prefix: ReadonlyArray<string>, path: string) => (index: number): Either.Either<unknown, ConfigError.ConfigError> =>
    Either.left(
      configError.MissingData(
        prefix,
        `The element at index ${index} in a sequence at path "${path}" was missing`
      )
    )

/** @internal */
export const mapInputPath = dual<
  (f: (path: string) => string) => (self: ConfigProvider.ConfigProvider) => ConfigProvider.ConfigProvider,
  (self: ConfigProvider.ConfigProvider, f: (path: string) => string) => ConfigProvider.ConfigProvider
>(2, (self, f) => fromFlat(mapInputPathFlat(self.flattened, f)))

const mapInputPathFlat = (
  self: ConfigProvider.ConfigProvider.Flat,
  f: (path: string) => string
): ConfigProvider.ConfigProvider.Flat =>
  makeFlat({
    load: (path, config, split = true) => self.load(path, config, split),
    enumerateChildren: (path) => self.enumerateChildren(path),
    patch: pathPatch.mapName(self.patch, f)
  })

/** @internal */
export const nested = dual<
  (name: string) => (self: ConfigProvider.ConfigProvider) => ConfigProvider.ConfigProvider,
  (self: ConfigProvider.ConfigProvider, name: string) => ConfigProvider.ConfigProvider
>(2, (self, name) =>
  fromFlat(makeFlat({
    load: (path, config) => self.flattened.load(path, config, true),
    enumerateChildren: (path) => self.flattened.enumerateChildren(path),
    patch: pathPatch.nested(self.flattened.patch, name)
  })))

/** @internal */
export const unnested = dual<
  (name: string) => (self: ConfigProvider.ConfigProvider) => ConfigProvider.ConfigProvider,
  (self: ConfigProvider.ConfigProvider, name: string) => ConfigProvider.ConfigProvider
>(2, (self, name) =>
  fromFlat(makeFlat({
    load: (path, config) => self.flattened.load(path, config, true),
    enumerateChildren: (path) => self.flattened.enumerateChildren(path),
    patch: pathPatch.unnested(self.flattened.patch, name)
  })))

/** @internal */
export const orElse = dual<
  (
    that: LazyArg<ConfigProvider.ConfigProvider>
  ) => (
    self: ConfigProvider.ConfigProvider
  ) => ConfigProvider.ConfigProvider,
  (
    self: ConfigProvider.ConfigProvider,
    that: LazyArg<ConfigProvider.ConfigProvider>
  ) => ConfigProvider.ConfigProvider
>(2, (self, that) => fromFlat(orElseFlat(self.flattened, () => that().flattened)))

const orElseFlat = (
  self: ConfigProvider.ConfigProvider.Flat,
  that: LazyArg<ConfigProvider.ConfigProvider.Flat>
): ConfigProvider.ConfigProvider.Flat =>
  makeFlat({
    load: (path, config, split) =>
      pipe(
        pathPatch.patch(path, self.patch),
        core.flatMap((patch) => self.load(patch, config, split)),
        core.catchAll((error1) =>
          pipe(
            core.sync(that),
            core.flatMap((that) =>
              pipe(
                pathPatch.patch(path, that.patch),
                core.flatMap((patch) => that.load(patch, config, split)),
                core.catchAll((error2) => core.fail(configError.Or(error1, error2)))
              )
            )
          )
        )
      ),
    enumerateChildren: (path) =>
      pipe(
        pathPatch.patch(path, self.patch),
        core.flatMap((patch) => self.enumerateChildren(patch)),
        core.either,
        core.flatMap((left) =>
          pipe(
            core.sync(that),
            core.flatMap((that) =>
              pipe(
                pathPatch.patch(path, that.patch),
                core.flatMap((patch) => that.enumerateChildren(patch)),
                core.either,
                core.flatMap((right) => {
                  if (Either.isLeft(left) && Either.isLeft(right)) {
                    return core.fail(configError.And(left.left, right.left))
                  }
                  if (Either.isLeft(left) && Either.isRight(right)) {
                    return core.succeed(right.right)
                  }
                  if (Either.isRight(left) && Either.isLeft(right)) {
                    return core.succeed(left.right)
                  }
                  if (Either.isRight(left) && Either.isRight(right)) {
                    return core.succeed(pipe(left.right, HashSet.union(right.right)))
                  }
                  throw new Error(
                    "BUG: ConfigProvider.orElseFlat - please report an issue at https://github.com/Effect-TS/effect/issues"
                  )
                })
              )
            )
          )
        )
      ),
    patch: pathPatch.empty
  })

/** @internal */
export const constantCase = (self: ConfigProvider.ConfigProvider): ConfigProvider.ConfigProvider =>
  mapInputPath(self, StringUtils.constantCase)

/** @internal */
export const kebabCase = (self: ConfigProvider.ConfigProvider): ConfigProvider.ConfigProvider =>
  mapInputPath(self, StringUtils.kebabCase)

/** @internal */
export const lowerCase = (self: ConfigProvider.ConfigProvider): ConfigProvider.ConfigProvider =>
  mapInputPath(self, StringUtils.lowerCase)

/** @internal */
export const snakeCase = (self: ConfigProvider.ConfigProvider): ConfigProvider.ConfigProvider =>
  mapInputPath(self, StringUtils.snakeCase)

/** @internal */
export const upperCase = (self: ConfigProvider.ConfigProvider): ConfigProvider.ConfigProvider =>
  mapInputPath(self, StringUtils.upperCase)

/** @internal */
export const within = dual<
  (
    path: ReadonlyArray<string>,
    f: (self: ConfigProvider.ConfigProvider) => ConfigProvider.ConfigProvider
  ) => (self: ConfigProvider.ConfigProvider) => ConfigProvider.ConfigProvider,
  (
    self: ConfigProvider.ConfigProvider,
    path: ReadonlyArray<string>,
    f: (self: ConfigProvider.ConfigProvider) => ConfigProvider.ConfigProvider
  ) => ConfigProvider.ConfigProvider
>(3, (self, path, f) => {
  const unnest = Arr.reduce(path, self, (provider, name) => unnested(provider, name))
  const nest = Arr.reduceRight(path, f(unnest), (provider, name) => nested(provider, name))
  return orElse(nest, () => self)
})

const splitPathString = (text: string, delim: string): Array<string> => {
  const split = text.split(new RegExp(`\\s*${regexp.escape(delim)}\\s*`))
  return split
}

const parsePrimitive = <A>(
  text: string,
  path: ReadonlyArray<string>,
  primitive: Config.Config.Primitive<A>,
  delimiter: string,
  split: boolean
): Effect.Effect<Array<A>, ConfigError.ConfigError> => {
  if (!split) {
    return pipe(
      primitive.parse(text),
      core.mapBoth({
        onFailure: configError.prefixed(path),
        onSuccess: Arr.of
      })
    )
  }
  return pipe(
    splitPathString(text, delimiter),
    core.forEachSequential((char) => primitive.parse(char.trim())),
    core.mapError(configError.prefixed(path))
  )
}

const transpose = <A>(array: ReadonlyArray<ReadonlyArray<A>>): Array<Array<A>> => {
  return Object.keys(array[0]).map((column) => array.map((row) => row[column as any]))
}

const indicesFrom = (quotedIndices: HashSet.HashSet<string>): Effect.Effect<Array<number>> =>
  pipe(
    core.forEachSequential(quotedIndices, parseQuotedIndex),
    core.mapBoth({
      onFailure: () => Arr.empty<number>(),
      onSuccess: Arr.sort(number.Order)
    }),
    core.either,
    core.map(Either.merge)
  )

const STR_INDEX_REGEX = /(^.+)(\[(\d+)\])$/
const QUOTED_INDEX_REGEX = /^(\[(\d+)\])$/

const parseQuotedIndex = (str: string): Option.Option<number> => {
  const match = str.match(QUOTED_INDEX_REGEX)
  if (match !== null) {
    const matchedIndex = match[2]
    return pipe(
      matchedIndex !== undefined && matchedIndex.length > 0 ?
        Option.some(matchedIndex) :
        Option.none(),
      Option.flatMap(parseInteger)
    )
  }
  return Option.none()
}

const splitIndexInKeys = (
  map: Map<string, string>,
  unmakePathString: (str: string) => ReadonlyArray<string>,
  makePathString: (chunk: ReadonlyArray<string>) => string
): Map<string, string> => {
  const newMap: Map<string, string> = new Map()
  for (const [pathString, value] of map) {
    const keyWithIndex = pipe(
      unmakePathString(pathString),
      Arr.flatMap((key) =>
        Option.match(splitIndexFrom(key), {
          onNone: () => Arr.of(key),
          onSome: ([key, index]) => Arr.make(key, `[${index}]`)
        })
      )
    )
    newMap.set(makePathString(keyWithIndex), value)
  }
  return newMap
}

const splitIndexFrom = (key: string): Option.Option<[string, number]> => {
  const match = key.match(STR_INDEX_REGEX)
  if (match !== null) {
    const matchedString = match[1]
    const matchedIndex = match[3]
    const optionalString = matchedString !== undefined && matchedString.length > 0 ?
      Option.some(matchedString) :
      Option.none()
    const optionalIndex = pipe(
      matchedIndex !== undefined && matchedIndex.length > 0 ?
        Option.some(matchedIndex) :
        Option.none(),
      Option.flatMap(parseInteger)
    )
    return Option.all([optionalString, optionalIndex])
  }
  return Option.none()
}

const parseInteger = (str: string): Option.Option<number> => {
  const parsedIndex = Number.parseInt(str)
  return Number.isNaN(parsedIndex) ?
    Option.none() :
    Option.some(parsedIndex)
}

const keyName = (name: string): KeyComponent => ({
  _tag: "KeyName",
  name
})

const keyIndex = (index: number): KeyComponent => ({
  _tag: "KeyIndex",
  index
})

interface JsonMap {
  [member: string]: string | number | boolean | null | JsonArray | JsonMap
}
interface JsonArray extends Array<string | number | boolean | null | JsonArray | JsonMap> {}

/** @internal */
export const fromJson = (json: unknown): ConfigProvider.ConfigProvider => {
  const hiddenDelimiter = "\ufeff"
  const indexedEntries = Arr.map(
    getIndexedEntries(json as JsonMap),
    ([key, value]): [string, string] => [configPathToString(key).join(hiddenDelimiter), value]
  )
  return fromMap(new Map(indexedEntries), {
    pathDelim: hiddenDelimiter,
    seqDelim: hiddenDelimiter
  })
}

const configPathToString = (path: ReadonlyArray<KeyComponent>): ReadonlyArray<string> => {
  const output: Array<string> = []
  let i = 0
  while (i < path.length) {
    const component = path[i]
    if (component._tag === "KeyName") {
      if (i + 1 < path.length) {
        const nextComponent = path[i + 1]
        if (nextComponent._tag === "KeyIndex") {
          output.push(`${component.name}[${nextComponent.index}]`)
          i += 2
        } else {
          output.push(component.name)
          i += 1
        }
      } else {
        output.push(component.name)
        i += 1
      }
    }
  }
  return output
}

const getIndexedEntries = (
  config: JsonMap
): ReadonlyArray<[path: ReadonlyArray<KeyComponent>, value: string]> => {
  const loopAny = (
    path: ReadonlyArray<KeyComponent>,
    value: string | number | boolean | JsonMap | JsonArray | null
  ): ReadonlyArray<[path: ReadonlyArray<KeyComponent>, value: string]> => {
    if (typeof value === "string") {
      return Arr.make([path, value] as [ReadonlyArray<KeyComponent>, string])
    }
    if (typeof value === "number" || typeof value === "boolean") {
      return Arr.make([path, String(value)] as [ReadonlyArray<KeyComponent>, string])
    }
    if (Arr.isArray(value)) {
      return loopArray(path, value)
    }
    if (typeof value === "object" && value !== null) {
      return loopObject(path, value)
    }
    return Arr.empty<[ReadonlyArray<KeyComponent>, string]>()
  }
  const loopArray = (
    path: ReadonlyArray<KeyComponent>,
    values: JsonArray
  ): ReadonlyArray<[path: ReadonlyArray<KeyComponent>, value: string]> =>
    Arr.match(values, {
      onEmpty: () => Arr.make([path, "<nil>"] as [ReadonlyArray<KeyComponent>, string]),
      onNonEmpty: Arr.flatMap((value, index) => loopAny(Arr.append(path, keyIndex(index)), value))
    })
  const loopObject = (
    path: ReadonlyArray<KeyComponent>,
    value: JsonMap
  ): ReadonlyArray<[path: ReadonlyArray<KeyComponent>, value: string]> =>
    Object.entries(value)
      .filter(([, value]) => Predicate.isNotNullable(value))
      .flatMap(([key, value]) => {
        const newPath = Arr.append(path, keyName(key))
        const result = loopAny(newPath, value)
        if (Arr.isEmptyReadonlyArray(result)) {
          return Arr.make([newPath, ""] as [ReadonlyArray<KeyComponent>, string])
        }
        return result
      })
  return loopObject(Arr.empty(), config)
}