import type { RelayDeviceRegistrationRequest } from "@t3tools/contracts/relay";
import { describe, expect, it } from "@effect/vitest";
import type { SQL } from "drizzle-orm";
import { PgDialect } from "drizzle-orm/pg-core";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";

import * as RelayDb from "../db.ts";
import { relayLiveActivities, relayMobileDevices } from "../persistence/schema.ts";
import * as Devices from "./Devices.ts";

const registration: RelayDeviceRegistrationRequest = {
  deviceId: "device-1" as RelayDeviceRegistrationRequest["deviceId"],
  label: "Julius's iPhone",
  platform: "ios",
  iosMajorVersion: 18,
  appVersion: "1.0.0" as RelayDeviceRegistrationRequest["appVersion"],
  pushToken: "apns-device-token" as RelayDeviceRegistrationRequest["pushToken"],
  pushToStartToken: "push-to-start-token" as RelayDeviceRegistrationRequest["pushToStartToken"],
  preferences: {
    notificationsEnabled: true,
    liveActivitiesEnabled: true,
    notifyOnApproval: true,
    notifyOnInput: true,
    notifyOnCompletion: true,
    notifyOnFailure: true,
  },
};

describe("Devices", () => {
  it.effect("claims APNs tokens globally before upserting the current user device", () => {
    const calls: Array<string> = [];
    const updateSets: Array<Record<string, unknown>> = [];
    const updateConditions: Array<SQL> = [];
    const insertedValues: Array<Record<string, unknown>> = [];
    const dialect = new PgDialect();

    const fakeDb = {
      update: (table: unknown) => {
        expect(table).toBe(relayMobileDevices);
        calls.push("update");
        return {
          set: (values: Record<string, unknown>) => {
            updateSets.push(values);
            calls.push("update.set");
            return {
              where: (condition: SQL) => {
                expect(condition).toBeDefined();
                updateConditions.push(condition);
                calls.push("update.where");
                return Effect.void;
              },
            };
          },
        };
      },
      insert: (table: unknown) => {
        expect(table).toBe(relayMobileDevices);
        calls.push("insert");
        return {
          values: (values: Record<string, unknown>) => {
            insertedValues.push(values);
            calls.push("insert.values");
            return {
              onConflictDoUpdate: (config: unknown) => {
                expect(config).toBeDefined();
                calls.push("insert.onConflictDoUpdate");
                return Effect.void;
              },
            };
          },
        };
      },
    } as unknown as RelayDb.RelayDb["Service"];

    return Effect.gen(function* () {
      const devices = yield* Devices.Devices;
      yield* devices.register({ userId: "user-2", registration });

      expect(calls).toEqual([
        "update",
        "update.set",
        "update.where",
        "update",
        "update.set",
        "update.where",
        "insert",
        "insert.values",
        "insert.onConflictDoUpdate",
      ]);
      expect(updateSets).toEqual([
        expect.objectContaining({ pushToken: null }),
        expect.objectContaining({ pushToStartToken: null }),
      ]);
      expect(updateConditions.map((condition) => dialect.sqlToQuery(condition))).toEqual([
        {
          sql: '"relay_mobile_devices"."push_token" = $1',
          params: ["apns-device-token"],
        },
        {
          sql: '"relay_mobile_devices"."push_to_start_token" = $1',
          params: ["push-to-start-token"],
        },
      ]);
      expect(insertedValues).toEqual([
        expect.objectContaining({
          userId: "user-2",
          deviceId: "device-1",
          pushToken: "apns-device-token",
          pushToStartToken: "push-to-start-token",
        }),
      ]);
    }).pipe(
      Effect.provide(Devices.layer.pipe(Layer.provide(Layer.succeed(RelayDb.RelayDb, fakeDb)))),
    );
  });

  it.effect("unregisters APNs state only for the current user device", () => {
    const calls: Array<string> = [];
    const deleteConditions: Array<SQL> = [];
    const dialect = new PgDialect();

    const fakeDb = {
      delete: (table: unknown) => {
        calls.push(table === relayLiveActivities ? "delete.liveActivities" : "delete.devices");
        return {
          where: (condition: SQL) => {
            expect(condition).toBeDefined();
            deleteConditions.push(condition);
            calls.push("delete.where");
            return Effect.void;
          },
        };
      },
    } as unknown as RelayDb.RelayDb["Service"];

    return Effect.gen(function* () {
      const devices = yield* Devices.Devices;
      yield* devices.unregister({ userId: "user-2", deviceId: "device-1" });

      expect(calls).toEqual([
        "delete.liveActivities",
        "delete.where",
        "delete.devices",
        "delete.where",
      ]);
      expect(deleteConditions.map((condition) => dialect.sqlToQuery(condition))).toEqual([
        {
          sql:
            '(("relay_live_activities"."user_id" = $1) and ' +
            '("relay_live_activities"."device_id" = $2))',
          params: ["user-2", "device-1"],
        },
        {
          sql:
            '(("relay_mobile_devices"."user_id" = $1) and ' +
            '("relay_mobile_devices"."device_id" = $2))',
          params: ["user-2", "device-1"],
        },
      ]);
    }).pipe(
      Effect.provide(Devices.layer.pipe(Layer.provide(Layer.succeed(RelayDb.RelayDb, fakeDb)))),
    );
  });

  it.effect("lists safe notification state without exposing APNs tokens", () => {
    const dialect = new PgDialect();
    let condition: SQL | null = null;
    const fakeDb = {
      select: () => ({
        from: (table: unknown) => {
          expect(table).toBe(relayMobileDevices);
          return {
            where: (nextCondition: SQL) => {
              condition = nextCondition;
              return Effect.succeed([
                {
                  deviceId: "device-1",
                  label: "Julius's iPhone",
                  platform: "ios" as const,
                  iosMajorVersion: 18,
                  appVersion: "1.0.0",
                  preferences: registration.preferences,
                  updatedAt: "2026-06-01T00:00:00.000Z",
                },
              ]);
            },
          };
        },
      }),
    } as unknown as RelayDb.RelayDb["Service"];

    return Effect.gen(function* () {
      const devices = yield* Devices.Devices;
      const listed = yield* devices.listForUser({ userId: "user-2" });

      expect(condition).not.toBeNull();
      expect(dialect.sqlToQuery(condition!)).toEqual({
        sql: '"relay_mobile_devices"."user_id" = $1',
        params: ["user-2"],
      });
      expect(listed).toEqual([
        {
          deviceId: "device-1",
          label: "Julius's iPhone",
          platform: "ios",
          iosMajorVersion: 18,
          appVersion: "1.0.0",
          notifications: {
            enabled: true,
            notifyOnApproval: true,
            notifyOnInput: true,
            notifyOnCompletion: true,
            notifyOnFailure: true,
          },
          liveActivities: {
            enabled: true,
          },
          updatedAt: "2026-06-01T00:00:00.000Z",
        },
      ]);
    }).pipe(
      Effect.provide(Devices.layer.pipe(Layer.provide(Layer.succeed(RelayDb.RelayDb, fakeDb)))),
    );
  });

  it.effect("identifies the failed device registration stage", () => {
    const cause = new Error("push-token claim failed");
    const fakeDb = {
      update: () => ({
        set: (values: Record<string, unknown>) => ({
          where: () => ("pushToken" in values ? Effect.fail(cause) : Effect.void),
        }),
      }),
    } as unknown as RelayDb.RelayDb["Service"];

    return Effect.gen(function* () {
      const devices = yield* Devices.Devices;
      const error = yield* devices.register({ userId: "user-2", registration }).pipe(Effect.flip);

      expect(error).toMatchObject({
        userId: "user-2",
        deviceId: "device-1",
        stage: "claim-push-token",
      });
      expect(error.cause).toBe(cause);
      expect(error.message).toBe(
        "Failed to persist mobile device registration for user-2/device-1 during claim-push-token.",
      );
    }).pipe(
      Effect.provide(Devices.layer.pipe(Layer.provide(Layer.succeed(RelayDb.RelayDb, fakeDb)))),
    );
  });

  it.effect("identifies the failed device unregistration stage", () => {
    const cause = new Error("live activity delete failed");
    const fakeDb = {
      delete: (table: unknown) => ({
        where: () => (table === relayLiveActivities ? Effect.fail(cause) : Effect.void),
      }),
    } as unknown as RelayDb.RelayDb["Service"];

    return Effect.gen(function* () {
      const devices = yield* Devices.Devices;
      const error = yield* devices
        .unregister({ userId: "user-2", deviceId: "device-1" })
        .pipe(Effect.flip);

      expect(error).toMatchObject({
        userId: "user-2",
        deviceId: "device-1",
        stage: "delete-live-activity",
      });
      expect(error.cause).toBe(cause);
      expect(error.message).toBe(
        "Failed to unregister mobile device user-2/device-1 during delete-live-activity.",
      );
    }).pipe(
      Effect.provide(Devices.layer.pipe(Layer.provide(Layer.succeed(RelayDb.RelayDb, fakeDb)))),
    );
  });

  it.effect("attaches the user to device list failures", () => {
    const cause = new Error("device list failed");
    const fakeDb = {
      select: () => ({
        from: () => ({
          where: () => Effect.fail(cause),
        }),
      }),
    } as unknown as RelayDb.RelayDb["Service"];

    return Effect.gen(function* () {
      const devices = yield* Devices.Devices;
      const error = yield* devices.listForUser({ userId: "user-2" }).pipe(Effect.flip);

      expect(error).toMatchObject({ userId: "user-2" });
      expect(error.cause).toBe(cause);
      expect(error.message).toBe("Failed to list mobile devices for user-2.");
    }).pipe(
      Effect.provide(Devices.layer.pipe(Layer.provide(Layer.succeed(RelayDb.RelayDb, fakeDb)))),
    );
  });
});