import { $ } from "bun";
import { Array, Console, Effect, Layer, ManagedRuntime, Option, Order, pipe, Schema, ServiceMap } from "effect";
import { UnknownError } from "effect/Cause";
import { readdir } from "node:fs/promises";

class PodmanError extends Schema.TaggedErrorClass<PodmanError>()("PodmanError", {
  cause: Schema.Error,
}) {}

class FileSystemError extends Schema.TaggedErrorClass<FileSystemError>()("FileSystemError", {
  cause: Schema.Error,
}) {}

class Podman extends ServiceMap.Service<
  Podman,
  {
    launchContainers(): Effect.Effect<string, PodmanError>;
    importLatestDbInWordPressContainer(exportPath: string): Effect.Effect<string, PodmanError>;
  }
>()("haikuatelier.fr/scripts/importe-dernier-export-bdd/Podman") {
  static readonly layer = Layer.effect(
    Podman,
    // oxlint-disable-next-line require-yield
    Effect.gen(function* () {
      const launchContainers = Effect.fn("launchContainers")(function* () {
        return yield* pipe(
          Effect.tryPromise(() => $`podman compose up -d &> /dev/null`),
          Effect.map((shell: $.ShellOutput) => shell.text()),
          Effect.mapError((error: UnknownError) => new PodmanError({ cause: error })),
        );
      });

      const importLatestDbInWordPressContainer = Effect.fn("importLatestDbInWordPressContainer")(function* (
        exportPath: string,
      ) {
        return yield* pipe(
          Effect.tryPromise(
            () =>
              $`podman exec -it haikuatelier.fr-wordpress fish -c "cd web && wp --allow-root db import ${exportPath} > /dev/null"`,
          ),
          Effect.map((shell: $.ShellOutput) => shell.text()),
          Effect.mapError((error: UnknownError) => new PodmanError({ cause: error })),
        );
      });

      return Podman.of({
        launchContainers,
        importLatestDbInWordPressContainer,
      });
    }),
  );
}

class FileSystem extends ServiceMap.Service<
  FileSystem,
  {
    getLatestDbExport(): Effect.Effect<string, FileSystemError>;
  }
>()("haikuatelier.fr/scripts/importe-dernier-export-bdd/FileSystem") {
  static readonly layer = Layer.effect(
    FileSystem,
    // oxlint-disable-next-line require-yield
    Effect.gen(function* () {
      const getLatestDbExport = Effect.fn("getLatestDbExport")(function* () {
        return yield* pipe(
          Effect.tryPromise(() => readdir(`./db`)),
          Effect.map((paths: ReadonlyArray<string>) => Array.sort(paths, Order.String)),
          Effect.map((sortedPaths: ReadonlyArray<string>) => Array.last(sortedPaths)),
          Effect.flatMap((path: Option.Option<string>) => Effect.fromOption(path)),
          Effect.mapError((_) => new FileSystemError({ cause: new Error("Aucun export de BDD n'est disponible.") })),
        );
      });

      return FileSystem.of({
        getLatestDbExport,
      });
    }),
  );
}

const mainLayer = Layer.mergeAll(Podman.layer, FileSystem.layer);
const runtime = ManagedRuntime.make(mainLayer);

const program = Effect.fn("program")(function* () {
  yield* Podman.use((podman) => podman.launchContainers());
  yield* Console.log("Containers are launched.");

  const latestExportPath: string = pipe(
    yield* FileSystem.use((fs) => fs.getLatestDbExport()),
    (path) => `../db/${path}`,
  );
  yield* Console.log(latestExportPath);

  yield* Podman.use((podman) => podman.importLatestDbInWordPressContainer(latestExportPath));
  yield* Console.log("Import done.");
});

runtime.runFork(program().pipe(Effect.tapError(Console.error)));