import Taro from '@tarojs/taro'
import { getCurrentUserId } from './auth'
import { ApiError, BASE_URL, getToken, request } from './api'
import { loadCurrentChildBindingContext } from './binding'
import { handleUnauthorized } from './session'

export type ConversationSource = 'im' | 'ai'
export type PeerKind = 'child' | 'parent' | 'ai'

const PARENT_CHILD_CONVERSATION_TYPE_NAME = 'parent_child'

export interface ChatConversation {
  id: number
  key: string
  source: ConversationSource
  peerKind: PeerKind
  name: string
  avatar: string
  typeLabel: string
  description: string
  lastMessage: string
  time: string
  sortAt: string
  roleKey?: string
  conversationTypeName?: string
  peerId?: string
  childId?: number | null
  childName?: string
  parentUserId?: number | null
  deviceId?: string
  channelLabel: string
  canSend: boolean
  isSynthetic?: boolean
}

export interface ChatMessage {
  id: number
  type: 'user' | 'peer'
  content: string
  time: string
  conversationId: number
  contentType?: number
  mediaUrl?: string | null
  mediaDurationMs?: number | null
  mediaMimeType?: string | null
  mediaTranscriptText?: string | null
  senderType?: string
  senderId?: string
  receiverType?: string
  receiverId?: string
  senderName?: string
  receiverName?: string
  channelLabel?: string
  extJson?: Record<string, any> | null
}

export interface Character {
  id: number
  name: string
  description: string
  icon: string
  peerKind: PeerKind
  source: ConversationSource
  conversationTypeName?: string
  childId?: number | null
  childName?: string
  peerId?: string
  parentUserId?: number | null
  deviceId?: string
  channelLabel: string
  canSend: boolean
}

interface DeviceAiMessageItem {
  id: number
  conversation_id: number
  role_key: string
  is_user: boolean
  speaker: 'user' | 'assistant'
  content: string
  timestamp: number
  created_at: string
}

interface DeviceAiMessageListResponse {
  items: DeviceAiMessageItem[]
  total: number
  next_cursor?: number | null
}

interface ChildConversationItem {
  conversation_id: number
  conversation_type: number
  conversation_type_name: string
  peer_type: 'child' | 'parent'
  peer_id: string
  peer_name?: string | null
  last_message_preview?: string | null
  last_message_at?: string | null
  message_count: number
}

interface ChildConversationListResponse {
  items: ChildConversationItem[]
  total: number
  next_cursor?: number | null
}

interface ChildConversationMessageItem {
  id: number
  conversation_id: number
  seq: number
  sender_type: 'child' | 'parent'
  sender_id: string
  receiver_type: 'child' | 'parent'
  receiver_id: string
  content_type: number
  content_text?: string | null
  content_json?: Record<string, any> | null
  media_file_key?: string | null
  media_duration_ms?: number | null
  media_mime_type?: string | null
  media_size_bytes?: number | null
  media_transcript_text?: string | null
  client_msg_id?: string | null
  sender_name_snapshot?: string | null
  receiver_name_snapshot?: string | null
  ext_json?: Record<string, any> | null
  created_at: string
}

interface ChildConversationMessageListResponse {
  conversation_id: number
  has_more: boolean
  next_cursor_seq?: number | null
  items: ChildConversationMessageItem[]
}

interface ConversationMessageCreateResponse {
  idempotent: boolean
  conversation_id: number
  conversation_type: number
  conversation_type_name: string
  message: ChildConversationMessageItem
}

interface BindingContext {
  deviceId: string
  childId: number | null
  childName: string
  currentUserId: number
}

const PEER_META: Record<PeerKind, { icon: string; label: string; description: string }> = {
  child: { icon: '🧒', label: '儿童', description: '孩子正在交流的儿童玩伴' },
  parent: { icon: '👨', label: '家长', description: '家长通过微信小程序和孩子沟通' },
  ai: { icon: '🤖', label: 'AI', description: '孩子与 AI 的历史交流' },
}

const AI_ROLE_META: Record<string, { name: string; icon: string; description: string }> = {
  assistant: { name: 'AI', icon: '🤖', description: '孩子与 AI 的历史交流' },
}

export function isParentChildConversation(conversationTypeName?: string | null): boolean {
  return conversationTypeName === PARENT_CHILD_CONVERSATION_TYPE_NAME
}

function parseTime(value?: string | null): number {
  if (!value) return 0
  const timestamp = new Date(value).getTime()
  return Number.isNaN(timestamp) ? 0 : timestamp
}

function parseNumericId(value?: string | number | null): number | null {
  const normalizedValue = Number(value)
  if (!Number.isFinite(normalizedValue) || normalizedValue <= 0) return null
  return normalizedValue
}

function formatListTime(value?: string | null): string {
  if (!value) return ''
  const date = new Date(value)
  if (Number.isNaN(date.getTime())) return value
  const now = new Date()
  const isSameDay =
    date.getFullYear() === now.getFullYear() &&
    date.getMonth() === now.getMonth() &&
    date.getDate() === now.getDate()
  if (isSameDay) {
    return `${`${date.getHours()}`.padStart(2, '0')}:${`${date.getMinutes()}`.padStart(2, '0')}`
  }
  return `${date.getMonth() + 1}/${date.getDate()}`
}

function formatDetailTime(value?: string | null): string {
  if (!value) return ''
  const date = new Date(value)
  if (Number.isNaN(date.getTime())) return value
  const month = `${date.getMonth() + 1}`.padStart(2, '0')
  const day = `${date.getDate()}`.padStart(2, '0')
  const hour = `${date.getHours()}`.padStart(2, '0')
  const minute = `${date.getMinutes()}`.padStart(2, '0')
  return `${month}-${day} ${hour}:${minute}`
}

function formatImPreview(
  item: Pick<
    ChildConversationMessageItem,
    'content_type' | 'content_text' | 'media_transcript_text' | 'content_json' | 'ext_json'
  >
): string {
  if (item.content_type === 1) return item.content_text || '文本消息'
  if (item.content_type === 2) {
    if (item.ext_json?.message_kind === 'leave_message') {
      return item.media_transcript_text || '[留言]'
    }
    return item.media_transcript_text || '[语音]'
  }
  if (item.content_type === 3) return '[图片]'
  if (item.content_type === 4) {
    const title = String(item.content_json?.title || item.content_json?.type || '').trim()
    return title ? `[卡片] ${title}` : '[卡片]'
  }
  return '[消息]'
}

function createClientMessageId(): string {
  return `parent-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
}

function getAiMeta(roleKey?: string): { name: string; icon: string; description: string } {
  if (roleKey && AI_ROLE_META[roleKey]) return AI_ROLE_META[roleKey]
  return {
    name: roleKey || 'AI',
    icon: '🤖',
    description: `孩子与 ${roleKey || 'AI'} 的历史交流`,
  }
}

function getParticipantDisplayName(type: string, id?: string, name?: string | null): string {
  if (name && name.trim()) return name.trim()
  if (type === 'child') return id ? `儿童 ${id}` : '儿童'
  if (type === 'parent') return id ? `家长 ${id}` : '家长'
  return id || 'AI'
}

function getPeerDisplayName(peerKind: PeerKind, peerId?: string, peerName?: string | null, roleKey?: string): string {
  if (peerKind === 'ai') return getAiMeta(roleKey).name
  return getParticipantDisplayName(peerKind, peerId, peerName)
}

function getConversationRank(conversation: ChatConversation): number {
  if (isParentChildConversation(conversation.conversationTypeName)) return 0
  return 1
}

async function getBindingContext(): Promise<BindingContext> {
  const context = await loadCurrentChildBindingContext()
  const childName = String(context.currentChild?.child_name || context.currentBinding?.child_name || '').trim()

  return {
    deviceId: context.currentBinding?.device_id || '',
    childId: context.currentChild?.child_id || null,
    childName,
    currentUserId: getCurrentUserId(),
  }
}

async function getDeviceMessages(context?: BindingContext): Promise<DeviceAiMessageItem[]> {
  const { deviceId } = context || (await getBindingContext())
  if (!deviceId) return []

  try {
    const response = await request<DeviceAiMessageListResponse>(`/banban/devices/${deviceId}/messages?limit=100`)
    return response.items || []
  } catch (error: any) {
    if (error?.status === 404) return []
    throw error
  }
}

async function getChildConversations(context?: BindingContext): Promise<ChildConversationItem[]> {
  const { childId } = context || (await getBindingContext())
  if (!childId) return []

  try {
    const response = await request<ChildConversationListResponse>(`/banban/children/${childId}/conversations?limit=100`)
    return response.items || []
  } catch (error: any) {
    if (error?.status === 404) return []
    throw error
  }
}

async function getChildConversationMessages(
  conversationId: number,
  context?: BindingContext
): Promise<ChildConversationMessageItem[]> {
  const { childId } = context || (await getBindingContext())
  if (!childId || conversationId <= 0) return []

  const response = await request<ChildConversationMessageListResponse>(
    `/banban/children/${childId}/conversations/${conversationId}/messages?limit=100`
  )
  return response.items || []
}

function toImConversation(item: ChildConversationItem, context: BindingContext): ChatConversation {
  const isParentConversation = isParentChildConversation(item.conversation_type_name)
  const peerKind: PeerKind = item.peer_type === 'parent' ? 'parent' : 'child'
  const meta = PEER_META[peerKind]

  return {
    id: item.conversation_id,
    key: `im-${item.conversation_id}`,
    source: 'im',
    peerKind,
    name: isParentConversation ? '家长沟通' : getPeerDisplayName(peerKind, item.peer_id, item.peer_name),
    avatar: meta.icon,
    typeLabel: isParentConversation ? '家长沟通' : meta.label,
    description: isParentConversation ? '家长通过微信小程序和孩子直接沟通' : meta.description,
    lastMessage: item.last_message_preview || (isParentConversation ? '还没有消息，点进去发送第一条' : '暂无消息'),
    time: formatListTime(item.last_message_at),
    sortAt: item.last_message_at || '',
    conversationTypeName: item.conversation_type_name,
    peerId: item.peer_id,
    childId: context.childId,
    childName: context.childName,
    parentUserId: isParentConversation ? parseNumericId(item.peer_id) : null,
    deviceId: context.deviceId,
    channelLabel: isParentConversation ? '微信小程序' : '设备端',
    canSend: isParentConversation,
  }
}

function toAiConversation(item: DeviceAiMessageItem, context: BindingContext): ChatConversation {
  const meta = getAiMeta(item.role_key)

  return {
    id: item.conversation_id,
    key: `ai-${item.conversation_id}`,
    source: 'ai',
    peerKind: 'ai',
    name: meta.name,
    avatar: meta.icon,
    typeLabel: PEER_META.ai.label,
    description: meta.description,
    lastMessage: item.content || '暂无消息',
    time: formatListTime(item.created_at),
    sortAt: item.created_at,
    roleKey: item.role_key,
    conversationTypeName: 'ai',
    peerId: item.role_key,
    childId: context.childId,
    childName: context.childName,
    parentUserId: null,
    deviceId: context.deviceId,
    channelLabel: 'AI',
    canSend: false,
  }
}

function createSyntheticParentConversation(context: BindingContext): ChatConversation | null {
  if (!context.childId || !context.currentUserId) return null

  return {
    id: 0,
    key: `im-parent-child-${context.childId}-${context.currentUserId}`,
    source: 'im',
    peerKind: 'parent',
    name: '家长沟通',
    avatar: PEER_META.parent.icon,
    typeLabel: '家长沟通',
    description: '家长通过微信小程序和孩子直接沟通',
    lastMessage: '还没有留言，点进去发送第一条',
    time: '',
    sortAt: '',
    conversationTypeName: PARENT_CHILD_CONVERSATION_TYPE_NAME,
    peerId: String(context.currentUserId),
    childId: context.childId,
    childName: context.childName,
    parentUserId: context.currentUserId,
    deviceId: context.deviceId,
    channelLabel: '微信小程序',
    canSend: true,
    isSynthetic: true,
  }
}

export async function getConversations(): Promise<ChatConversation[]> {
  const context = await getBindingContext()
  const [imConversationItems, aiMessages] = await Promise.all([getChildConversations(context), getDeviceMessages(context)])
  const imConversations = imConversationItems.map((item) => toImConversation(item, context))
  const aiConversationMap = new Map<number, DeviceAiMessageItem>()

  for (const item of aiMessages) {
    if (!aiConversationMap.has(item.conversation_id)) {
      aiConversationMap.set(item.conversation_id, item)
    }
  }

  const conversations = [
    ...imConversations,
    ...Array.from(aiConversationMap.values()).map((item) => toAiConversation(item, context)),
  ]

  const hasParentConversation = conversations.some(
    (item) =>
      isParentChildConversation(item.conversationTypeName) &&
      item.parentUserId === context.currentUserId
  )

  if (!hasParentConversation) {
    const syntheticConversation = createSyntheticParentConversation(context)
    if (syntheticConversation) {
      conversations.push(syntheticConversation)
    }
  }

  return conversations.sort((left, right) => {
    const rankDiff = getConversationRank(left) - getConversationRank(right)
    if (rankDiff !== 0) return rankDiff
    return parseTime(right.sortAt) - parseTime(left.sortAt)
  })
}

export async function getMessages(
  conversationId: number,
  source: ConversationSource,
  conversationTypeName?: string
): Promise<ChatMessage[]> {
  const context = await getBindingContext()

  if (source === 'ai') {
    const items = await getDeviceMessages(context)
    return items
      .filter((item) => item.conversation_id === conversationId)
      .slice()
      .reverse()
      .map((item) => ({
        id: item.id,
        type: item.is_user ? 'user' : 'peer',
        content: item.content || '暂无内容',
        time: formatDetailTime(item.created_at),
        conversationId: item.conversation_id,
        contentType: 1,
        mediaUrl: null,
        mediaDurationMs: null,
        mediaMimeType: null,
        mediaTranscriptText: null,
        senderType: item.is_user ? 'device' : 'ai',
        senderId: item.is_user ? context.deviceId : item.role_key,
        receiverType: item.is_user ? 'ai' : 'device',
        receiverId: item.is_user ? item.role_key : context.deviceId,
        senderName: item.is_user ? context.childName || '孩子设备' : getAiMeta(item.role_key).name,
        receiverName: item.is_user ? getAiMeta(item.role_key).name : context.childName || '孩子设备',
        channelLabel: 'AI',
      }))
  }

  const items = await getChildConversationMessages(conversationId, context)
  const isParentConversation = isParentChildConversation(conversationTypeName)

  return items.map((item) => ({
    id: item.id,
    type: isParentConversation
      ? item.sender_type === 'parent' && item.sender_id === String(context.currentUserId)
        ? 'user'
        : 'peer'
      : item.sender_type === 'child' && item.sender_id === String(context.childId || '')
        ? 'user'
        : 'peer',
    content: formatImPreview(item),
    time: formatDetailTime(item.created_at),
    conversationId: item.conversation_id,
    contentType: item.content_type,
    mediaUrl: item.media_file_key || null,
    mediaDurationMs: item.media_duration_ms || null,
    mediaMimeType: item.media_mime_type || null,
    mediaTranscriptText: item.media_transcript_text || null,
    senderType: item.sender_type,
    senderId: item.sender_id,
    receiverType: item.receiver_type,
    receiverId: item.receiver_id,
    extJson: item.ext_json || null,
    senderName:
      item.sender_type === 'parent' && item.sender_id === String(context.currentUserId)
        ? '我'
        : item.sender_type === 'child' && item.sender_id === String(context.childId || '')
          ? context.childName || item.sender_name_snapshot || '孩子'
          : getParticipantDisplayName(item.sender_type, item.sender_id, item.sender_name_snapshot),
    receiverName:
      item.receiver_type === 'parent' && item.receiver_id === String(context.currentUserId)
        ? '我'
        : item.receiver_type === 'child' && item.receiver_id === String(context.childId || '')
          ? context.childName || item.receiver_name_snapshot || '孩子'
          : getParticipantDisplayName(item.receiver_type, item.receiver_id, item.receiver_name_snapshot),
    channelLabel:
      isParentConversation && (item.sender_type === 'parent' || item.receiver_type === 'parent')
        ? '微信小程序'
        : '设备端',
  }))
}

export async function getCharacter(options: {
  conversationId: number
  source: ConversationSource
  peerKind?: PeerKind
  name?: string
  roleKey?: string
  conversationTypeName?: string
  childId?: number | null
  childName?: string
  peerId?: string
  parentUserId?: number | null
  deviceId?: string
  channelLabel?: string
  canSend?: boolean
}): Promise<Character | null> {
  const {
    conversationId,
    source,
    peerKind = 'ai',
    name,
    roleKey,
    conversationTypeName,
    childId,
    childName,
    peerId,
    parentUserId,
    deviceId,
    channelLabel,
    canSend = false,
  } = options

  if (source === 'ai') {
    const meta = getAiMeta(roleKey)
    return {
      id: conversationId,
      name: name || meta.name,
      description: 'AI 对话通道',
      icon: meta.icon,
      peerKind: 'ai',
      source,
      conversationTypeName: 'ai',
      childId,
      childName,
      peerId: peerId || roleKey,
      parentUserId: null,
      deviceId,
      channelLabel: channelLabel || 'AI',
      canSend: false,
    }
  }

  if (isParentChildConversation(conversationTypeName)) {
    return {
      id: conversationId,
      name: '家长沟通',
      description: '微信小程序 <-> 儿童设备',
      icon: PEER_META.parent.icon,
      peerKind: 'parent',
      source,
      conversationTypeName: PARENT_CHILD_CONVERSATION_TYPE_NAME,
      childId,
      childName,
      peerId,
      parentUserId: parentUserId || parseNumericId(peerId),
      deviceId,
      channelLabel: channelLabel || '微信小程序',
      canSend: canSend || true,
    }
  }

  const meta = PEER_META[peerKind]
  return {
    id: conversationId,
    name: getPeerDisplayName(peerKind, peerId, name),
    description: peerKind === 'child' ? '儿童设备间的聊天记录' : meta.description,
    icon: meta.icon,
    peerKind,
    source,
    conversationTypeName,
    childId,
    childName,
    peerId,
    parentUserId,
    deviceId,
    channelLabel: channelLabel || '设备端',
    canSend,
  }
}

export async function sendParentMessage(childId: number, content: string): Promise<ConversationMessageCreateResponse> {
  const normalizedContent = content.trim()
  if (!normalizedContent) {
    throw new Error('请输入消息内容')
  }

  return request<ConversationMessageCreateResponse>(`/banban/children/${childId}/messages`, {
    method: 'POST',
    data: {
      content_type: 1,
      content_text: normalizedContent,
      client_msg_id: createClientMessageId(),
    },
  })
}

function parseUploadResponseData(rawData: any): any {
  if (typeof rawData !== 'string') return rawData
  try {
    return JSON.parse(rawData)
  } catch {
    return { detail: rawData }
  }
}

function getUploadErrorMessage(data: any): string {
  if (!data) return '留言发送失败'
  if (typeof data.detail === 'string') return data.detail
  if (typeof data.message === 'string') return data.message
  if (typeof data.errMsg === 'string') return data.errMsg
  return '留言发送失败'
}

export async function sendParentVoiceMessage(
  childId: number,
  options: { filePath: string; durationMs: number; transcriptText?: string }
): Promise<ConversationMessageCreateResponse> {
  if (!childId) {
    throw new Error('当前会话不支持留言')
  }
  if (!options.filePath) {
    throw new Error('录音文件不存在')
  }

  const token = getToken()
  const requestUrl = `${BASE_URL}/banban/children/${childId}/voice-message`
  const uploadResponse: any = await new Promise((resolve, reject) => {
    Taro.uploadFile({
      url: requestUrl,
      filePath: options.filePath,
      name: 'file',
      header: token
        ? {
            Authorization: `Bearer ${token}`,
          }
        : {},
      formData: {
        duration_ms: `${Math.max(1, Math.round(options.durationMs || 0))}`,
        client_msg_id: createClientMessageId(),
        transcript_text: options.transcriptText || '',
      },
      success: resolve,
      fail: reject,
    })
  }).catch((error: any) => {
    const message = String(error?.errMsg || error?.message || 'request:fail')
    throw new ApiError(0, message)
  })

  if (uploadResponse.statusCode === 401) {
    handleUnauthorized({ redirect: true })
  }

  const data = parseUploadResponseData(uploadResponse.data)
  if (uploadResponse.statusCode >= 400) {
    throw new ApiError(uploadResponse.statusCode, getUploadErrorMessage(data))
  }

  return data as ConversationMessageCreateResponse
}