import { z } from 'zod';

import { FieldType, ReadStatus, SendStatus, SigningStatus } from '@documenso/prisma/client';

/**
 * Documents
 */
export const ZGetDocumentsQuerySchema = z.object({
  page: z.string().optional(),
  perPage: z.string().optional(),
});

export type TGetDocumentsQuerySchema = z.infer<typeof ZGetDocumentsQuerySchema>;

export const ZDeleteDocumentMutationSchema = null;

export type TDeleteDocumentMutationSchema = typeof ZDeleteDocumentMutationSchema;

export const ZSuccessfulDocumentResponseSchema = z.object({
  id: z.number(),
  userId: z.number(),
  title: z.string(),
  status: z.string(),
  documentDataId: z.string(),
  createdAt: z.date(),
  updatedAt: z.date(),
  completedAt: z.date().nullable(),
});

export type TSuccessfulDocumentResponseSchema = z.infer<typeof ZSuccessfulDocumentResponseSchema>;

export const ZSendDocumentForSigningMutationSchema = null;

export type TSendDocumentForSigningMutationSchema = typeof ZSendDocumentForSigningMutationSchema;

export const ZUploadDocumentSuccessfulSchema = z.object({
  url: z.string(),
  key: z.string(),
});

export type TUploadDocumentSuccessfulSchema = z.infer<typeof ZUploadDocumentSuccessfulSchema>;

export const ZCreateDocumentMutationSchema = z.object({
  fileName: z.string(),
  contentType: z.string().default('PDF'),
});

export type TCreateDocumentMutationSchema = z.infer<typeof ZCreateDocumentMutationSchema>;

export const ZCreateRecipientMutationSchema = z.object({
  name: z.string().min(1),
  email: z.string().email().min(1),
});

/**
 * Recipients
 */
export type TCreateRecipientMutationSchema = z.infer<typeof ZCreateRecipientMutationSchema>;

export const ZUpdateRecipientMutationSchema = ZCreateRecipientMutationSchema.partial();

export type TUpdateRecipientMutationSchema = z.infer<typeof ZUpdateRecipientMutationSchema>;

export const ZDeleteRecipientMutationSchema = null;

export type TDeleteRecipientMutationSchema = typeof ZDeleteRecipientMutationSchema;

export const ZSuccessfulRecipientResponseSchema = z.object({
  id: z.number(),
  documentId: z.number(),
  email: z.string().email().min(1),
  name: z.string(),
  token: z.string(),
  // !: Not used for now
  // expired: z.string(),
  signedAt: z.date().nullable(),
  readStatus: z.nativeEnum(ReadStatus),
  signingStatus: z.nativeEnum(SigningStatus),
  sendStatus: z.nativeEnum(SendStatus),
});

export type TSuccessfulRecipientResponseSchema = z.infer<typeof ZSuccessfulRecipientResponseSchema>;

/**
 * Fields
 */
export const ZCreateFieldMutationSchema = z.object({
  recipientId: z.number(),
  type: z.nativeEnum(FieldType),
  pageNumber: z.number(),
  pageX: z.number(),
  pageY: z.number(),
  pageWidth: z.number(),
  pageHeight: z.number(),
});

export type TCreateFieldMutationSchema = z.infer<typeof ZCreateFieldMutationSchema>;

export const ZUpdateFieldMutationSchema = ZCreateFieldMutationSchema.partial();

export type TUpdateFieldMutationSchema = z.infer<typeof ZUpdateFieldMutationSchema>;

export const ZDeleteFieldMutationSchema = null;

export type TDeleteFieldMutationSchema = typeof ZDeleteFieldMutationSchema;

export const ZSuccessfulFieldResponseSchema = z.object({
  documentId: z.number(),
  recipientId: z.number(),
  type: z.nativeEnum(FieldType),
  pageNumber: z.number(),
  pageX: z.number(),
  pageY: z.number(),
  pageWidth: z.number(),
  pageHeight: z.number(),
  customText: z.string(),
  inserted: z.boolean(),
});

export type TSuccessfulFieldResponseSchema = z.infer<typeof ZSuccessfulFieldResponseSchema>;

export const ZSuccessfulResponseSchema = z.object({
  documents: ZSuccessfulDocumentResponseSchema.array(),
  totalPages: z.number(),
});

export type TSuccessfulResponseSchema = z.infer<typeof ZSuccessfulResponseSchema>;

export const ZSuccessfulSigningResponseSchema = z.object({
  message: z.string(),
});

export type TSuccessfulSigningResponseSchema = z.infer<typeof ZSuccessfulSigningResponseSchema>;

/**
 * General
 */
export const ZAuthorizationHeadersSchema = z.object({
  authorization: z.string(),
});

export type TAuthorizationHeadersSchema = z.infer<typeof ZAuthorizationHeadersSchema>;

export const ZUnsuccessfulResponseSchema = z.object({
  message: z.string(),
});

export type TUnsuccessfulResponseSchema = z.infer<typeof ZUnsuccessfulResponseSchema>;