import type React from 'react'

/**
 * Three messaging states a `MessageAttachment.*` card can render in,
 * mirroring the LinkAttachment / LockedAttachment families.
 */
export type MessageAttachmentState = 'composer' | 'sent' | 'received'

/**
 * Visual variant of the surrounding `Bubble` chrome. Sender-side bubbles
 * (`composer`, `sent`) get the dark treatment; recipient-side bubbles
 * (`received`) get the light treatment.
 */
export type BubbleVariant = 'dark' | 'light'

/** Maps a state to the bubble chrome it should render with. */
export const bubbleVariantForState = (
  state: MessageAttachmentState
): BubbleVariant => (state === 'received' ? 'light' : 'dark')

/**
 * Position of a bubble inside a same-author run, mirroring the grouping
 * stream-chat-react applies to consecutive messages from the same user:
 *
 *   - `'single'` — standalone message, every corner fully rounded.
 *   - `'first'`  — first in a 2+ message run; the corner facing the
 *                  next bubble in the run is flattened.
 *   - `'middle'` — both the corner facing the previous bubble and the
 *                  corner facing the next bubble are flattened.
 *   - `'end'`    — last in a 2+ message run; the corner facing the
 *                  previous bubble is flattened (this is also the
 *                  bubble the avatar attaches to on the receiver side).
 *
 * "Facing" is determined by the bubble's side: sender-aligned bubbles
 * cluster against their right edge, receiver-aligned bubbles against
 * their left edge.
 */
export type BubbleGroupPosition = 'single' | 'first' | 'middle' | 'end'

/**
 * Convenience adapter that derives the `BubbleGroupPosition` from the
 * three booleans `stream-chat-react` forwards into the `Message` HOC.
 * Drop-in for `useMessageContext()` consumers:
 *
 * ```tsx
 * const { firstOfGroup, endOfGroup, groupedByUser } = useMessageContext()
 * <MessageAttachment.Image.Sent
 *   {...props}
 *   groupPosition={bubbleGroupPositionFromStream({
 *     firstOfGroup, endOfGroup, groupedByUser,
 *   })}
 * />
 * ```
 *
 * @deprecated Unadopted convenience adapter, slated for removal in a future
 * release. No consumer uses it. Derive `groupPosition` (a `BubbleGroupPosition`)
 * inline from stream-chat-react's `firstOfGroup` / `endOfGroup` /
 * `groupedByUser` booleans instead.
 */
export const bubbleGroupPositionFromStream = ({
  firstOfGroup,
  endOfGroup,
  groupedByUser,
}: {
  firstOfGroup?: boolean
  endOfGroup?: boolean
  groupedByUser?: boolean
}): BubbleGroupPosition => {
  if (!groupedByUser) return 'single'
  if (firstOfGroup && endOfGroup) return 'single'
  if (firstOfGroup) return 'first'
  if (endOfGroup) return 'end'
  return 'middle'
}

/** Loading hint forwarded to the underlying `<img>` element. */
export type ImageLoadingMode = 'lazy' | 'eager'

/** Preload hint forwarded to the underlying `<video>` / `<audio>` element. */
export type MediaPreloadMode = 'none' | 'metadata' | 'auto'

/** A single image inside an Image attachment (single or stacked). */
export interface ImageItem {
  src: string
  alt?: string
  /** Optional width/height hint — preserved aspect on cover-fit. */
  width?: number
  height?: number
  /**
   * Per-tile native lazy-load override. Defaults to the parent
   * attachment's `loading` value (which itself defaults to `'lazy'`).
   * Pass `'eager'` for above-the-fold hero tiles.
   */
  loading?: ImageLoadingMode
}

/** A single video inside a Video attachment (single or stacked). */
export interface VideoItem {
  src: string
  /** Poster / thumbnail rendered before playback starts. */
  poster?: string
  /**
   * Width ÷ height of the source clip, when the sender recorded it on the
   * attachment (Stream's `original_width` / `original_height`). Preferred over
   * measuring the poster, because it is known before any image loads and works
   * for a clip that has no poster at all — the case that otherwise leaves a
   * portrait video in a square or landscape box. Absent on anything sent
   * before the composer began writing it (MES-1353).
   */
  naturalAspectRatio?: number
  /** Optional MIME type (e.g. `video/mp4`). */
  mimeType?: string
  /**
   * Per-item override for the `<video preload>` hint. Defaults to the
   * parent attachment's `preload` value (which itself defaults to
   * `'none'` so the poster carries the visual weight and no video
   * bytes are fetched until playback).
   */
  preload?: MediaPreloadMode
}

/** A single PDF inside a Pdf attachment (single or stacked). */
export interface PdfItem {
  src: string
  /** Filename — drives the row title + the meta line + the viewer dialog's accessible name. */
  filename?: string
  /** File size in bytes — formatted into the `EXT · SIZE` meta line. */
  fileSize?: number
  /** Override displayed title. Defaults to `filename`. */
  title?: string
}

/** A single audio file inside an Audio attachment (single or stacked). */
export interface AudioItem {
  src: string
  /** MIME type hint — typed onto the inline `<source>` element. */
  mimeType?: string
  /**
   * Filename — used as the download default name (consumed by the
   * native player's kebab menu).
   */
  filename?: string
  /**
   * Per-track override for the `<audio preload>` hint. Defaults to
   * the parent attachment's `preload` value, which itself defaults
   * to `'metadata'` for a single audio (so the native player can
   * surface duration immediately) and `'none'` for a stacked thread
   * (so a fan-out of metadata requests doesn't happen on first paint).
   */
  preload?: MediaPreloadMode
}

/** A single generic file inside a File attachment (single or stacked). */
export interface FileItem {
  src: string
  /** Filename — drives the title + the meta line + the download default name. */
  filename?: string
  /** File size in bytes — formatted into the `EXT · SIZE` meta line. */
  fileSize?: number
  /** MIME type — drives the type icon. Defaults to `application/octet-stream`. */
  mimeType?: string
  /** Override displayed title. Defaults to `filename`. */
  title?: string
}

/** Shared props every `MessageAttachment.*.{Composer|Sent|Received}` accepts. */
export interface MessageAttachmentBaseProps {
  /**
   * Optional text rendered below the attachment inside the same bubble.
   * Mirrors the chat behavior in the mobile screenshots — `'Here is the
   * file'`, `'Here is the image'`, etc.
   */
  text?: React.ReactNode
  /**
   * Position of this attachment inside a same-author message run —
   * mirrors the corner-flattening stream-chat-react applies to text
   * bubbles in a clustered conversation. Defaults to `'single'`, so
   * standalone usage keeps every corner rounded. Pass the value
   * derived from `bubbleGroupPositionFromStream({ firstOfGroup,
   * endOfGroup, groupedByUser })` when rendering inside a real
   * `CustomMessage` thread to make the attachment visually merge
   * with adjacent bubbles. Image / Video Composer ignore this — the
   * draft preview renders bare without the surrounding bubble.
   */
  groupPosition?: BubbleGroupPosition
}

/** Shared props for the `Composer` state of every attachment type. */
export interface ComposerExtras {
  /** Renders a dismiss `×` button overlaid on the attachment. */
  onDismiss?: () => void
}