import { describe, expect, it } from "bun:test";
import { AccessPolicy, ExtendedPatch, ServerComputed, Static, Type } from "..";
import {
  applyServerComputedMetadata,
  enforceMultiplayerPolicies,
  filterStateForReadAccess,
} from "../multiplayerPolicies";

describe("filterStateForReadAccess", () => {
  const now = 0;

  it("removes nested fields that are not readable", () => {
    const schema = Type.Object({
      profile: Type.Object({
        name: Type.String(),
        secret: AccessPolicy(
          Type.Object({
            value: Type.String(),
            ownerId: Type.String(),
          }),
          {
            allow: {
              read: "auth.id != null && data != null && data.ownerId == auth.id",
            },
          }
        ),
      }),
    });

    type State = Static<typeof schema>;

    const state: State = {
      profile: {
        name: "Alice",
        secret: { value: "classified", ownerId: "user-1" },
      },
    };

    const ownerView = filterStateForReadAccess<State>({
      schema,
      state,
      auth: { id: "user-1" },
      now,
    });

    expect(ownerView).toEqual(state);

    const blockedView = filterStateForReadAccess<State>({
      schema,
      state,
      auth: { id: "user-2" },
      now,
    });

    expect(blockedView).toEqual({
      profile: {
        name: "Alice",
      },
    } as State);
  });

  it("returns undefined when the root object is unreadable", () => {
    const schema = AccessPolicy(
      Type.Object({
        title: Type.String(),
        ownerId: Type.String(),
      }),
      {
        allow: {
          read: "auth.id != null && data != null && data.ownerId == auth.id",
        },
      }
    );

    type State = Static<typeof schema>;

    const state: State = {
      title: "Secret",
      ownerId: "user-1",
    };

    const filtered = filterStateForReadAccess<State>({
      schema,
      state,
      auth: { id: "user-2" },
      now,
    });

    expect(filtered).toBeUndefined();
  });

  it("evaluates chained let bindings referenced by allow expressions", () => {
    const schema = Type.Object({
      record: AccessPolicy(
        Type.Object({
          id: Type.String(),
          ownerId: Type.String(),
          title: Type.String(),
        }),
        {
          let: [
            [
              "isOwner",
              "auth.id != null && data != null && data.ownerId == auth.id",
            ],
            ["canEdit", "isOwner && data != null"],
            ["finalRule", "canEdit"],
          ],
          allow: {
            update: "finalRule",
          },
        }
      ),
    });

    type State = Static<typeof schema>;

    const previous: State = {
      record: { id: "1", ownerId: "user-1", title: "Original" },
    };
    const next: State = {
      record: { id: "1", ownerId: "user-1", title: "Updated" },
    };

    const patch: ExtendedPatch = {
      op: "replace",
      path: ["record", "title"],
      value: "Updated",
    };

    const allowed = enforceMultiplayerPolicies({
      schema,
      patches: [patch],
      previousState: previous,
      nextState: next,
      auth: { id: "user-1" },
      now,
    });

    expect(allowed).toBeUndefined();

    const violation = enforceMultiplayerPolicies({
      schema,
      patches: [patch],
      previousState: previous,
      nextState: next,
      auth: { id: "intruder" },
      now,
    });

    expect(violation?.action).toEqual("update");
  });

  it("returns violation with error message when allow expression throws", () => {
    const schema = AccessPolicy(
      Type.Object({
        value: Type.Number(),
      }),
      {
        allow: {
          update: "1 / 0 == 0",
        },
      }
    );

    type State = Static<typeof schema>;

    const previous: State = { value: 1 };
    const next: State = { value: 2 };
    const patch: ExtendedPatch = {
      op: "replace",
      path: ["value"],
      value: 2,
    };

    const violation = enforceMultiplayerPolicies({
      schema,
      patches: [patch],
      previousState: previous,
      nextState: next,
      auth: { id: "user-1" },
      now,
    });

    expect(violation?.action).toEqual("update");
    expect(violation?.message).toBeTruthy();
  });

  it("uses random helpers inside ServerComputed expressions", () => {
    const schema = Type.Object({
      roll: ServerComputed(Type.Number(), {
        compute:
          "random() < 0.5 ? double(randomInt(10, 10)) : double(randomInt(20, 20))",
        events: ["create", "update"],
        targets: ["value"],
      }),
    });

    const createPatch = (): ExtendedPatch => ({
      op: "add",
      path: ["roll"],
      value: 0,
    });

    const originalRandom = Math.random;

    try {
      Math.random = () => 0.25;
      const lowPatch = createPatch();
      applyServerComputedMetadata({
        schema,
        patches: [lowPatch],
        now,
      });
      expect(lowPatch.value).toEqual(10);

      Math.random = (): number => 0.75;
      const highPatch = createPatch();
      applyServerComputedMetadata({
        schema,
        patches: [highPatch],
        now,
      });
      expect(highPatch.value).toEqual(20);
    } finally {
      Math.random = originalRandom;
    }
  });

  it("evaluates now() helper using the provided timestamp", () => {
    const schema = Type.Object({
      timestamp: ServerComputed(Type.Number(), {
        compute: "now()",
        events: ["create", "update"],
        targets: ["value"],
      }),
    });

    const patch: ExtendedPatch = {
      op: "add",
      path: ["timestamp"],
      value: 0,
    };

    const nowValue = 1_725_000_000_000;

    applyServerComputedMetadata({
      schema,
      patches: [patch],
      now: nowValue,
    });

    expect(patch.value).toEqual(nowValue);
  });

  it("exposes uuid() helper for server-computed fields", () => {
    const schema = Type.Object({
      id: ServerComputed(Type.String(), {
        compute: "uuid()",
        events: ["create", "update"],
        targets: ["value"],
      }),
    });

    const patch: ExtendedPatch = {
      op: "add",
      path: ["id"],
      value: "",
    };

    applyServerComputedMetadata({
      schema,
      patches: [patch],
      now,
    });

    expect(typeof patch.value).toEqual("string");
    expect(patch.value.length).toBeGreaterThan(0);
  });

  it("exposes timestamp() helper returning ISO strings", () => {
    const schema = Type.Object({
      createdAt: ServerComputed(Type.String(), {
        compute: "timestamp()",
        events: ["create", "update"],
        targets: ["value"],
      }),
    });

    const patch: ExtendedPatch = {
      op: "add",
      path: ["createdAt"],
      value: "",
    };

    const nowValue = 1_725_000_000_000;

    applyServerComputedMetadata({
      schema,
      patches: [patch],
      now: nowValue,
    });

    expect(patch.value).toEqual(new Date(nowValue).toISOString());
  });

});