import {z} from 'zod'

export type ContentStatus = 'New' | 'Assigned' | 'Replied' | 'UserReply' | 'UserInitiated' | 'Ignored';

export type ContentStatuses = Array<ContentStatus>;

export type SocMsgCreationTimeOrder = '-creationTime' | '+creationTime' | 'creationTime';

export type GetApiCxSocialMessagingV1ContentsArgs = {intervention?: Array<string> | undefined, identity?: Array<string> | undefined, identityGroup?: Array<string> | undefined, source?: Array<string> | undefined, thread?: Array<string> | undefined, text?: Array<string> | undefined, status?: ContentStatuses | undefined, orderBy?: SocMsgCreationTimeOrder | undefined, pageToken?: string | undefined, perPage?: number | undefined};

export type GetApiCxSocialMessagingV1ContentsOptions = {baseUrl?: string | undefined, OAuth2?: string | undefined, fetch?: typeof fetch | undefined};

export const contentAttachment = z.object({contentType: z.string().optional(), creationTime: z.string().optional(), embedded: z.boolean().optional(), filename: z.string().optional(), id: z.string().optional(), public: z.boolean().optional(), size: z.number().int().optional(), lastModifiedTime: z.string().optional(), uri: z.string().optional()});

export const contentAttachments = z.array(contentAttachment);

export const contentAuthorIdentityId = z.string();

export const contentAutoSubmittedField = z.boolean();

export const contentBody = z.string();

export const contentBodyFormatted = z.object({html: z.string().optional(), text: z.string().optional()});

export const contentBodyInputFormat = z.enum(["Text", "Html"]);

export const contentCategoryIds = z.array(z.string());

export const contentContextData = z.record(z.string(), z.string());

export const socMsgCreationTime = z.string();

export const contentCreatedFrom = z.enum(["Synchronizer", "Interface", "Api", "AutoSurvey", "AutoResponseTrigger", "AutoRequestEmail"]);

export const contentCreatorId = z.string();

export const contentForeignCategories = z.array(z.string());

export const contentId = z.string();

export const contentInReplyToAuthorIdentityId = z.string();

export const contentInReplyToContentId = z.string();

export const contentInterventionId = z.string();

export const contentLanguage = z.string();

export const contentPublic = z.boolean();

export const contentPublished = z.boolean();

export const contentRating = z.number().int();

export const contentRemotelyDeleted = z.boolean();

export const contentSourceId = z.string();

export const contentSourceType = z.enum(["AppleMessagesForBusiness", "Email", "EngageMessaging", "Facebook", "GoogleBusinessMessages", "GoogleMyBusiness", "Instagram", "InstagramMessaging", "Linkedin", "Messenger", "Twitter", "Viber", "WhatsApp", "Youtube"]);

export const contentSourceUri = z.string();

export const contentStatus = z.enum(["New", "Assigned", "Replied", "UserReply", "UserInitiated", "Ignored"]);

export const contentSynchronizationStatus = z.string();

export const contentSynchronizationError = z.string();

export const contentThreadId = z.string();

export const contentTitle = z.string();

export const contentType = z.enum(["Album", "AuthenticateMessage", "AuthenticateResponse", "Carousel", "CarouselMessage", "Comment", "ContactMessage", "Content", "Email", "FormMessage", "FormResponse", "HsmMessage", "Link", "ListMessage", "Media", "Message", "OutboundMessage", "PaymentMessage", "Photo", "PostbackMessage", "PrivateTweet", "PromptMessage", "Question", "Review", "ReviewResponse", "RichLinkMessage", "SelectMessage", "Status", "TemplateMessage", "TimePickerMessage", "Tweet", "Video", "VideoCallRequestMessage"]);

export const socMsgLastModifiedTime = z.string();

export const contentCapabilitiesSupported = z.array(z.string());

export const contentModel = z.object({attachments: contentAttachments, authorIdentityId: contentAuthorIdentityId, autoSubmitted: contentAutoSubmittedField, body: contentBody, bodyFormatted: contentBodyFormatted, bodyInputFormat: contentBodyInputFormat, categoryIds: contentCategoryIds, contextData: contentContextData.optional(), creationTime: socMsgCreationTime, createdFrom: contentCreatedFrom, creatorId: contentCreatorId, foreignCategories: contentForeignCategories.optional(), id: contentId, inReplyToAuthorIdentityId: contentInReplyToAuthorIdentityId, inReplyToContentId: contentInReplyToContentId, interventionId: contentInterventionId, language: contentLanguage, public: contentPublic, published: contentPublished, rating: contentRating, remotelyDeleted: contentRemotelyDeleted, sourceId: contentSourceId, sourceType: contentSourceType, sourceUri: contentSourceUri, status: contentStatus, synchronizationStatus: contentSynchronizationStatus, synchronizationError: contentSynchronizationError, threadId: contentThreadId, title: contentTitle, type: contentType, lastModifiedTime: socMsgLastModifiedTime, capabilitiesSupported: contentCapabilitiesSupported});

export const nonEnumeratedPagingModel = z.object({perPage: z.number().int().gte(1).lte(1000), pageToken: z.string().optional(), nextPageToken: z.string().optional(), previousPageToken: z.string().optional(), firstPageToken: z.string().optional()});

export const contentList = z.object({records: z.array(contentModel), paging: nonEnumeratedPagingModel});

export const validateResponse = async <Output>(
  schema: {
    readonly '~standard': {
      readonly validate: (value: unknown) => ({ readonly value: Output; readonly issues?: undefined } | { readonly issues: ReadonlyArray<{ readonly message: string; readonly path?: ReadonlyArray<PropertyKey | { readonly key: PropertyKey }> | undefined }> }) | Promise<{ readonly value: Output; readonly issues?: undefined } | { readonly issues: ReadonlyArray<{ readonly message: string; readonly path?: ReadonlyArray<PropertyKey | { readonly key: PropertyKey }> | undefined }> }>
    }
  },
  value: unknown
): Promise<Output> => {
  const result = await schema['~standard'].validate(value)

  if (result.issues !== undefined) {
    const detail = result.issues
      .map(({ message, path }) =>
        path?.length
          ? `${path.map((segment) => String(typeof segment === 'object' ? segment.key : segment)).join('.')}: ${message}`
          : message
      )
      .join('; ')

    throw new Error(`Response does not match the schema: ${detail}`, { cause: { issues: result.issues } })
  }

  return result.value
};

/**
 * List All Contents
 * 
 * GET /cx/social-messaging/v1/contents
 */
export const getApiCxSocialMessagingV1Contents = async (args: GetApiCxSocialMessagingV1ContentsArgs, options?: GetApiCxSocialMessagingV1ContentsOptions) => {
const {baseUrl = "https://platform.ringcentral.com", fetch: fetchFn = fetch, OAuth2} = options ?? {}

const query = new URLSearchParams()
const headers = new Headers()
headers.set('accept', "application/json")

for (const item of args.intervention ?? []) query.append("intervention", String(item))
for (const item of args.identity ?? []) query.append("identity", String(item))
for (const item of args.identityGroup ?? []) query.append("identityGroup", String(item))
for (const item of args.source ?? []) query.append("source", String(item))
for (const item of args.thread ?? []) query.append("thread", String(item))
for (const item of args.text ?? []) query.append("text", String(item))
for (const item of args.status ?? []) query.append("status", String(item))
if (args.orderBy != null) query.append("orderBy", String(args.orderBy))
if (args.pageToken != null) query.append("pageToken", String(args.pageToken))
if (args.perPage != null) query.append("perPage", String(args.perPage))
if (OAuth2 !== undefined) headers.set('authorization', `Bearer ${OAuth2}`)

const url = `${baseUrl.replace(/\/+$/, '')}/cx/social-messaging/v1/contents${query.size > 0 ? `?${query}` : ''}`

const res = await fetchFn(url, {method: "GET", headers})

if (!res.ok) throw new Error(`Request failed with status ${res.status}`, {cause: {status: res.status, body: await res.text()}})

return validateResponse(contentList, await res.json())
};