import { reactive } from 'vue'
import type { IEventBuilder, IEventMap } from '@/events/IEventBuilder'
import { v4 as uuidv4 } from 'uuid'
import type { WindowState } from './WindowService'
import type { ResourceType } from './ResourceService'

/**
 * 消息类型枚举
 */
export enum MessageType {
  SYSTEM = 'system',
  APPLICATION = 'application',
  USER_INTERACTION = 'user_interaction',
  CROSS_APP = 'cross_app',
  BROADCAST = 'broadcast',
}

/**
 * 消息优先级枚举
 */
export enum MessagePriority {
  LOW = 0,
  NORMAL = 1,
  HIGH = 2,
  CRITICAL = 3,
}

/**
 * 消息状态枚举
 */
export enum MessageStatus {
  PENDING = 'pending',
  SENT = 'sent',
  DELIVERED = 'delivered',
  FAILED = 'failed',
  EXPIRED = 'expired',
}

/**
 * 事件消息接口
 */
export interface EventMessage {
  id: string
  type: MessageType
  priority: MessagePriority
  senderId: string
  receiverId?: string // undefined表示广播消息
  channel: string
  payload: any
  timestamp: Date
  expiresAt?: Date
  status: MessageStatus
  retryCount: number
  maxRetries: number
}

/**
 * 事件订阅者接口
 */
export interface EventSubscriber {
  id: string
  appId: string
  channel: string
  handler: (message: EventMessage) => void | Promise<void>
  filter?: (message: EventMessage) => boolean
  priority: MessagePriority
  createdAt: Date
  active: boolean
}

/**
 * 通信通道接口
 */
export interface CommunicationChannel {
  name: string
  description: string
  restricted: boolean // 是否需要权限
  allowedApps: string[] // 允许访问的应用ID列表
  maxMessageSize: number // 最大消息大小(字节)
  messageRetention: number // 消息保留时间(毫秒)
}

/**
 * 事件统计信息
 */
export interface EventStatistics {
  totalMessagesSent: number
  totalMessagesReceived: number
  totalBroadcasts: number
  failedMessages: number
  activeSubscribers: number
  channelUsage: Map<string, number>
}

/**
 * 窗体数据更新参数
 */
export interface WindowFormDataUpdateParams {
  /** 窗口id */
  id: string
  /** 窗口状态 */
  state: WindowState
  /** 窗口宽度 */
  width: number
  /** 窗口高度 */
  height: number
  /** 窗口x坐标(左上角) */
  x: number
  /** 窗口y坐标(左上角) */
  y: number
}

/**
 * 事件通信服务事件接口
 */
export interface EventCommunicationEvents extends IEventMap {
  // 系统就绪事件
  onSystemReady: (data: { timestamp: Date; services: string[] }) => void
  
  // 窗体相关事件
  onWindowStateChanged: (windowId: string, newState: string, oldState: string) => void
  onWindowFormDataUpdate: (data: WindowFormDataUpdateParams) => void
  onWindowFormResizeStart: (windowId: string) => void
  onWindowFormResizing: (windowId: string, width: number, height: number) => void
  onWindowFormResizeEnd: (windowId: string) => void
  onWindowClose: (windowId: string) => void
  
  // 应用生命周期事件
  onAppLifecycle: (data: { appId: string; event: string; timestamp: Date }) => void
  
  // 资源相关事件
  onResourceQuotaExceeded: (appId: string, resourceType: ResourceType) => void
  onPerformanceAlert: (data: { type: 'memory' | 'cpu'; usage: number; limit: number }) => void
  
  // 消息处理事件
  onMessageProcessed: (message: EventMessage) => void
  onMessageFailed: (message: EventMessage, error: any) => void
}

/**
 * 事件通信服务类
 */
export class EventCommunicationService {
  private subscribers = reactive(new Map<string, EventSubscriber>())
  private messageQueue = reactive(new Map<string, EventMessage[]>()) // 按应用分组的消息队列
  private messageHistory = reactive(new Map<string, EventMessage[]>()) // 消息历史记录
  private channels = reactive(new Map<string, CommunicationChannel>())
  private statistics = reactive<EventStatistics>({
    totalMessagesSent: 0,
    totalMessagesReceived: 0,
    totalBroadcasts: 0,
    failedMessages: 0,
    activeSubscribers: 0,
    channelUsage: new Map(),
  })

  private processingInterval: number | null = null
  private eventBus: IEventBuilder<EventCommunicationEvents>

  constructor(eventBus: IEventBuilder<EventCommunicationEvents>) {
    this.eventBus = eventBus
    this.initializeDefaultChannels()
    this.startMessageProcessing()
  }

  /**
   * 订阅事件频道
   */
  subscribe(
    appId: string,
    channel: string,
    handler: (message: EventMessage) => void | Promise<void>,
    options: {
      filter?: (message: EventMessage) => boolean
      priority?: MessagePriority
    } = {},
  ): string {
    // 检查通道权限
    if (!this.canAccessChannel(appId, channel)) {
      throw new Error(`应用 ${appId} 无权访问频道 ${channel}`)
    }

    const subscriberId = uuidv4()
    const subscriber: EventSubscriber = {
      id: subscriberId,
      appId,
      channel,
      handler,
      filter: options.filter,
      priority: options.priority || MessagePriority.NORMAL,
      createdAt: new Date(),
      active: true,
    }

    this.subscribers.set(subscriberId, subscriber)
    this.updateActiveSubscribersCount()

    console.log(`应用 ${appId} 订阅了频道 ${channel}`)
    return subscriberId
  }

  /**
   * 取消订阅
   */
  unsubscribe(subscriberId: string): boolean {
    const result = this.subscribers.delete(subscriberId)
    if (result) {
      this.updateActiveSubscribersCount()
      console.log(`取消订阅: ${subscriberId}`)
    }
    return result
  }

  /**
   * 发送消息
   */
  async sendMessage(
    senderId: string,
    channel: string,
    payload: any,
    options: {
      receiverId?: string
      priority?: MessagePriority
      type?: MessageType
      expiresIn?: number // 过期时间(毫秒)
      maxRetries?: number
    } = {},
  ): Promise<string> {
    // 检查发送者权限
    if (!this.canAccessChannel(senderId, channel)) {
      throw new Error(`应用 ${senderId} 无权向频道 ${channel} 发送消息`)
    }

    // 检查消息大小
    const messageSize = JSON.stringify(payload).length
    const channelConfig = this.channels.get(channel)
    if (channelConfig && messageSize > channelConfig.maxMessageSize) {
      throw new Error(`消息大小超出限制: ${messageSize} > ${channelConfig.maxMessageSize}`)
    }

    const messageId = uuidv4()
    const now = new Date()

    const message: EventMessage = {
      id: messageId,
      type: options.type || MessageType.APPLICATION,
      priority: options.priority || MessagePriority.NORMAL,
      senderId,
      receiverId: options.receiverId,
      channel,
      payload,
      timestamp: now,
      expiresAt: options.expiresIn ? new Date(now.getTime() + options.expiresIn) : undefined,
      status: MessageStatus.PENDING,
      retryCount: 0,
      maxRetries: options.maxRetries || 3,
    }

    // 如果是点对点消息，直接发送
    if (options.receiverId) {
      await this.deliverMessage(message)
    } else {
      // 广播消息，加入队列处理
      this.addToQueue(message)
    }

    // 更新统计信息
    this.statistics.totalMessagesSent++
    if (!options.receiverId) {
      this.statistics.totalBroadcasts++
    }

    const channelUsage = this.statistics.channelUsage.get(channel) || 0
    this.statistics.channelUsage.set(channel, channelUsage + 1)

    // 记录消息历史
    this.recordMessage(message)

    console.log(
      `[EventCommunication] 消息 ${messageId} 已发送到频道 ${channel}[发送者: ${senderId}]`,
    )
    return messageId
  }

  /**
   * 广播消息到所有订阅者
   */
  async broadcast(
    senderId: string,
    channel: string,
    payload: any,
    options: {
      priority?: MessagePriority
      expiresIn?: number
    } = {},
  ): Promise<string> {
    return this.sendMessage(senderId, channel, payload, {
      ...options,
      type: MessageType.BROADCAST,
    })
  }

  /**
   * 发送跨应用消息
   */
  async sendCrossAppMessage(
    senderId: string,
    receiverId: string,
    payload: any,
    options: {
      priority?: MessagePriority
      expiresIn?: number
    } = {},
  ): Promise<string> {
    const channel = 'cross-app'

    return this.sendMessage(senderId, channel, payload, {
      ...options,
      receiverId,
      type: MessageType.CROSS_APP,
    })
  }

  /**
   * 获取消息历史
   */
  getMessageHistory(
    appId: string,
    options: {
      channel?: string
      limit?: number
      since?: Date
    } = {},
  ): EventMessage[] {
    const history = this.messageHistory.get(appId) || []

    let filtered = history.filter((msg) => msg.senderId === appId || msg.receiverId === appId)

    if (options.channel) {
      filtered = filtered.filter((msg) => msg.channel === options.channel)
    }

    if (options.since) {
      filtered = filtered.filter((msg) => msg.timestamp >= options.since!)
    }

    if (options.limit) {
      filtered = filtered.slice(-options.limit)
    }

    return filtered.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime())
  }

  /**
   * 获取应用的订阅列表
   */
  getAppSubscriptions(appId: string): EventSubscriber[] {
    return Array.from(this.subscribers.values()).filter((sub) => sub.appId === appId)
  }

  /**
   * 获取频道订阅者数量
   */
  getChannelSubscriberCount(channel: string): number {
    return Array.from(this.subscribers.values()).filter(
      (sub) => sub.channel === channel && sub.active,
    ).length
  }

  /**
   * 创建通信频道
   */
  createChannel(channel: string, config: Omit<CommunicationChannel, 'name'>): boolean {
    if (this.channels.has(channel)) {
      return false
    }

    this.channels.set(channel, {
      name: channel,
      ...config,
    })

    console.log(`创建通信频道: ${channel}`)
    return true
  }

  /**
   * 删除通信频道
   */
  deleteChannel(channel: string): boolean {
    // 移除所有相关订阅
    const subscribersToRemove = Array.from(this.subscribers.entries())
      .filter(([, sub]) => sub.channel === channel)
      .map(([id]) => id)

    subscribersToRemove.forEach((id) => this.unsubscribe(id))

    // 删除频道
    const result = this.channels.delete(channel)

    if (result) {
      console.log(`删除通信频道: ${channel}`)
    }

    return result
  }

  /**
   * 获取统计信息
   */
  getStatistics(): EventStatistics {
    return { ...this.statistics }
  }

  /**
   * 清理过期消息和订阅
   */
  cleanup(): void {
    const now = new Date()

    // 清理过期消息
    for (const [appId, messages] of this.messageQueue.entries()) {
      const validMessages = messages.filter((msg) => !msg.expiresAt || msg.expiresAt > now)

      if (validMessages.length !== messages.length) {
        this.messageQueue.set(appId, validMessages)
      }
    }

    // 清理消息历史(保留最近7天)
    const sevenDaysAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000)
    for (const [appId, history] of this.messageHistory.entries()) {
      const recentHistory = history.filter((msg) => msg.timestamp > sevenDaysAgo)
      this.messageHistory.set(appId, recentHistory)
    }

    console.log('事件通信服务清理完成')
  }

  /**
   * 销毁服务
   */
  destroy(): void {
    if (this.processingInterval) {
      clearInterval(this.processingInterval)
      this.processingInterval = null
    }

    this.subscribers.clear()
    this.messageQueue.clear()
    this.messageHistory.clear()
    this.channels.clear()

    console.log('事件通信服务已销毁')
  }

  // 私有方法

  /**
   * 初始化默认频道
   */
  private initializeDefaultChannels(): void {
    // 系统事件频道
    this.createChannel('system', {
      description: '系统级事件通信',
      restricted: true,
      allowedApps: ['system'],
      maxMessageSize: 1024 * 10, // 10KB
      messageRetention: 24 * 60 * 60 * 1000, // 24小时
    })

    // 应用间通信频道
    this.createChannel('cross-app', {
      description: '应用间通信',
      restricted: false,
      allowedApps: [],
      maxMessageSize: 1024 * 100, // 100KB
      messageRetention: 7 * 24 * 60 * 60 * 1000, // 7天
    })

    // 用户交互频道
    this.createChannel('user-interaction', {
      description: '用户交互事件',
      restricted: false,
      allowedApps: [],
      maxMessageSize: 1024 * 5, // 5KB
      messageRetention: 60 * 60 * 1000, // 1小时
    })

    // 广播频道
    this.createChannel('broadcast', {
      description: '系统广播',
      restricted: true,
      allowedApps: ['system'],
      maxMessageSize: 1024 * 50, // 50KB
      messageRetention: 24 * 60 * 60 * 1000, // 24小时
    })
  }

  /**
   * 检查应用是否可以访问频道
   */
  private canAccessChannel(appId: string, channel: string): boolean {
    const channelConfig = this.channels.get(channel)

    if (!channelConfig) {
      // 频道不存在，默认允许
      return true
    }

    if (!channelConfig.restricted) {
      return true
    }

    // 系统应用总是有权限
    if (appId === 'system') {
      return true
    }

    return channelConfig.allowedApps.includes(appId)
  }

  /**
   * 添加消息到队列
   */
  private addToQueue(message: EventMessage): void {
    const queueKey = message.receiverId || 'broadcast'

    if (!this.messageQueue.has(queueKey)) {
      this.messageQueue.set(queueKey, [])
    }

    const queue = this.messageQueue.get(queueKey)!

    // 按优先级插入
    const insertIndex = queue.findIndex((msg) => msg.priority < message.priority)
    if (insertIndex === -1) {
      queue.push(message)
    } else {
      queue.splice(insertIndex, 0, message)
    }
  }

  /**
   * 直接投递消息
   */
  private async deliverMessage(message: EventMessage): Promise<void> {
    try {
      const subscribers = this.getRelevantSubscribers(message)

      if (subscribers.length === 0) {
        message.status = MessageStatus.FAILED
        // 只对非系统频道显示警告信息
        if (message.channel !== 'system') {
          console.warn(
            `[EventCommunication] 没有找到频道 ${message.channel} 的订阅者[消息 ID: ${message.id}]`,
          )
        }
        return
      }

      // 并行发送给所有订阅者
      const deliveryPromises = subscribers.map(async (subscriber) => {
        try {
          // 应用过滤器
          if (subscriber.filter && !subscriber.filter(message)) {
            return
          }

          await subscriber.handler(message)
          this.statistics.totalMessagesReceived++
          console.log(
            `[EventCommunication] 消息 ${message.id} 已投递给订阅者 ${subscriber.id}[频道: ${message.channel}]`,
          )
        } catch (error) {
          console.error(`向订阅者 ${subscriber.id} 发送消息失败:`, error)
          throw error
        }
      })

      await Promise.allSettled(deliveryPromises)
      message.status = MessageStatus.DELIVERED
    } catch (error) {
      message.status = MessageStatus.FAILED
      this.statistics.failedMessages++
      console.error('消息投递失败:', error)

      // 重试机制
      if (message.retryCount < message.maxRetries) {
        message.retryCount++
        message.status = MessageStatus.PENDING
        setTimeout(() => this.deliverMessage(message), 1000 * message.retryCount)
      }
    }
  }

  /**
   * 获取相关订阅者
   */
  private getRelevantSubscribers(message: EventMessage): EventSubscriber[] {
    return Array.from(this.subscribers.values()).filter((subscriber) => {
      if (!subscriber.active) return false
      if (subscriber.channel !== message.channel) return false

      // 点对点消息检查接收者
      if (message.receiverId && subscriber.appId !== message.receiverId) {
        return false
      }

      return true
    })
  }

  /**
   * 开始消息处理循环
   */
  private startMessageProcessing(): void {
    this.processingInterval = setInterval(() => {
      this.processMessageQueue()
      this.cleanupExpiredMessages()
    }, 100) // 每100ms处理一次
  }

  /**
   * 处理消息队列
   */
  private processMessageQueue(): void {
    for (const [queueKey, messages] of this.messageQueue.entries()) {
      if (messages.length === 0) continue

      // 处理优先级最高的消息
      const message = messages.shift()!

      // 检查消息是否过期
      if (message.expiresAt && message.expiresAt <= new Date()) {
        message.status = MessageStatus.EXPIRED
        continue
      }

      this.deliverMessage(message)
    }
  }

  /**
   * 清理过期消息
   */
  private cleanupExpiredMessages(): void {
    const now = new Date()

    for (const [queueKey, messages] of this.messageQueue.entries()) {
      const validMessages = messages.filter((msg) => !msg.expiresAt || msg.expiresAt > now)

      if (validMessages.length !== messages.length) {
        this.messageQueue.set(queueKey, validMessages)
      }
    }
  }

  /**
   * 记录消息历史
   */
  private recordMessage(message: EventMessage): void {
    // 记录发送者历史
    if (!this.messageHistory.has(message.senderId)) {
      this.messageHistory.set(message.senderId, [])
    }
    this.messageHistory.get(message.senderId)!.push(message)

    // 记录接收者历史
    if (message.receiverId && message.receiverId !== message.senderId) {
      if (!this.messageHistory.has(message.receiverId)) {
        this.messageHistory.set(message.receiverId, [])
      }
      this.messageHistory.get(message.receiverId)!.push(message)
    }
  }

  /**
   * 更新活跃订阅者数量
   */
  private updateActiveSubscribersCount(): void {
    this.statistics.activeSubscribers = Array.from(this.subscribers.values()).filter(
      (sub) => sub.active,
    ).length
  }
}