schema.ts

import Mongoose, { Types } from 'mongoose';
import { z as zod, ZodTypeAny, ZodLazy, ZodObject, ZodArray } from 'zod';
import { AnyProcedure, inferProcedureOutput, AnyRouter, AnyTRPCClientTypes, TRPCRouterRecord } from '@trpc/server';

export type { inferRouterInputs } from '@trpc/server';

export const z = zod;

// @ts-ignore
export const ObjectId = z.union([
  z.instanceof(Types.ObjectId), // Accept Mongoose ObjectId instances
  z.string().refine((value) => Mongoose.isValidObjectId(value), {
    // Accept valid ObjectId strings
    message: 'Invalid ObjectId',
  }),
]);

export const Anything = z.any();
export const Nothing = z.object({});
export const Signature = z.object({ hash: z.string(), address: z.string() });
export const UnsignedData = z.object({ data: z.any() });
export const SignedData = z.object({
  data: z.any(),
  signature: Signature,
});

export const AnyInput = z.any();
export const OnlySignatureInput = z.object({ signature: Signature });
export const NoDataOutput = z.object({ status: z.number() });
export const AnyDataOutput = z.object({ data: z.any(), status: z.number() });

export enum Status {
  Paused = 'Paused',
  Pending = 'Pending',
  Active = 'Active',
  Archived = 'Archived',
}

export type Meta = {
  [key: string]: unknown;
};

export const Common = z.object({
  id: ObjectId.optional(),
  createdById: ObjectId.optional(),
  editedById: ObjectId.optional(),
  deletedById: ObjectId.optional(),
  createdDate: z.date().default(() => new Date()), // Default matches Mongoose
  updatedDate: z.date().optional(),
  deletedDate: z.date().optional(),
  meta: z.any(), // Default value set here matches Mongoose
  data: z.any(), // Default value set here matches Mongoose
  status: z.enum(['Paused', 'Pending', 'Active', 'Archived']).default('Active'), // Default set in StatusEnum matches Mongoose
});

export type Common = zod.infer<typeof Common>;

export const Entity = z
  .object({
    id: z.string().min(24).max(24).trim().optional(),
    key: z.string().min(1).max(200).trim().optional(),
    name: z.string().min(1).max(200).trim().optional(),
    description: z.string().optional(),
    applicationId: ObjectId.optional(),
    ownerId: ObjectId.optional(),
  })
  .merge(Common);

export type Entity = zod.infer<typeof Entity>;

const QueryFilterOperators = z.object({
  equals: z.any().optional(),
  not: z.any().optional(),
  in: z.array(z.any()).optional(),
  notIn: z.array(z.any()).optional(),
  lt: z.any().optional(),
  lte: z.any().optional(),
  gt: z.any().optional(),
  gte: z.any().optional(),
  contains: z.string().optional(),
  startsWith: z.string().optional(),
  endsWith: z.string().optional(),
  mode: z.enum(['default', 'insensitive']).optional(),
});

const QueryWhereSchema = z.lazy(() =>
  z.object({
    AND: z.array(QueryWhereSchema).optional(),
    OR: z.array(QueryWhereSchema).optional(),
    NOT: z.array(QueryWhereSchema).optional(),
    id: QueryFilterOperators.optional(),
    key: QueryFilterOperators.optional(),
    name: QueryFilterOperators.optional(),
    email: QueryFilterOperators.optional(),
    status: QueryFilterOperators.optional(),
  })
);

export const Query = z.object({
  skip: z.number().default(0).optional(),
  take: z.number().default(10).optional(),
  cursor: z.record(z.any()).optional(),
  where: QueryWhereSchema.optional(),
  orderBy: z.record(z.enum(['asc', 'desc'])).optional(),
  include: z.record(z.boolean()).optional(),
  select: z.record(z.boolean()).optional(),
});

// Operators for filtering in a Prisma-like way
type PrismaFilterOperators<T extends ZodTypeAny> = zod.ZodObject<
  {
    equals?: T;
    not?: T;
    in?: zod.ZodArray<T>;
    notIn?: zod.ZodArray<T>;
    lt?: T;
    lte?: T;
    gt?: T;
    gte?: T;
    contains?: zod.ZodString; // T extends zod.ZodString ? zod.ZodString : never;
    startsWith?: zod.ZodString; // T extends zod.ZodString ? zod.ZodString : never;
    endsWith?: zod.ZodString; // T extends zod.ZodString ? zod.ZodString : never;
    mode?: zod.ZodString; // T extends zod.ZodString ? zod.ZodEnum<['default', 'insensitive']> : never;
  },
  'strip',
  ZodTypeAny
>;

// Level 0: No AND, OR, NOT
type PrismaWhereLevel0<T extends zod.ZodRawShape> = ZodObject<
  {
    [K in keyof T]?: PrismaFilterOperators<T[K]>;
  },
  'strip',
  ZodTypeAny
>;

// Level 1: Includes AND, OR, NOT of Level 0
type PrismaWhereLevel1<T extends zod.ZodRawShape> = ZodObject<
  {
    AND?: ZodArray<ZodLazy<PrismaWhereLevel0<T>>>;
    OR?: ZodArray<ZodLazy<PrismaWhereLevel0<T>>>;
    NOT?: ZodArray<ZodLazy<PrismaWhereLevel0<T>>>;
  } & {
    [K in keyof T]?: PrismaFilterOperators<T[K]>;
  },
  'strip',
  ZodTypeAny
>;

// Level 2: Includes AND, OR, NOT of Level 1
type PrismaWhereLevel2<T extends zod.ZodRawShape> = ZodObject<
  {
    AND?: ZodArray<ZodLazy<PrismaWhereLevel1<T>>>;
    OR?: ZodArray<ZodLazy<PrismaWhereLevel1<T>>>;
    NOT?: ZodArray<ZodLazy<PrismaWhereLevel1<T>>>;
  } & {
    [K in keyof T]?: PrismaFilterOperators<T[K]>;
  },
  'strip',
  ZodTypeAny
>;

// Level 3: Includes AND, OR, NOT of Level 2
type PrismaWhereLevel3<T extends zod.ZodRawShape> = ZodObject<
  {
    AND?: ZodArray<ZodLazy<PrismaWhereLevel2<T>>>;
    OR?: ZodArray<ZodLazy<PrismaWhereLevel2<T>>>;
    NOT?: ZodArray<ZodLazy<PrismaWhereLevel2<T>>>;
  } & {
    [K in keyof T]?: PrismaFilterOperators<T[K]>;
  },
  'strip',
  ZodTypeAny
>;

// Level 4: Includes AND, OR, NOT of Level 3
type PrismaWhereLevel4<T extends zod.ZodRawShape> = ZodObject<
  {
    AND?: ZodArray<ZodLazy<PrismaWhereLevel3<T>>>;
    OR?: ZodArray<ZodLazy<PrismaWhereLevel3<T>>>;
    NOT?: ZodArray<ZodLazy<PrismaWhereLevel3<T>>>;
  } & {
    [K in keyof T]?: PrismaFilterOperators<T[K]>;
  },
  'strip',
  ZodTypeAny
>;

// Function to create a recursive schema up to level 4
export const createPrismaWhereSchema = <T extends zod.ZodRawShape>(
  modelSchema: zod.ZodObject<T>,
  depth: number = 3
): zod.ZodObject<any> => {
  const fields = modelSchema.shape;

  const fieldFilters = Object.fromEntries(
    Object.entries(fields).map(([key, value]) => [
      key,
      zod
        .object({
          equals: value.optional(),
          not: value.optional(),
          in: zod.array(value).optional(),
          notIn: zod.array(value).optional(),
          lt: value.optional(),
          lte: value.optional(),
          gt: value.optional(),
          gte: value.optional(),
          contains: zod.string().optional(),
          startsWith: zod.string().optional(),
          endsWith: zod.string().optional(),
          mode: zod.string().optional(),
        })
        .optional(),
    ])
  );

  if (depth <= 0) {
    // Base case: return schema without AND, OR, NOT to stop recursion
    return zod.object({
      ...fieldFilters,
    });
  }

  return zod.object({
    AND: zod.array(zod.lazy(() => createPrismaWhereSchema(modelSchema, depth - 1))).optional(),
    OR: zod.array(zod.lazy(() => createPrismaWhereSchema(modelSchema, depth - 1))).optional(),
    NOT: zod.array(zod.lazy(() => createPrismaWhereSchema(modelSchema, depth - 1))).optional(),
    ...fieldFilters,
  });
};

export const getQueryOutput = <T extends zod.ZodTypeAny>(data: T) => {
  return z.object({ status: z.number(), data: data.optional(), error: z.string().optional() });
};

export const getQueryInput = <T extends zod.ZodRawShape>(
  modelSchema: zod.ZodObject<T>,
  options: { partialData?: boolean } = {}
) => {
  const { partialData = true } = options;
  const whereSchema = createPrismaWhereSchema(modelSchema);

  const querySchema = z
    .object({
      data: partialData ? modelSchema.partial().optional() : modelSchema.optional(),
      skip: z.number().default(0).optional(),
      take: z.number().default(10).optional(),
      cursor: z.record(z.any()).optional(),
      where: whereSchema.optional(),
      orderBy: z.record(z.enum(['asc', 'desc'])).optional(),
      include: z.record(z.boolean()).optional(),
      select: z.record(z.boolean()).optional(),
    })
    .partial();

  // Merge querySchema and dataSchema, making all fields optional
  return zod.union([querySchema, zod.undefined()]);
  // return querySchema.merge(dataSchema).partial();
};

export type inferQuery<T extends zod.ZodRawShape> = zod.infer<ReturnType<typeof createPrismaWhereSchema<T>>>;

export type GetInferenceHelpers<
  TType extends 'input' | 'output',
  TRoot extends AnyTRPCClientTypes,
  TRecord extends TRPCRouterRecord
> = {
  [TKey in keyof TRecord]: TRecord[TKey] extends infer $Value
    ? $Value extends TRPCRouterRecord
      ? GetInferenceHelpers<TType, TRoot, $Value>
      : $Value extends AnyProcedure
      ? inferProcedureOutput<$Value> // inferTransformedProcedureOutput<TRoot, $Value>
      : never
    : never;
};

export type inferRouterOutputs<TRouter extends AnyRouter> = GetInferenceHelpers<
  'output',
  TRouter['_def']['_config']['$types'],
  TRouter['_def']['record']
>;

// type SpecificOutput = Router['_def']['record']['createInterfaceDraft']['_def']['$types']['output'];
// type TestOutput = RouterOutput['createInterfaceDraft'];