import { homedir } from "node:os";
import { resolve } from "node:path";
import { FileSystem, Option, Path, Schema } from "effect";
import type { PlatformError } from "effect/PlatformError";
import * as Effect from "effect/Effect";

import {
  parseExecutorLocalServerManifest,
  serializeExecutorLocalServerManifest,
  type ExecutorLocalServerManifest,
} from "@executor-js/sdk/shared";
import { isPidAlive } from "./daemon-state";

export interface LocalServerStartLock {
  readonly path: string;
}

export const resolveExecutorDataDir = (path: Path.Path): string =>
  resolve(process.env.EXECUTOR_DATA_DIR ?? path.join(homedir(), ".executor"));

const serverControlDir = (path: Path.Path): string =>
  path.join(resolveExecutorDataDir(path), "server-control");

const localServerManifestPath = (path: Path.Path): string =>
  path.join(serverControlDir(path), "server.json");

const localServerStartLockPath = (path: Path.Path): string =>
  path.join(serverControlDir(path), "startup.lock");

export const readLocalServerManifest = (): Effect.Effect<
  ExecutorLocalServerManifest | null,
  never,
  FileSystem.FileSystem | Path.Path
> =>
  Effect.gen(function* () {
    const fs = yield* FileSystem.FileSystem;
    const path = yield* Path.Path;
    const raw = yield* fs
      .readFileString(localServerManifestPath(path))
      .pipe(Effect.catchCause(() => Effect.succeed(null)));
    if (raw === null) return null;
    return parseExecutorLocalServerManifest(raw);
  });

export const writeLocalServerManifest = (
  manifest: ExecutorLocalServerManifest,
): Effect.Effect<void, PlatformError, FileSystem.FileSystem | Path.Path> =>
  Effect.gen(function* () {
    const fs = yield* FileSystem.FileSystem;
    const path = yield* Path.Path;
    yield* fs.makeDirectory(serverControlDir(path), { recursive: true });
    const manifestPath = localServerManifestPath(path);
    // The manifest embeds the bearer token; create it owner-only so there's no
    // window where it exists world-readable (mode applies only on create). The
    // chmod after covers overwriting a pre-existing world-readable file, where
    // the create mode is ignored.
    yield* fs.writeFileString(manifestPath, serializeExecutorLocalServerManifest(manifest), {
      mode: 0o600,
    });
    yield* fs.chmod(manifestPath, 0o600).pipe(Effect.ignore);
  });

export const removeLocalServerManifestIfOwnedBy = (input: {
  readonly pid: number;
}): Effect.Effect<void, PlatformError, FileSystem.FileSystem | Path.Path> =>
  Effect.gen(function* () {
    const fs = yield* FileSystem.FileSystem;
    const path = yield* Path.Path;
    const manifestPath = localServerManifestPath(path);
    const raw = yield* fs
      .readFileString(manifestPath)
      .pipe(Effect.catchCause(() => Effect.succeed(null)));
    if (raw === null) return;
    const manifest = parseExecutorLocalServerManifest(raw);
    if (manifest?.pid !== input.pid) return;
    yield* fs.remove(manifestPath, { force: true });
  });

/**
 * Remove the server manifest unconditionally. Used by an OS-supervised daemon
 * to reclaim a stale `server.json` left by a previous boot: across a reboot the
 * recorded pid is meaningless (pids recycle, so it may now belong to an
 * unrelated process), and launchd/systemd already guarantee a single supervised
 * instance — so any pre-existing manifest is stale and the supervised daemon
 * owns it.
 */
export const removeLocalServerManifest = (): Effect.Effect<
  void,
  PlatformError,
  FileSystem.FileSystem | Path.Path
> =>
  Effect.gen(function* () {
    const fs = yield* FileSystem.FileSystem;
    const path = yield* Path.Path;
    yield* fs.remove(localServerManifestPath(path), { force: true });
  });

const StartupLockPayload = Schema.Struct({
  pid: Schema.Number,
});

const decodeStartupLockPayload = Schema.decodeUnknownOption(
  Schema.fromJsonString(StartupLockPayload),
);

const parseLockPid = (raw: string): number | null => {
  const decoded = decodeStartupLockPayload(raw);
  return Option.isSome(decoded) ? decoded.value.pid : null;
};

export const acquireLocalServerStartLock = (): Effect.Effect<
  LocalServerStartLock,
  Error,
  FileSystem.FileSystem | Path.Path
> =>
  Effect.gen(function* () {
    const fs = yield* FileSystem.FileSystem;
    const path = yield* Path.Path;
    yield* fs.makeDirectory(serverControlDir(path), { recursive: true });

    const lockPath = localServerStartLockPath(path);
    const lockPayload = `${JSON.stringify({ pid: process.pid, startedAt: new Date().toISOString() }, null, 2)}\n`;

    const tryAcquire = () =>
      fs.writeFileString(lockPath, lockPayload, { flag: "wx" }).pipe(
        Effect.as(true),
        Effect.catchCause(() => Effect.succeed(false)),
      );

    if (yield* tryAcquire()) return { path: lockPath };

    const existingRaw = yield* fs
      .readFileString(lockPath)
      .pipe(Effect.catchCause(() => Effect.succeed(null)));
    if (existingRaw !== null) {
      const existingPid = parseLockPid(existingRaw);
      if (existingPid !== null && !isPidAlive(existingPid)) {
        yield* fs.remove(lockPath, { force: true });
        if (yield* tryAcquire()) return { path: lockPath };
      }
    }

    return yield* Effect.fail(
      new Error("Another local Executor server startup is already in progress."),
    );
  });

export const releaseLocalServerStartLock = (
  lock: LocalServerStartLock,
): Effect.Effect<void, PlatformError, FileSystem.FileSystem | Path.Path> =>
  Effect.gen(function* () {
    const fs = yield* FileSystem.FileSystem;
    yield* fs.remove(lock.path, { force: true });
  });