import {z} from 'zod'

export type GetApiJobsJobidTranscriptArgs = {jobid: string, format?: ('json-v2' | 'txt' | 'srt') | undefined, wait?: number | undefined};

export type GetApiJobsJobidTranscriptOptions = {baseUrl?: string | undefined, bearerAuth?: string | undefined, fetch?: typeof fetch | undefined};

export const trackingData = z.object({title: z.string().optional(), reference: z.string().optional(), tags: z.array(z.string()).optional(), details: z.object({}).optional()});

export const jobInfo = z.object({created_at: z.string(), data_name: z.string(), duration: z.number().int().gte(0), id: z.string(), tracking: trackingData.optional()});

export const jobType = z.literal("transcription");

export const model = z.enum(["standard", "enhanced", "melia-1"]);

export const operatingPoint = z.enum(["standard", "enhanced", "melia-1"]);

export const speakersInputItem = z.object({label: z.string().min(1), speaker_identifiers: z.array(z.string())});

export const transcriptionConfig = z.object({language: z.string(), domain: z.string().optional(), output_locale: z.string().optional(), model: model.optional(), operating_point: operatingPoint.optional(), additional_vocab: z.array(z.object({content: z.string(), sounds_like: z.array(z.string()).optional()})).optional(), punctuation_overrides: z.object({sensitivity: z.number().gte(0).lte(1).optional(), permitted_marks: z.array(z.string()).optional()}).optional(), diarization: z.enum(["none", "speaker", "channel"]).optional(), channel_diarization_labels: z.array(z.string()).optional(), enable_entities: z.boolean().optional(), max_delay_mode: z.enum(["fixed", "flexible"]).optional(), audio_filtering_config: z.object({volume_threshold: z.number().gte(0).lte(100).optional()}).optional(), transcript_filtering_config: z.object({remove_disfluencies: z.boolean().optional(), replacements: z.array(z.object({from: z.string(), to: z.string()})).optional()}).optional(), speaker_diarization_config: z.object({prefer_current_speaker: z.boolean().optional(), speaker_sensitivity: z.number().gte(0).lte(1).optional(), get_speakers: z.boolean().optional(), speakers: z.array(speakersInputItem).optional()}).optional()});

export const translationError = z.object({type: z.enum(["translation_failed", "unsupported_translation_pair"]).optional(), message: z.string().optional()});

export const summarizationError = z.object({type: z.enum(["summarization_failed", "unsupported_language"]).optional(), message: z.string().optional()});

export const sentimentAnalysisError = z.object({type: z.enum(["sentiment_analysis_failed", "unsupported_language"]).optional(), message: z.string().optional()});

export const topicDetectionError = z.object({type: z.enum(["topic_detection_failed", "unsupported_list_of_topics", "unsupported_language"]).optional(), message: z.string().optional()});

export const autoChaptersResultError = z.object({type: z.enum(["auto_chapters_failed", "unsupported_language"]).optional(), message: z.string().optional()});

export const outputConfig = z.object({srt_overrides: z.object({max_line_length: z.number().int().optional(), max_lines: z.number().int().optional()}).optional()});

export const languagePackInfo = z.object({language_description: z.string().optional(), word_delimiter: z.string(), writing_direction: z.enum(["left-to-right", "right-to-left"]).optional(), itn: z.boolean().optional(), adapted: z.boolean().optional()});

export const languageIdentificationResultAlternative = z.object({language: z.string().optional(), confidence: z.number().optional()});

export const languageIdentificationResultItem = z.object({alternatives: z.array(languageIdentificationResultAlternative).optional(), start_time: z.number().optional(), end_time: z.number().optional()});

export const languageIdentificationResult = z.object({results: z.array(languageIdentificationResultItem).optional(), error: z.enum(["LOW_CONFIDENCE", "UNEXPECTED_LANGUAGE", "NO_SPEECH", "FILE_UNREADABLE", "OTHER"]).optional(), message: z.string().optional()});

export const recognitionMetadata = z.object({created_at: z.string(), type: jobType, transcription_config: transcriptionConfig.optional(), translation_errors: z.array(translationError).optional(), summarization_errors: z.array(summarizationError).optional(), sentiment_analysis_errors: z.array(sentimentAnalysisError).optional(), topic_detection_errors: z.array(topicDetectionError).optional(), auto_chapters_errors: z.array(autoChaptersResultError).optional(), output_config: outputConfig.optional(), language_pack_info: languagePackInfo.optional(), language_identification: languageIdentificationResult.optional(), orchestrator_version: z.string().optional()});

export const recognitionDisplay = z.object({direction: z.enum(["ltr", "rtl"])});

export const recognitionAlternative = z.object({content: z.string(), confidence: z.number(), language: z.string(), display: recognitionDisplay.optional(), speaker: z.string().optional(), tags: z.array(z.string()).optional()});

export const writtenFormRecognitionResult = z.object({alternatives: z.array(recognitionAlternative), end_time: z.number(), start_time: z.number(), type: z.literal("word")});

export const spokenFormRecognitionResult = z.object({alternatives: z.array(recognitionAlternative), end_time: z.number(), start_time: z.number(), type: z.enum(["word", "punctuation"])});

export const recognitionResult = z.object({channel: z.string().optional(), start_time: z.number(), end_time: z.number(), volume: z.number().gte(0).lte(100).optional(), is_eos: z.boolean().optional(), type: z.enum(["word", "punctuation", "entity"]), written_form: z.array(writtenFormRecognitionResult).optional(), spoken_form: z.array(spokenFormRecognitionResult).optional(), alternatives: z.array(recognitionAlternative).optional(), attaches_to: z.enum(["previous", "next", "both", "none"]).optional()});

export const speakersResultItem = z.object({label: z.string().min(1), speaker_identifiers: z.array(z.string())});

export const translationSentence = z.object({start_time: z.number().optional(), end_time: z.number().optional(), content: z.string().optional(), speaker: z.string().optional(), channel: z.string().optional()});

export const summarizationResult = z.object({content: z.string().optional()});

export const sentimentSegment = z.object({text: z.string().optional(), sentiment: z.string().optional(), start_time: z.number().optional(), end_time: z.number().optional(), speaker: z.string().optional(), channel: z.string().optional(), confidence: z.unknown()});

export const sentimentSummaryDetail = z.object({positive_count: z.number().int().optional(), negative_count: z.number().int().optional(), neutral_count: z.number().int().optional()});

export const sentimentSpeakerSummary = z.object({speaker: z.string().optional(), positive_count: z.number().int().optional(), negative_count: z.number().int().optional(), neutral_count: z.number().int().optional()});

export const sentimentChannelSummary = z.object({channel: z.string().optional(), positive_count: z.number().int().optional(), negative_count: z.number().int().optional(), neutral_count: z.number().int().optional()});

export const sentimentSummary = z.object({overall: sentimentSummaryDetail.optional(), speakers: z.array(sentimentSpeakerSummary).optional(), channels: z.array(sentimentChannelSummary).optional()});

export const sentimentAnalysisResult = z.object({sentiment_analysis: z.object({segments: z.array(sentimentSegment).optional(), summary: sentimentSummary.optional()}).optional()});

export const topicDetectionSegmentTopic = z.object({topic: z.string().optional()});

export const topicDetectionSegment = z.object({text: z.string().optional(), start_time: z.number().optional(), end_time: z.number().optional(), topics: z.array(topicDetectionSegmentTopic).optional()});

export const topicDetectionSummaryOverall = z.record(z.string(), z.number().int());

export const topicDetectionSummary = z.object({overall: topicDetectionSummaryOverall.optional()});

export const topicDetectionResult = z.object({segments: z.array(topicDetectionSegment).optional(), summary: topicDetectionSummary.optional()});

export const chapter = z.object({title: z.string().optional(), summary: z.string().optional(), start_time: z.number().optional(), end_time: z.number().optional()});

export const autoChaptersResult = z.array(chapter);

export const audioEventItem = z.object({type: z.string().optional(), start_time: z.number().optional(), end_time: z.number().optional(), confidence: z.number().optional(), channel: z.string().optional()});

export const audioEventSummaryItem = z.object({total_duration: z.number().optional(), count: z.number().optional()});

export const audioEventSummary = z.record(z.string(), audioEventSummaryItem);

export const retrieveTranscriptResponse = z.object({format: z.string(), job: jobInfo, metadata: recognitionMetadata, results: z.array(recognitionResult), speakers: z.array(speakersResultItem).optional(), translations: z.record(z.string(), z.array(translationSentence)).optional(), summary: summarizationResult.optional(), sentiment_analysis: sentimentAnalysisResult.optional(), topics: topicDetectionResult.optional(), chapters: autoChaptersResult.optional(), audio_events: z.array(audioEventItem).optional(), audio_event_summary: z.object({overall: audioEventSummary.optional(), channels: z.record(z.string(), audioEventSummary).optional()}).optional()});

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
};

/**
 * Get the transcript for a transcription job
 * 
 * GET /jobs/{jobid}/transcript
 */
export const getApiJobsJobidTranscript = async (args: GetApiJobsJobidTranscriptArgs, options?: GetApiJobsJobidTranscriptOptions) => {
const {baseUrl = "https://eu1.asr.api.speechmatics.com/v2", fetch: fetchFn = fetch, bearerAuth} = options ?? {}

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

if (args.format != null) query.append("format", String(args.format))
if (args.wait != null) query.append("wait", String(args.wait))
if (bearerAuth !== undefined) headers.set("Authorization", bearerAuth)

const url = `${baseUrl.replace(/\/+$/, '')}/jobs/${encodeURIComponent(String(args.jobid))}/transcript${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(retrieveTranscriptResponse, await res.json())
};