import { z } from "zod/v4";

import {
  DirectoryMembershipRoleSchema,
  DirectoryMembershipValuesSchema,
} from "../api/domain/directory-membership-values";

import {
  DIRECTORY_MEMBERSHIP_DEFINITION,
  DIRECTORY_MEMBERSHIP_TYPE_ID,
} from "./directory-membership-definition";

export type { DirectoryMembershipRole } from "../api/domain/directory-membership-values";

export {
  DIRECTORY_MEMBERSHIP_DEFINITION,
  DIRECTORY_MEMBERSHIP_TYPE_ID,
  DirectoryMembershipRoleSchema,
};

export const DirectoryMembershipCommandSchema = z.discriminatedUnion("action", [
  z.strictObject({
    action: z.literal("join"),
    domainResourceId: z.uuid(),
    role: DirectoryMembershipRoleSchema,
  }),
  z.strictObject({
    action: z.literal("role"),
    membershipId: z.uuid(),
    role: DirectoryMembershipRoleSchema,
  }),
  z.strictObject({ action: z.literal("end"), membershipId: z.uuid() }),
  z.strictObject({
    action: z.literal("transfer"),
    membershipId: z.uuid(),
    domainResourceId: z.uuid(),
    role: DirectoryMembershipRoleSchema,
  }),
]);

export type DirectoryMembershipCommandDTO = z.infer<typeof DirectoryMembershipCommandSchema>;

export const DirectoryMembershipQuerySchema = z.strictObject({
  assetId: z.uuid().optional(),
  domainResourceId: z.uuid().optional(),
  role: DirectoryMembershipRoleSchema.optional(),
  includeEnded: z.enum(["true", "false"]).optional(),
  pageSize: z.coerce.number().int().min(1).max(100).optional(),
  cursor: z.uuid().optional(),
});

export type DirectoryMembershipQueryDTO = z.infer<typeof DirectoryMembershipQuerySchema>;

export const DirectoryMembershipSchema = z.strictObject({
  typeId: z.literal(DIRECTORY_MEMBERSHIP_DEFINITION.typeId),
  id: z.uuid(),
  companyId: z.uuid(),
  assetId: z.uuid(),
  domainResourceId: z.uuid(),
  predecessorId: z.uuid().nullable(),
  role: DirectoryMembershipRoleSchema,
  createdBy: z.uuid(),
  createdAt: z.iso.datetime(),
  endedAt: z.iso.datetime().nullable(),
  history: z
    .array(
      z.strictObject({
        id: z.uuid(),
        values: DirectoryMembershipValuesSchema,
        actorId: z.uuid(),
        recordedAt: z.iso.datetime(),
      })
    )
    .min(1),
});

export type DirectoryMembershipDTO = z.infer<typeof DirectoryMembershipSchema>;

export const DirectoryMembershipResponseSchema = z.strictObject({
  membership: DirectoryMembershipSchema,
});

export const CurrentDirectoryMembershipResponseSchema = z.strictObject({
  membership: DirectoryMembershipSchema.nullable(),
});

export const DirectoryMembershipPageSchema = z.strictObject({
  memberships: z.array(DirectoryMembershipSchema),
  nextCursor: z.uuid().nullable(),
});