import { DesktopWslStateSchema } from "@t3tools/contracts";
import { assert, describe, it } from "@effect/vitest";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import * as Schema from "effect/Schema";

import * as DesktopEnvironment from "../../app/DesktopEnvironment.ts";
import * as DesktopLifecycle from "../../app/DesktopLifecycle.ts";
import * as DesktopShutdown from "../../app/DesktopShutdown.ts";
import * as DesktopState from "../../app/DesktopState.ts";
import * as ElectronApp from "../../electron/ElectronApp.ts";
import * as ElectronDialog from "../../electron/ElectronDialog.ts";
import * as ElectronTheme from "../../electron/ElectronTheme.ts";
import * as ElectronWindow from "../../electron/ElectronWindow.ts";
import * as DesktopAppSettings from "../../settings/DesktopAppSettings.ts";
import * as DesktopClientSettings from "../../settings/DesktopClientSettings.ts";
import * as DesktopWindow from "../../window/DesktopWindow.ts";
import * as DesktopWslBackend from "../../wsl/DesktopWslBackend.ts";
import * as DesktopWslEnvironment from "../../wsl/DesktopWslEnvironment.ts";
import { setWslBackendEnabled, setWslDistro, setWslOnly } from "./wsl.ts";

const decodeWslState = Schema.decodeUnknownEffect(DesktopWslStateSchema);

const invokeSetWslBackendEnabled = (enabled: boolean) =>
  setWslBackendEnabled.handler(enabled).pipe(Effect.flatMap(decodeWslState));
const invokeSetWslDistro = (distro: string | null) =>
  setWslDistro.handler(distro).pipe(Effect.flatMap(decodeWslState));
const invokeSetWslOnly = (enabled: boolean) =>
  setWslOnly.handler(enabled).pipe(Effect.flatMap(decodeWslState));

function makeWslBackendLayer(input: { readonly onReconcile?: Effect.Effect<void> } = {}) {
  return Layer.succeed(
    DesktopWslBackend.DesktopWslBackend,
    DesktopWslBackend.DesktopWslBackend.of({
      reconcile: input.onReconcile ?? Effect.void,
      lastPreflightError: Effect.succeed(Option.none()),
    }),
  );
}

function makeLifecycleLayer(relaunchReasons: Array<string>) {
  return Layer.succeed(
    DesktopLifecycle.DesktopLifecycle,
    DesktopLifecycle.DesktopLifecycle.of({
      relaunch: (reason) =>
        Effect.sync(() => {
          relaunchReasons.push(reason);
        }),
      register: Effect.void,
    }),
  );
}

const unusedLifecycleRuntimeLayer = Layer.mergeAll(
  DesktopShutdown.layer,
  DesktopState.layer,
  Layer.succeed(
    DesktopEnvironment.DesktopEnvironment,
    DesktopEnvironment.DesktopEnvironment.of(
      {} as DesktopEnvironment.DesktopEnvironment["Service"],
    ),
  ),
  Layer.succeed(
    DesktopWindow.DesktopWindow,
    DesktopWindow.DesktopWindow.of({} as DesktopWindow.DesktopWindow["Service"]),
  ),
  Layer.succeed(
    ElectronApp.ElectronApp,
    ElectronApp.ElectronApp.of({} as ElectronApp.ElectronApp["Service"]),
  ),
  Layer.succeed(
    ElectronTheme.ElectronTheme,
    ElectronTheme.ElectronTheme.of({} as ElectronTheme.ElectronTheme["Service"]),
  ),
  Layer.succeed(
    ElectronDialog.ElectronDialog,
    ElectronDialog.ElectronDialog.of({} as ElectronDialog.ElectronDialog["Service"]),
  ),
  Layer.succeed(
    ElectronWindow.ElectronWindow,
    ElectronWindow.ElectronWindow.of({} as ElectronWindow.ElectronWindow["Service"]),
  ),
  DesktopClientSettings.layerTest(),
);

describe("WSL IPC", () => {
  it.effect("stages dual-backend preferences before enabling without relaunching", () => {
    const relaunchReasons: Array<string> = [];
    const layer = Layer.mergeAll(
      DesktopAppSettings.layerTest({
        ...DesktopAppSettings.DEFAULT_DESKTOP_SETTINGS,
        wslBackendEnabled: false,
        wslOnly: true,
      }),
      DesktopWslEnvironment.layerTest({ isAvailable: true }),
      makeWslBackendLayer(),
      makeLifecycleLayer(relaunchReasons),
      unusedLifecycleRuntimeLayer,
    );

    return Effect.gen(function* () {
      yield* invokeSetWslOnly(false);
      yield* invokeSetWslDistro("Debian");
      const state = yield* invokeSetWslBackendEnabled(true);

      assert.deepEqual(state, {
        enabled: true,
        distro: "Debian",
        available: true,
        wslOnly: false,
        distros: [],
        preflightError: null,
      });
      assert.deepEqual(relaunchReasons, []);
    }).pipe(Effect.provide(layer));
  });

  it.effect("stages WSL-only preferences and relaunches only after enabling", () => {
    const relaunchReasons: Array<string> = [];
    const layer = Layer.mergeAll(
      DesktopAppSettings.layerTest({
        ...DesktopAppSettings.DEFAULT_DESKTOP_SETTINGS,
        wslBackendEnabled: false,
        wslOnly: false,
      }),
      DesktopWslEnvironment.layerTest({ isAvailable: true }),
      makeWslBackendLayer(),
      makeLifecycleLayer(relaunchReasons),
      unusedLifecycleRuntimeLayer,
    );

    return Effect.gen(function* () {
      const stagedMode = yield* invokeSetWslOnly(true);
      assert.equal(stagedMode.enabled, false);
      assert.equal(stagedMode.wslOnly, true);
      assert.deepEqual(relaunchReasons, []);

      yield* invokeSetWslDistro("Debian");
      assert.deepEqual(relaunchReasons, []);

      const state = yield* invokeSetWslBackendEnabled(true);
      assert.deepEqual(state, {
        enabled: true,
        distro: "Debian",
        available: true,
        wslOnly: true,
        distros: [],
        preflightError: null,
      });
      assert.deepEqual(relaunchReasons, ["wslBackendEnabled=true"]);
    }).pipe(Effect.provide(layer));
  });

  it.effect("relaunches when enabling the WSL backend while wsl-only is already persisted", () => {
    const relaunchReasons: Array<string> = [];
    let reconcileCount = 0;
    const layer = Layer.mergeAll(
      DesktopAppSettings.layerTest({
        ...DesktopAppSettings.DEFAULT_DESKTOP_SETTINGS,
        wslBackendEnabled: false,
        wslOnly: true,
      }),
      DesktopWslEnvironment.layerTest({ isAvailable: true }),
      makeWslBackendLayer({
        onReconcile: Effect.sync(() => {
          reconcileCount += 1;
        }),
      }),
      makeLifecycleLayer(relaunchReasons),
      unusedLifecycleRuntimeLayer,
    );

    return Effect.gen(function* () {
      const state = yield* invokeSetWslBackendEnabled(true);

      assert.deepEqual(state, {
        enabled: true,
        distro: null,
        available: true,
        wslOnly: true,
        distros: [],
        preflightError: null,
      });
      assert.equal(reconcileCount, 0);
      assert.deepEqual(relaunchReasons, ["wslBackendEnabled=true"]);
    }).pipe(Effect.provide(layer));
  });

  it.effect("reconciles in dual-backend mode without relaunching", () => {
    const relaunchReasons: Array<string> = [];
    let reconcileCount = 0;
    const layer = Layer.mergeAll(
      DesktopAppSettings.layerTest({
        ...DesktopAppSettings.DEFAULT_DESKTOP_SETTINGS,
        wslBackendEnabled: false,
        wslOnly: false,
      }),
      DesktopWslEnvironment.layerTest({ isAvailable: true }),
      makeWslBackendLayer({
        onReconcile: Effect.sync(() => {
          reconcileCount += 1;
        }),
      }),
      makeLifecycleLayer(relaunchReasons),
      unusedLifecycleRuntimeLayer,
    );

    return Effect.gen(function* () {
      const state = yield* invokeSetWslBackendEnabled(true);

      assert.equal(state.enabled, true);
      assert.equal(state.wslOnly, false);
      assert.equal(reconcileCount, 1);
      assert.deepEqual(relaunchReasons, []);
    }).pipe(Effect.provide(layer));
  });

  it.effect("clears wsl-only before relaunching when disabling a WSL-only backend", () => {
    const relaunchReasons: Array<string> = [];
    let reconcileCount = 0;
    const layer = Layer.mergeAll(
      DesktopAppSettings.layerTest({
        ...DesktopAppSettings.DEFAULT_DESKTOP_SETTINGS,
        wslBackendEnabled: true,
        wslOnly: true,
      }),
      DesktopWslEnvironment.layerTest({ isAvailable: true }),
      makeWslBackendLayer({
        onReconcile: Effect.sync(() => {
          reconcileCount += 1;
        }),
      }),
      makeLifecycleLayer(relaunchReasons),
      unusedLifecycleRuntimeLayer,
    );

    return Effect.gen(function* () {
      const state = yield* invokeSetWslBackendEnabled(false);
      const appSettings = yield* DesktopAppSettings.DesktopAppSettings;
      const settings = yield* appSettings.get;

      assert.deepEqual(state, {
        enabled: false,
        distro: null,
        available: true,
        wslOnly: false,
        distros: [],
        preflightError: null,
      });
      assert.equal(settings.wslBackendEnabled, false);
      assert.equal(settings.wslOnly, false);
      assert.equal(reconcileCount, 0);
      assert.deepEqual(relaunchReasons, ["wslBackendEnabled=false"]);
    }).pipe(Effect.provide(layer));
  });

  it.effect("clears dual-backend WSL without relaunching", () => {
    const relaunchReasons: Array<string> = [];
    let reconcileCount = 0;
    const layer = Layer.mergeAll(
      DesktopAppSettings.layerTest({
        ...DesktopAppSettings.DEFAULT_DESKTOP_SETTINGS,
        wslBackendEnabled: true,
        wslOnly: false,
      }),
      DesktopWslEnvironment.layerTest({ isAvailable: true }),
      makeWslBackendLayer({
        onReconcile: Effect.sync(() => {
          reconcileCount += 1;
        }),
      }),
      makeLifecycleLayer(relaunchReasons),
      unusedLifecycleRuntimeLayer,
    );

    return Effect.gen(function* () {
      const state = yield* invokeSetWslBackendEnabled(false);

      assert.equal(state.enabled, false);
      assert.equal(state.wslOnly, false);
      assert.equal(reconcileCount, 1);
      assert.deepEqual(relaunchReasons, []);
    }).pipe(Effect.provide(layer));
  });
});