import * as NodeServices from "@effect/platform-node/NodeServices";
import { assert, describe, it } from "@effect/vitest";
import * as Effect from "effect/Effect";
import * as FileSystem from "effect/FileSystem";
import * as Layer from "effect/Layer";
import * as Path from "effect/Path";
import * as PlatformError from "effect/PlatformError";
import * as Ref from "effect/Ref";
import * as Scope from "effect/Scope";

import * as DesktopConfig from "../app/DesktopConfig.ts";
import * as DesktopEnvironment from "../app/DesktopEnvironment.ts";
import * as DesktopWslServerTree from "./DesktopWslServerTree.ts";

// The service reads packaged Windows roots through the (asar-aware, in
// Electron) fs, so a plain directory named server.asar exercises the full
// extraction path under plain Node.

const environmentLayer = (input: {
  readonly baseDir: string;
  readonly resourcesPath: string;
  readonly appVersion?: string;
  readonly isPackaged?: boolean;
}) =>
  DesktopEnvironment.layer({
    dirname: "/repo/apps/desktop/src",
    homeDirectory: input.baseDir,
    platform: "win32",
    processArch: "x64",
    appVersion: input.appVersion ?? "1.2.3",
    appPath: "/repo",
    isPackaged: input.isPackaged ?? true,
    resourcesPath: input.resourcesPath,
    runningUnderArm64Translation: false,
  }).pipe(
    Layer.provide(
      Layer.mergeAll(
        NodeServices.layer,
        DesktopConfig.layerTest({
          T3CODE_HOME: input.baseDir,
          T3CODE_MODE: "desktop",
        }),
      ),
    ),
  );

const withTempDir = <A, E, R>(
  run: (tempDir: string) => Effect.Effect<A, E, R>,
): Effect.Effect<
  A,
  E | PlatformError.PlatformError,
  FileSystem.FileSystem | Exclude<R, Scope.Scope>
> =>
  Effect.gen(function* () {
    const fileSystem = yield* FileSystem.FileSystem;
    const tempDir = yield* fileSystem.makeTempDirectoryScoped({
      prefix: "t3-wsl-server-tree-test-",
    });
    return yield* run(tempDir);
  }).pipe(Effect.scoped);

const ensureWith = (input: {
  readonly baseDir: string;
  readonly resourcesPath: string;
  readonly appVersion?: string;
  readonly isPackaged?: boolean;
}) =>
  Effect.gen(function* () {
    const tree = yield* DesktopWslServerTree.DesktopWslServerTree;
    return yield* tree.ensure;
  }).pipe(
    Effect.provide(DesktopWslServerTree.layer.pipe(Layer.provideMerge(environmentLayer(input)))),
  );

describe("DesktopWslServerTree", () => {
  it.effect("bounds entry work across an eight-way nested tree", () =>
    Effect.gen(function* () {
      const active = yield* Ref.make(0);
      const maxActive = yield* Ref.make(0);
      const visited = yield* Ref.make(0);

      yield* DesktopWslServerTree.forEachBoundedTree([{ depth: 0, id: "root" }], (node) =>
        Effect.acquireUseRelease(
          Effect.gen(function* () {
            const current = yield* Ref.updateAndGet(active, (count) => count + 1);
            yield* Ref.update(maxActive, (maximum) => Math.max(maximum, current));
            yield* Ref.update(visited, (count) => count + 1);
          }),
          () =>
            Effect.gen(function* () {
              // Give every task in the current batch a chance to overlap.
              yield* Effect.yieldNow;
              if (node.depth === 4) return [];
              return Array.from({ length: 8 }, (_, index) => ({
                depth: node.depth + 1,
                id: `${node.id}.${String(index)}`,
              }));
            }),
          () => Ref.update(active, (count) => count - 1),
        ),
      );

      assert.equal(yield* Ref.get(active), 0);
      assert.equal(yield* Ref.get(maxActive), 8);
      assert.equal(yield* Ref.get(visited), 4_681);
    }),
  );

  it.effect("returns the server root unchanged when it is a plain directory (dev)", () =>
    withTempDir((tempDir) =>
      Effect.gen(function* () {
        const result = yield* ensureWith({
          baseDir: tempDir,
          resourcesPath: tempDir,
          isPackaged: false,
        });
        assert.isTrue(result.ok);
        assert.isFalse(result.ok && result.root.endsWith(".asar"));
      }),
    ).pipe(Effect.provide(NodeServices.layer)),
  );

  it.effect("extracts an archive root into a version-keyed state directory", () =>
    withTempDir((tempDir) =>
      Effect.gen(function* () {
        const fileSystem = yield* FileSystem.FileSystem;
        const path = yield* Path.Path;
        const serverRoot = path.join(tempDir, "resources", "server.asar");
        yield* fileSystem.makeDirectory(path.join(serverRoot, "apps/server/dist"), {
          recursive: true,
        });
        yield* fileSystem.writeFileString(
          path.join(serverRoot, "apps/server/dist/bin.mjs"),
          "server-entry",
        );
        yield* fileSystem.makeDirectory(path.join(serverRoot, "node_modules/effect"), {
          recursive: true,
        });
        yield* fileSystem.writeFileString(
          path.join(serverRoot, "node_modules/effect/package.json"),
          "{}",
        );

        const result = yield* ensureWith({
          baseDir: tempDir,
          resourcesPath: path.join(tempDir, "resources"),
        });

        assert.isTrue(result.ok);
        const root = result.ok ? result.root : "";
        assert.include(root, path.join("wsl-server-tree", "1.2.3"));
        const entry = yield* fileSystem.readFileString(path.join(root, "apps/server/dist/bin.mjs"));
        assert.equal(entry, "server-entry");
        const dep = yield* fileSystem.exists(path.join(root, "node_modules/effect/package.json"));
        assert.isTrue(dep);
        const marker = yield* fileSystem.readFileString(
          path.join(root, "t3code-wsl-server-tree.json"),
        );
        assert.include(marker, '"version":"1.2.3"');
      }),
    ).pipe(Effect.provide(NodeServices.layer)),
  );

  it.effect("serializes concurrent extraction callers and publishes one complete tree", () =>
    withTempDir((tempDir) =>
      Effect.gen(function* () {
        const fileSystem = yield* FileSystem.FileSystem;
        const path = yield* Path.Path;
        const resourcesPath = path.join(tempDir, "resources");
        const serverRoot = path.join(resourcesPath, "server.asar");
        yield* fileSystem.makeDirectory(path.join(serverRoot, "apps/server/dist"), {
          recursive: true,
        });
        yield* fileSystem.writeFileString(
          path.join(serverRoot, "apps/server/dist/bin.mjs"),
          "server-entry",
        );

        const results = yield* Effect.gen(function* () {
          const tree = yield* DesktopWslServerTree.DesktopWslServerTree;
          return yield* Effect.all([tree.ensure, tree.ensure], { concurrency: "unbounded" });
        }).pipe(
          Effect.provide(
            DesktopWslServerTree.layer.pipe(
              Layer.provideMerge(environmentLayer({ baseDir: tempDir, resourcesPath })),
            ),
          ),
        );

        assert.isTrue(results.every((result) => result.ok));
        const roots = results.flatMap((result) => (result.ok ? [result.root] : []));
        assert.lengthOf(new Set(roots), 1);
        assert.equal(
          yield* fileSystem.readFileString(path.join(roots[0] ?? "", "apps/server/dist/bin.mjs")),
          "server-entry",
        );
      }),
    ).pipe(Effect.provide(NodeServices.layer)),
  );

  it.effect("reuses a completed extraction instead of copying again", () =>
    withTempDir((tempDir) =>
      Effect.gen(function* () {
        const fileSystem = yield* FileSystem.FileSystem;
        const path = yield* Path.Path;
        const serverRoot = path.join(tempDir, "resources", "server.asar");
        yield* fileSystem.makeDirectory(path.join(serverRoot, "apps/server/dist"), {
          recursive: true,
        });
        yield* fileSystem.writeFileString(path.join(serverRoot, "apps/server/dist/bin.mjs"), "v1");

        const first = yield* ensureWith({
          baseDir: tempDir,
          resourcesPath: path.join(tempDir, "resources"),
        });
        assert.isTrue(first.ok);

        // Mutate the source; a reused tree must keep the first copy.
        yield* fileSystem.writeFileString(
          path.join(serverRoot, "apps/server/dist/bin.mjs"),
          "v2-should-not-appear",
        );
        const second = yield* ensureWith({
          baseDir: tempDir,
          resourcesPath: path.join(tempDir, "resources"),
        });
        assert.isTrue(second.ok);
        const root = second.ok ? second.root : "";
        const entry = yield* fileSystem.readFileString(path.join(root, "apps/server/dist/bin.mjs"));
        assert.equal(entry, "v1");
      }),
    ).pipe(Effect.provide(NodeServices.layer)),
  );

  it.effect("sweeps stale version directories and leftover partials after extraction", () =>
    withTempDir((tempDir) =>
      Effect.gen(function* () {
        const fileSystem = yield* FileSystem.FileSystem;
        const path = yield* Path.Path;
        const serverRoot = path.join(tempDir, "resources", "server.asar");
        yield* fileSystem.makeDirectory(path.join(serverRoot, "apps/server/dist"), {
          recursive: true,
        });
        yield* fileSystem.writeFileString(path.join(serverRoot, "apps/server/dist/bin.mjs"), "x");

        // T3CODE_HOME is set to tempDir, so the desktop state dir resolves to
        // <tempDir>/userdata (no .t3 segment).
        const treeRoot = path.join(tempDir, "userdata", "wsl-server-tree");
        yield* fileSystem.makeDirectory(path.join(treeRoot, "1.0.0"), { recursive: true });
        yield* fileSystem.makeDirectory(path.join(treeRoot, "1.2.3.partial"), { recursive: true });

        const result = yield* ensureWith({
          baseDir: tempDir,
          resourcesPath: path.join(tempDir, "resources"),
        });
        assert.isTrue(result.ok);
        assert.isFalse(yield* fileSystem.exists(path.join(treeRoot, "1.0.0")));
        assert.isFalse(yield* fileSystem.exists(path.join(treeRoot, "1.2.3.partial")));
        assert.isTrue(yield* fileSystem.exists(path.join(treeRoot, "1.2.3")));
      }),
    ).pipe(Effect.provide(NodeServices.layer)),
  );

  it.effect("re-extracts when the app version changes", () =>
    withTempDir((tempDir) =>
      Effect.gen(function* () {
        const fileSystem = yield* FileSystem.FileSystem;
        const path = yield* Path.Path;
        const serverRoot = path.join(tempDir, "resources", "server.asar");
        yield* fileSystem.makeDirectory(path.join(serverRoot, "apps/server/dist"), {
          recursive: true,
        });
        yield* fileSystem.writeFileString(path.join(serverRoot, "apps/server/dist/bin.mjs"), "old");

        const first = yield* ensureWith({
          baseDir: tempDir,
          resourcesPath: path.join(tempDir, "resources"),
          appVersion: "1.2.3",
        });
        assert.isTrue(first.ok);

        yield* fileSystem.writeFileString(path.join(serverRoot, "apps/server/dist/bin.mjs"), "new");
        const second = yield* ensureWith({
          baseDir: tempDir,
          resourcesPath: path.join(tempDir, "resources"),
          appVersion: "1.2.4",
        });
        assert.isTrue(second.ok);
        const root = second.ok ? second.root : "";
        assert.include(root, "1.2.4");
        const entry = yield* fileSystem.readFileString(path.join(root, "apps/server/dist/bin.mjs"));
        assert.equal(entry, "new");
        // The previous version's tree is gone.
        const treeRoot = path.dirname(root);
        assert.isFalse(yield* fileSystem.exists(path.join(treeRoot, "1.2.3")));
      }),
    ).pipe(Effect.provide(NodeServices.layer)),
  );

  it.effect("removes the legacy Windows extraction tree without preparing a fallback", () =>
    withTempDir((tempDir) =>
      Effect.gen(function* () {
        const fileSystem = yield* FileSystem.FileSystem;
        const path = yield* Path.Path;
        const resourcesPath = path.join(tempDir, "resources");
        const treeRoot = path.join(tempDir, "userdata", "wsl-server-tree");
        yield* fileSystem.makeDirectory(path.join(treeRoot, "1.2.3"), { recursive: true });
        yield* fileSystem.writeFileString(path.join(treeRoot, "1.2.3", "legacy"), "old");

        yield* Effect.gen(function* () {
          const tree = yield* DesktopWslServerTree.DesktopWslServerTree;
          yield* tree.cleanupLegacy;
        }).pipe(
          Effect.provide(
            DesktopWslServerTree.layer.pipe(
              Layer.provideMerge(environmentLayer({ baseDir: tempDir, resourcesPath })),
            ),
          ),
        );

        assert.isFalse(yield* fileSystem.exists(treeRoot));
      }),
    ).pipe(Effect.provide(NodeServices.layer)),
  );

  it.effect("re-extracts after legacy cleanup partially deletes the completed tree", () =>
    withTempDir((tempDir) =>
      Effect.gen(function* () {
        const fileSystem = yield* FileSystem.FileSystem;
        const path = yield* Path.Path;
        const resourcesPath = path.join(tempDir, "resources");
        const serverRoot = path.join(resourcesPath, "server.asar");
        const sourceEntryPath = path.join(serverRoot, "apps/server/dist/bin.mjs");
        yield* fileSystem.makeDirectory(path.dirname(sourceEntryPath), { recursive: true });
        yield* fileSystem.writeFileString(sourceEntryPath, "fresh-server-entry");

        const initial = yield* ensureWith({ baseDir: tempDir, resourcesPath });
        assert.isTrue(initial.ok);
        const versionDir = initial.ok ? initial.root : "";
        const treeRoot = path.dirname(versionDir);
        const extractedEntryPath = path.join(versionDir, "apps/server/dist/bin.mjs");
        let cleanupFailed = false;
        const partialCleanupFileSystem = Layer.effect(
          FileSystem.FileSystem,
          Effect.gen(function* () {
            const realFileSystem = yield* FileSystem.FileSystem;
            return {
              ...realFileSystem,
              remove: (target, options) =>
                String(target) === treeRoot && options?.recursive === true && !cleanupFailed
                  ? Effect.gen(function* () {
                      cleanupFailed = true;
                      yield* realFileSystem.remove(extractedEntryPath);
                      return yield* PlatformError.systemError({
                        _tag: "PermissionDenied",
                        module: "FileSystem",
                        method: "remove",
                        pathOrDescriptor: treeRoot,
                        description: "simulated partial legacy cleanup",
                      });
                    })
                  : realFileSystem.remove(target, options),
            } satisfies FileSystem.FileSystem;
          }),
        ).pipe(Layer.provide(NodeServices.layer));

        const result = yield* Effect.gen(function* () {
          const tree = yield* DesktopWslServerTree.DesktopWslServerTree;
          yield* tree.cleanupLegacy;
          return yield* tree.ensure;
        }).pipe(
          Effect.provide(
            DesktopWslServerTree.layer.pipe(
              Layer.provideMerge(environmentLayer({ baseDir: tempDir, resourcesPath })),
              Layer.provideMerge(partialCleanupFileSystem),
            ),
          ),
        );

        assert.isTrue(cleanupFailed);
        assert.isTrue(result.ok);
        assert.equal(yield* fileSystem.readFileString(extractedEntryPath), "fresh-server-entry");
      }),
    ).pipe(Effect.provide(NodeServices.layer)),
  );

  it.effect("reports a retryable failure when the archive cannot be read", () =>
    withTempDir((tempDir) =>
      Effect.gen(function* () {
        const fileSystem = yield* FileSystem.FileSystem;
        const path = yield* Path.Path;
        const result = yield* ensureWith({
          baseDir: tempDir,
          // resources dir exists but server.asar does not
          resourcesPath: path.join(tempDir, "resources"),
        });
        assert.isFalse(result.ok);
        if (!result.ok) {
          assert.include(result.reason, "could not be extracted");
          assert.isFalse(result.fatal);
        }
        const treeRoot = path.join(tempDir, "userdata", "wsl-server-tree");
        const leftovers = yield* fileSystem
          .readDirectory(treeRoot)
          .pipe(Effect.orElseSucceed(() => []));
        assert.deepStrictEqual(leftovers, []);
      }),
    ).pipe(Effect.provide(NodeServices.layer)),
  );
});