import { z } from '../zod'
import { credentialsBaseSchema } from './blocks/shared'
import {
  ComparisonOperators,
  LogicalOperator,
} from './blocks/logic/condition/constants'

const mediaSchema = z.object({ link: z.string() })

const headerSchema = z
  .object({
    type: z.literal('image'),
    image: mediaSchema,
  })
  .or(
    z.object({
      type: z.literal('video'),
      video: mediaSchema,
    })
  )
  .or(
    z.object({
      type: z.literal('text'),
      text: z.string(),
    })
  )

const bodySchema = z.object({
  text: z.string(),
})

const actionSchema = z.object({
  buttons: z.array(
    z.object({
      type: z.literal('reply'),
      reply: z.object({ id: z.string(), title: z.string() }),
    })
  ),
})

const templateSchema = z.object({
  name: z.string(),
  language: z.object({
    code: z.string(),
  }),
})

const interactiveSchema = z.object({
  type: z.literal('button'),
  header: headerSchema.optional(),
  body: bodySchema.optional(),
  action: actionSchema,
})

const sendingMessageSchema = z.discriminatedUnion('type', [
  z.object({
    type: z.literal('text'),
    text: z.object({
      body: z.string(),
      preview_url: z.boolean().optional(),
    }),
  }),
  z.object({
    type: z.literal('image'),
    image: mediaSchema,
  }),
  z.object({
    type: z.literal('audio'),
    audio: mediaSchema,
  }),
  z.object({
    type: z.literal('video'),
    video: mediaSchema,
  }),
  z.object({
    type: z.literal('interactive'),
    interactive: interactiveSchema,
  }),
  z.object({
    type: z.literal('template'),
    template: templateSchema,
  }),
])

export const incomingMessageSchema = z.object({
  date: z.number().optional(),
  from: z.object({
    id: z.number(),
    is_bot: z.boolean(),
    first_name: z.string(),
    last_name: z.string().optional(),
    username: z.string().optional(),
    language_code: z.string().optional(),
  }),
  chat: z.object({
    id: z.number(),
    first_name: z.string(),
    last_name: z.string().optional(),
    username: z.string().optional(),
    type: z.enum(['private', 'group', 'supergroup', 'channel']),
  }),
  message_id: z.number().optional(),
  forward_from: z.object({
    id: z.number().optional(),
    type: z.literal('channel').optional(),
    title: z.string().optional(),
  }).optional(),
  forward_date: z.number().optional(),
  text: z.string().optional(),
}).optional()

export const telegramWebhookRequestBodySchema = z.object({
  message: incomingMessageSchema,
})

export type TelegramWebhookRequestBody = z.infer<
  typeof telegramWebhookRequestBodySchema
>

export const telegramCredentialsSchema = z
  .object({
    type: z.literal('telegram'),
    data: z.object({
      botToken: z.string(),
      chatId: z.string(),
    }),
  })
  .merge(credentialsBaseSchema)

const telegramComparisonSchema = z.object({
  id: z.string(),
  comparisonOperator: z.nativeEnum(ComparisonOperators).optional(),
  value: z.string().optional(),
})
export type TelegramComparison = z.infer<typeof telegramComparisonSchema>

const startConditionSchema = z.object({
  logicalOperator: z.nativeEnum(LogicalOperator),
  comparisons: z.array(
    z.object({
      id: z.string(),
      comparisonOperator: z.nativeEnum(ComparisonOperators).optional(),
      value: z.string().optional(),
    })
  ),
})

export const telegramSettingsSchema = z.object({
  isEnabled: z.boolean().optional(),
  startCondition: startConditionSchema.optional(),
  sessionExpiryTimeout: z
    .number()
    .max(48)
    .min(0.01)
    .optional()
    .describe('Expiration delay in hours after latest interaction'),
})

export const defaultSessionExpiryTimeout = 4

export type TelegramIncomingMessage = z.infer<typeof incomingMessageSchema>
export type TelegramSendingMessage = z.infer<typeof sendingMessageSchema>
export type TelegramCredentials = z.infer<typeof telegramCredentialsSchema>