import type { AssertionError } from "Test"
import type { Wish } from "Wish"

import Directory from "./Directory"
import File from "./File"
import Process from "./Process"
import { always } from "Function"
import { ErrorWithMessage, assertEquals, test } from "Test"
import { bichain, good, mapRej } from "Wish"



TEST_ROOT :: String
TEST_ROOT = ".tests/prelude-directory-spec"

testRootFor :: String -> String
testRootFor = (name) => `${TEST_ROOT}/${name}`

runShell :: String -> Wish Process.CommandResult {}
runShell = (script) => map(
  always({}),
  Process.exec("sh", ["-c", script], Process.DEFAULT_COMMAND_OPTIONS),
)

expectSuccess :: String -> Wish e a -> Wish AssertionError a
expectSuccess = (message, wish) => mapRej(always(ErrorWithMessage(message)), wish)


test(
  "create - recursive creates missing parents",
  () => do {
    root = testRootFor("recursive")
    _ <- expectSuccess("failed to clean test directory", runShell(`rm -rf ${root}`))
    _ <- expectSuccess(
      "failed to create recursive directory",
      Directory.create(`${root}/nested/a/b`, { recursive: true }),
    )
    _ <- expectSuccess(
      "failed to write file in recursive directory",
      File.write(`${root}/nested/a/b/value.txt`, "ok"),
    )
    content <- expectSuccess(
      "failed to read file in recursive directory",
      File.read(`${root}/nested/a/b/value.txt`),
    )
    _ <- expectSuccess("failed to clean test directory", runShell(`rm -rf ${root}`))

    return assertEquals(content, "ok")
  },
)


test(
  "create - non recursive fails when parent is missing",
  () => do {
    root = testRootFor("non-recursive-missing-parent")
    _ <- expectSuccess("failed to clean test directory", runShell(`rm -rf ${root}`))

    failed <- bichain(
      always(good(true)),
      always(good(false)),
      Directory.create(`${root}/missing/leaf`, Directory.DEFAULT_CREATE_OPTIONS),
    )

    _ <- expectSuccess("failed to clean test directory", runShell(`rm -rf ${root}`))

    return assertEquals(failed, true)
  },
)


test(
  "create - idempotent when directory exists",
  () => do {
    root = testRootFor("idempotent")
    _ <- expectSuccess("failed to clean test directory", runShell(`rm -rf ${root}`))
    _ <- expectSuccess(
      "failed to create directory recursively",
      Directory.create(`${root}/idempotent`, { recursive: true }),
    )
    _ <- expectSuccess(
      "failed to create existing directory",
      Directory.create(`${root}/idempotent`, Directory.DEFAULT_CREATE_OPTIONS),
    )
    _ <- expectSuccess(
      "failed to write in idempotent directory",
      File.write(`${root}/idempotent/check.txt`, "idempotent"),
    )
    content <- expectSuccess(
      "failed to read from idempotent directory",
      File.read(`${root}/idempotent/check.txt`),
    )
    _ <- expectSuccess("failed to clean test directory", runShell(`rm -rf ${root}`))

    return assertEquals(content, "idempotent")
  },
)


test(
  "copy - recursive copies nested files and honors excludes",
  () => do {
    root = testRootFor("copy-recursive")
    _ <- expectSuccess("failed to clean test directory", runShell(`rm -rf ${root}`))
    _ <- expectSuccess("failed to create source directory", Directory.create(`${root}/source/nested`, { recursive: true }))
    _ <- expectSuccess("failed to create excluded directory", Directory.create(`${root}/source/node_modules`, { recursive: true }))
    _ <- expectSuccess("failed to write source file", File.write(`${root}/source/nested/value.txt`, "copied"))
    _ <- expectSuccess("failed to write excluded file", File.write(`${root}/source/node_modules/value.txt`, "excluded"))
    _ <- expectSuccess(
      "failed to copy directory",
      Directory.copy(
        `${root}/source`,
        `${root}/destination`,
        { recursive: true, overwrite: true, exclude: ["node_modules"] },
      ),
    )

    copied <- expectSuccess("failed to read copied file", File.read(`${root}/destination/nested/value.txt`))
    excludedMissing <- bichain(
      always(good(true)),
      always(good(false)),
      File.exists(`${root}/destination/node_modules/value.txt`),
    )
    _ <- expectSuccess("failed to clean test directory", Directory.remove(root, { recursive: true }))
    _ <- assertEquals(copied, "copied")
    return assertEquals(excludedMissing, true)
  },
)


test(
  "rename - moves a directory",
  () => do {
    root = testRootFor("rename")
    _ <- expectSuccess("failed to clean test directory", runShell(`rm -rf ${root}`))
    _ <- expectSuccess("failed to create source directory", Directory.create(`${root}/source`, { recursive: true }))
    _ <- expectSuccess("failed to write source file", File.write(`${root}/source/value.txt`, "renamed"))
    _ <- expectSuccess("failed to rename directory", Directory.rename(`${root}/source`, `${root}/renamed`))
    content <- expectSuccess("failed to read renamed file", File.read(`${root}/renamed/value.txt`))
    _ <- expectSuccess("failed to clean test directory", Directory.remove(root, { recursive: true }))
    return assertEquals(content, "renamed")
  },
)


test(
  "remove - recursive removes nested directories",
  () => do {
    root = testRootFor("remove-recursive")
    _ <- expectSuccess("failed to clean test directory", runShell(`rm -rf ${root}`))
    _ <- expectSuccess("failed to create nested directory", Directory.create(`${root}/nested`, { recursive: true }))
    _ <- expectSuccess("failed to write nested file", File.write(`${root}/nested/value.txt`, "removed"))
    _ <- expectSuccess("failed to remove directory", Directory.remove(root, { recursive: true }))
    missing <- bichain(
      always(good(true)),
      always(good(false)),
      File.exists(`${root}/nested/value.txt`),
    )
    return assertEquals(missing, true)
  },
)