// src/stores/realtime.ts

import { defineStore } from 'pinia'
import type { DataUpdatePayload } from '@/types/realtime'

export const useRealtimeStore = defineStore('realtime', {
  state: () => ({
    // key = `${nodeId}/${deviceId}` → 全量物模型缓存（初始化后持续 Merge）
    deviceSnapshot: {} as Record<string, Record<string, {
      value: unknown
      ts: number
      quality: string
      changed: boolean  // 标记本轮差量中是否刚更新（用于 UI 高亮）
    }>>,
    alertCount: 0,
  }),
  actions: {
    // 处理 data_update WebSocket 事件
    updateData(payload: DataUpdatePayload) {
      const key = `${payload.node_id}/${payload.device_id}`

      if (payload.is_full_snapshot) {
        // 全量：重建整个设备快照
        const snap: typeof this.deviceSnapshot[string] = {}
        for (const [pointId, value] of Object.entries(payload.points)) {
          snap[pointId] = { value, ts: payload.timestamp, quality: payload.quality, changed: true }
        }
        this.deviceSnapshot[key] = snap
      } else {
        // 差量：仅 Merge 出现的点位，不删除未出现的
        if (!this.deviceSnapshot[key]) this.deviceSnapshot[key] = {}
        // 先将上一轮的 changed 标记清除
        for (const p of Object.values(this.deviceSnapshot[key])) p.changed = false
        for (const [pointId, value] of Object.entries(payload.points)) {
          this.deviceSnapshot[key][pointId] = {
            value,
            ts: payload.timestamp,
            quality: payload.quality,
            changed: true,  // 本轮差量更新，UI 高亮 1.5s
          }
        }
      }
    },

    getPointValue(nodeId: string, deviceId: string, pointId: string) {
      return this.deviceSnapshot[`${nodeId}/${deviceId}`]?.[pointId]
    },

    getDeviceSnapshot(nodeId: string, deviceId: string) {
      return this.deviceSnapshot[`${nodeId}/${deviceId}`] ?? {}
    },

    incrementAlertCount() { this.alertCount++ },
    clearAlertCount() { this.alertCount = 0 },
  },
})

// src/types/realtime.ts

export type RealtimeEventType =
  | 'node_registered'       // 新节点注册
  | 'node_offline'          // 节点离线
  | 'node_heartbeat'        // 心跳更新
  | 'device_synced'         // 设备列表同步
  | 'point_synced'          // 点位元数据同步
  | 'data_update'           // 实时数据更新
  | 'command_response'      // 命令执行响应
  | 'alert'                 // 告警事件
  | 'middleware_status'     // 消息总线状态变化

export interface RealtimeEvent<T = unknown> {
  type: RealtimeEventType
  timestamp: number
  payload: T
}

export interface DataUpdatePayload {
  node_id: string
  device_id: string
  points: Record<string, number | boolean | string>  // 全量或差量点位
  timestamp: number
  quality: 'Good' | 'Bad' | 'Uncertain'
  is_full_snapshot: boolean  // true=物模型首次全量上报，false=差量 Merge
}

export interface CommandResponsePayload {
  request_id: string
  node_id: string
  device_id: string
  success: boolean
  message: string
  latency_ms: number
}

export interface AlertPayload {
  alert_id: string
  node_id: string
  device_id: string
  alert_type: string
  severity: 'info' | 'warning' | 'error' | 'critical'
  message: string
  timestamp: number
}

// src/composables/useWebSocket.ts

import { ref, onMounted, onUnmounted } from 'vue'
import type { RealtimeEvent } from '@/types/realtime'

export function useWebSocket() {
  const ws = ref<WebSocket | null>(null)
  const connected = ref(false)
  const handlers = new Map<string, Set<(payload: unknown) => void>>()

  function connect() {
    ws.value = new WebSocket(`ws://${location.host}/api/v1/ws`)
    ws.value.onopen = () => { connected.value = true }
    ws.value.onclose = () => {
      connected.value = false
      setTimeout(connect, 3000) // 自动重连
    }
    ws.value.onmessage = (event) => {
      const evt: RealtimeEvent = JSON.parse(event.data)
      const set = handlers.get(evt.type)
      if (set) set.forEach(fn => fn(evt.payload))
    }
  }

  function on(type: string, fn: (payload: unknown) => void) {
    if (!handlers.has(type)) handlers.set(type, new Set())
    handlers.get(type)!.add(fn)
    return () => handlers.get(type)?.delete(fn)
  }

  onMounted(connect)
  onUnmounted(() => ws.value?.close())

  return { connected, on }
}

// src/stores/middleware.ts

import { defineStore } from 'pinia'
import type { MiddlewareConfig } from '@/types/middleware'
import * as middlewareApi from '@/api/middleware'

export const useMiddlewareStore = defineStore('middleware', {
  state: () => ({
    list: [] as MiddlewareConfig[],
    loading: false,
  }),
  getters: {
    connectedCount: (s) => s.list.filter(m => m.status === 'connected').length,
    getById: (s) => (id: string) => s.list.find(m => m.id === id),
  },
  actions: {
    async fetchAll() {
      this.loading = true
      this.list = await middlewareApi.getAll()
      this.loading = false
    },
    async addMiddleware(cfg: Omit<MiddlewareConfig, 'id' | 'status'>) {
      const result = await middlewareApi.create(cfg)
      this.list.push(result)
      return result
    },
    async connect(id: string) {
      const cfg = await middlewareApi.connect(id)
      this.upsert(cfg)
    },
    async disconnect(id: string) {
      const cfg = await middlewareApi.disconnect(id)
      this.upsert(cfg)
    },
    async remove(id: string) {
      await middlewareApi.remove(id)
      this.list = this.list.filter(m => m.id !== id)
    },
    upsert(cfg: MiddlewareConfig) {
      const idx = this.list.findIndex(m => m.id === cfg.id)
      if (idx >= 0) this.list[idx] = cfg
      else this.list.push(cfg)
    },
    updateStatus(id: string, status: MiddlewareConfig['status']) {
      const m = this.list.find(m => m.id === id)
      if (m) m.status = status
    },
  },
})

// src/stores/node.ts

import { defineStore } from 'pinia'
import type { Node } from '@/types/node'
import * as nodeApi from '@/api/node'

export const useNodeStore = defineStore('node', {
  state: () => ({
    list: [] as Node[],
    loading: false,
  }),
  getters: {
    onlineNodes: (s) => s.list.filter(n => n.status === 'online'),
    offlineNodes: (s) => s.list.filter(n => n.status === 'offline'),
  },
  actions: {
    async fetchAll() {
      this.loading = true
      this.list = await nodeApi.getAll()
      this.loading = false
    },
    upsertNode(node: Node) {
      const idx = this.list.findIndex(n => n.id === node.id)
      if (idx >= 0) this.list[idx] = { ...this.list[idx], ...node }
      else this.list.push(node)
    },
    markOffline(nodeId: string) {
      const node = this.list.find(n => n.id === nodeId)
      if (node) node.status = 'offline'
    },
    updateHeartbeat(nodeId: string, metrics: Node['metrics']) {
      const node = this.list.find(n => n.id === nodeId)
      if (node) {
        node.last_heartbeat = Date.now()
        node.metrics = metrics
        node.status = 'online'
      }
    },
  },
})

// src/stores/realtime.ts  ← 完整代码见 §6.4
// 关键接口摘要：

realtimeStore.updateData(payload: DataUpdatePayload)  // 全量或差量 Merge
realtimeStore.getPointValue(nodeId, deviceId, pointId) // 获取点位最新值+changed标记
realtimeStore.getDeviceSnapshot(nodeId, deviceId)      // 获取设备物模型完整快照

// src/stores/command.ts

import { defineStore } from 'pinia'
import type { CommandLog } from '@/types/command'
import * as controlApi from '@/api/control'

export const useCommandStore = defineStore('command', {
  state: () => ({
    logs: [] as CommandLog[],
  }),
  actions: {
    async writePoints(nodeId: string, deviceId: string, points: Record<string, unknown>) {
      const log: CommandLog = {
        id: crypto.randomUUID(),
        type: 'write',
        nodeId, deviceId,
        command: `写入: ${JSON.stringify(points)}`,
        target: `${nodeId}/${deviceId}`,
        status: 'pending',
        timestamp: Date.now(),
      }
      this.logs.unshift(log)

      const result = await controlApi.writePoints(nodeId, deviceId, points)
      const idx = this.logs.findIndex(l => l.id === log.id)
      if (idx >= 0) {
        this.logs[idx] = {
          ...this.logs[idx],
          status: result.success ? 'success' : 'error',
          latencyMs: result.latency_ms,
          errorMessage: result.message,
        }
      }
      return result
    },
    clearLogs() { this.logs = [] },
  },
})

// src/types/middleware.ts
export interface MiddlewareConfig {
  id: string
  name: string
  type: 'edgeOS(MQTT)' | 'edgeOS(NATS)'
  description?: string
  mqtt?: MQTTConfig
  nats?: NATSConfig
  status: 'connected' | 'disconnected' | 'connecting' | 'error'
  created_at: number
  updated_at: number
}

export interface MQTTConfig {
  broker: string
  client_id: string
  username: string
  password: string
  qos: 0 | 1 | 2
  clean_session: boolean
  keep_alive: number
  connect_timeout: number
  auto_reconnect: boolean
  tls_enabled: boolean
}

export interface NATSConfig {
  url: string
  client_name: string
  username: string
  password: string
  token?: string
  reconnect_wait: number
  max_reconnects: number
  jetstream_enabled: boolean
  tls_enabled: boolean
}

// src/types/node.ts
export interface Node {
  id: string
  name: string
  model: string
  version: string
  capabilities: string[]
  protocol: string
  endpoint: { host: string; port: number }
  metadata: Record<string, string>
  status: 'online' | 'offline' | 'error'
  metrics?: NodeMetrics
  registered_at: number
  last_heartbeat: number
}

export interface NodeMetrics {
  cpu_usage: number
  memory_usage: number
  disk_usage: number
  active_devices: number
  active_tasks: number
}

// src/types/device.ts
export interface Device {
  node_id: string
  device_id: string
  device_name: string
  device_profile: string
  service_name: string
  labels: string[]
  description: string
  admin_state: 'ENABLED' | 'DISABLED'
  operating_state: 'ENABLED' | 'DISABLED'
  properties: Record<string, unknown>
  status: 'online' | 'offline'
  created_at: number
  updated_at: number
}

// src/types/point.ts
export interface Point {
  node_id: string
  device_id: string
  point_id: string
  point_name: string
  resource_name: string
  value_type: string
  access_mode: 'R' | 'W' | 'RW'
  unit: string
  minimum?: number
  maximum?: number
  address: string
  data_type: string
  scale: number
  offset: number
  current_value?: unknown
  quality?: 'good' | 'bad' | 'uncertain'
  last_updated?: number
}

// src/types/command.ts
export interface CommandLog {
  id: string
  type: 'write' | 'task_control' | 'discover' | 'config'
  nodeId: string
  deviceId: string
  command: string
  target: string
  status: 'pending' | 'success' | 'error'
  timestamp: number
  latencyMs?: number
  errorMessage?: string
}

// src/api/middleware.ts
import { http } from './http'
import type { MiddlewareConfig } from '@/types/middleware'

const BASE = '/api/v1/middlewares'
export const getAll = () => http.get<MiddlewareConfig[]>(BASE)
export const getById = (id: string) => http.get<MiddlewareConfig>(`${BASE}/${id}`)
export const create = (data: Partial<MiddlewareConfig>) => http.post<MiddlewareConfig>(BASE, data)
export const update = (id: string, data: Partial<MiddlewareConfig>) => http.put<MiddlewareConfig>(`${BASE}/${id}`, data)
export const remove = (id: string) => http.delete(`${BASE}/${id}`)
export const connect = (id: string) => http.post<MiddlewareConfig>(`${BASE}/${id}/connect`)
export const disconnect = (id: string) => http.post<MiddlewareConfig>(`${BASE}/${id}/disconnect`)
export const testConnection = (data: Partial<MiddlewareConfig>) => http.post<{ success: boolean; message: string }>(`${BASE}/test`, data)

// src/api/node.ts
const NODE_BASE = '/api/v1/nodes'
export const getAll = () => http.get<Node[]>(NODE_BASE)
export const getById = (id: string) => http.get<Node>(`${NODE_BASE}/${id}`)
export const triggerDiscover = (nodeId: string, opts: object) => http.post(`${NODE_BASE}/${nodeId}/discover`, opts)

// src/api/device.ts
export const list = (nodeId: string) => http.get<Device[]>(`/api/v1/nodes/${nodeId}/devices`)
export const getDetail = (nodeId: string, deviceId: string) => http.get<Device>(`/api/v1/nodes/${nodeId}/devices/${deviceId}`)
export const triggerSync = (nodeId: string) => http.post(`/api/v1/nodes/${nodeId}/devices/sync`)

// src/api/point.ts
export const list = (nodeId: string, deviceId: string) => http.get<Point[]>(`/api/v1/nodes/${nodeId}/devices/${deviceId}/points`)
export const syncPoints = (nodeId: string, deviceId: string) => http.post(`/api/v1/nodes/${nodeId}/devices/${deviceId}/points/sync`)
export const createTask = (nodeId: string, data: object) => http.post(`/api/v1/nodes/${nodeId}/tasks`, data)

// src/api/control.ts
export const writePoints = (nodeId: string, deviceId: string, points: Record<string, unknown>) =>
  http.post<{ success: boolean; latency_ms: number; message: string }>(
    `/api/v1/nodes/${nodeId}/devices/${deviceId}/write`, { points }
  )
export const controlTask = (nodeId: string, taskId: string, action: 'pause' | 'resume' | 'stop') =>
  http.put(`/api/v1/nodes/${nodeId}/tasks/${taskId}/${action}`)