import { query, queryOne } from '../utils/db'

interface Client {
  ws: any
  interval: number
  timer: ReturnType<typeof setInterval> | null
  autoRefresh: boolean
}

const clients = new Map<any, Client>()

async function getNetworkStatus() {
  // pubnet 상태
  const pubnetStatus = await queryOne(`
    SELECT 
      ps.*,
      pt.name as last_target_name,
      pt.url as last_target_url
    FROM pubnet_status ps
    LEFT JOIN pubnet_targets pt ON ps.last_target_id = pt.id
    WHERE ps.id = 1
  `)
  
  const pubnetLogs = await query(`
    SELECT 
      pl.*,
      pt.name as target_name,
      pt.url as target_url
    FROM pubnet_logs pl
    JOIN pubnet_targets pt ON pl.target_id = pt.id
    ORDER BY pl.checked_at DESC
    LIMIT 5
  `)

  // privnet 상태
  const privnetStatus = await queryOne(`
    SELECT 
      ps.*,
      pt.name as last_target_name,
      pt.url as last_target_url
    FROM privnet_status ps
    LEFT JOIN privnet_targets pt ON ps.last_target_id = pt.id
    WHERE ps.id = 1
  `)
  
  const privnetLogs = await query(`
    SELECT 
      pl.*,
      pt.name as target_name,
      pt.url as target_url
    FROM privnet_logs pl
    JOIN privnet_targets pt ON pl.target_id = pt.id
    ORDER BY pl.checked_at DESC
    LIMIT 5
  `)

  return {
    pubnet: {
      status: pubnetStatus,
      logs: pubnetLogs
    },
    privnet: {
      status: privnetStatus,
      logs: privnetLogs
    },
    timestamp: new Date().toISOString()
  }
}

async function getHistoricalData(datetime: string) {
  const pubnetLogs = await query(`
    SELECT 
      pl.*,
      pt.name as target_name,
      pt.url as target_url
    FROM pubnet_logs pl
    JOIN pubnet_targets pt ON pl.target_id = pt.id
    WHERE pl.checked_at <= $1
    ORDER BY pl.checked_at DESC
    LIMIT 5
  `, [datetime])

  const privnetLogs = await query(`
    SELECT 
      pl.*,
      pt.name as target_name,
      pt.url as target_url
    FROM privnet_logs pl
    JOIN privnet_targets pt ON pl.target_id = pt.id
    WHERE pl.checked_at <= $1
    ORDER BY pl.checked_at DESC
    LIMIT 5
  `, [datetime])

  const pubnetLatest = pubnetLogs[0] || null
  const privnetLatest = privnetLogs[0] || null

  return {
    pubnet: {
      status: pubnetLatest ? {
        is_healthy: pubnetLatest.is_success,
        last_checked_at: pubnetLatest.checked_at,
        last_target_name: pubnetLatest.target_name
      } : null,
      logs: pubnetLogs
    },
    privnet: {
      status: privnetLatest ? {
        is_healthy: privnetLatest.is_success,
        last_checked_at: privnetLatest.checked_at,
        last_target_name: privnetLatest.target_name
      } : null,
      logs: privnetLogs
    },
    timestamp: datetime
  }
}

// 임계값 조회
async function getThresholds() {
  let rows: any[] = []
  try {
    rows = await query(`SELECT category, metric, warning, critical, danger FROM thresholds`)
  } catch (e) {
    // 테이블 없으면 빈 배열
  }
  
  const result: Record<string, Record<string, { warning: number; critical: number; danger: number }>> = {}
  for (const row of rows) {
    if (!result[row.category]) result[row.category] = {}
    result[row.category][row.metric] = { warning: row.warning, critical: row.critical, danger: row.danger }
  }
  return result
}

// 레벨 계산
function getLevel(value: number | null, threshold: { warning: number; critical: number; danger: number }): string {
  if (value === null || value === undefined) return 'normal'
  if (value >= threshold.danger) return 'danger'
  if (value >= threshold.critical) return 'critical'
  if (value >= threshold.warning) return 'warning'
  return 'normal'
}

// 레벨 우선순위
const levelPriority: Record<string, number> = { normal: 0, warning: 1, critical: 2, danger: 3, offline: 4, stopped: 3 }

function getHighestLevel(levels: string[]): string {
  let highest = 'normal'
  for (const level of levels) {
    if ((levelPriority[level] || 0) > (levelPriority[highest] || 0)) {
      highest = level
    }
  }
  return highest
}

// 서버 대시보드 데이터
async function getServerDashboard() {
  const thresholds = await getThresholds()
  const now = new Date()
  const offlineThreshold = 5 * 60 * 1000 // 5분
  
  // 서버 목록
  const servers = await query(`
    SELECT target_id, name as server_name, is_active 
    FROM server_targets 
    WHERE is_active = 1 
    ORDER BY name
  `)
  
  const serverStatuses: any[] = []
  const summaryServers = { total: servers.length, normal: 0, warning: 0, critical: 0, danger: 0, offline: 0 }
  
  for (const server of servers) {
    // 최신 로그
    const snapshot = await queryOne(`
      SELECT cpu_usage as cpu_percent, memory_usage as memory_percent, disk_usage as disk_percent, checked_at as collected_at
      FROM server_logs 
      WHERE target_id = $1 AND is_success = 1
      ORDER BY checked_at DESC 
      LIMIT 1
    `, [server.target_id])
    
    // 오프라인 체크
    let isOffline = true
    let lastCollected = null
    if (snapshot && snapshot.collected_at) {
      lastCollected = snapshot.collected_at
      const collectedTime = new Date(snapshot.collected_at).getTime()
      isOffline = (now.getTime() - collectedTime) > offlineThreshold
    }
    
    // 서버 레벨 계산
    let serverLevel = 'offline'
    let cpuLevel = 'normal', memLevel = 'normal', diskLevel = 'normal'
    
    if (!isOffline && snapshot) {
      cpuLevel = getLevel(Number(snapshot.cpu_percent), thresholds.server?.cpu || { warning: 70, critical: 85, danger: 95 })
      memLevel = getLevel(Number(snapshot.memory_percent), thresholds.server?.memory || { warning: 80, critical: 90, danger: 95 })
      diskLevel = getLevel(Number(snapshot.disk_percent), thresholds.server?.disk || { warning: 80, critical: 90, danger: 95 })
      serverLevel = getHighestLevel([cpuLevel, memLevel, diskLevel])
    }
    
    // 요약 집계
    if (serverLevel === 'offline') summaryServers.offline++
    else if (serverLevel === 'danger') summaryServers.danger++
    else if (serverLevel === 'critical') summaryServers.critical++
    else if (serverLevel === 'warning') summaryServers.warning++
    else summaryServers.normal++
    
    serverStatuses.push({
      target_id: server.target_id,
      server_name: server.server_name,
      level: serverLevel,
      cpu_percent: snapshot?.cpu_percent ?? null,
      cpu_level: cpuLevel,
      memory_percent: snapshot?.memory_percent ?? null,
      memory_level: memLevel,
      disk_percent: snapshot?.disk_percent ?? null,
      disk_level: diskLevel,
      last_collected: lastCollected
    })
  }
  
  // 서버 정렬: 이름 순
  serverStatuses.sort((a, b) => a.server_name.localeCompare(b.server_name))
  
  return {
    summary: { servers: summaryServers },
    servers: serverStatuses,
    timestamp: new Date().toISOString()
  }
}

function startAutoRefresh(client: Client) {
  if (client.timer) {
    clearInterval(client.timer)
  }
  
  if (client.autoRefresh) {
    client.timer = setInterval(async () => {
      const data = await getNetworkStatus()
      client.ws.send(JSON.stringify({ type: 'status', data }))
      
      const serverData = await getServerDashboard()
      client.ws.send(JSON.stringify({ type: 'server', data: serverData }))
    }, client.interval)
  }
}

export default defineWebSocketHandler({
  async open(peer) {
    console.log('[WebSocket] Client connected')
    
    const client: Client = {
      ws: peer,
      interval: 60 * 1000,
      timer: null,
      autoRefresh: true
    }
    
    clients.set(peer, client)
    
    // 초기 데이터 전송
    const data = await getNetworkStatus()
    peer.send(JSON.stringify({ type: 'status', data }))
    
    const serverData = await getServerDashboard()
    peer.send(JSON.stringify({ type: 'server', data: serverData }))
    
    startAutoRefresh(client)
  },
  
  async message(peer, message) {
    const client = clients.get(peer)
    if (!client) return
    
    try {
      const msg = JSON.parse(message.text())
      
      switch (msg.type) {
        case 'set_interval':
          client.interval = msg.interval * 60 * 1000
          console.log(`[WebSocket] Interval changed to ${msg.interval} min`)
          startAutoRefresh(client)
          break
          
        case 'set_auto_refresh':
          client.autoRefresh = msg.enabled
          console.log(`[WebSocket] Auto refresh: ${msg.enabled}`)
          if (msg.enabled) {
            startAutoRefresh(client)
          } else if (client.timer) {
            clearInterval(client.timer)
            client.timer = null
          }
          break
          
        case 'fetch_at':
          const historicalData = await getHistoricalData(msg.datetime)
          peer.send(JSON.stringify({ type: 'historical', data: historicalData }))
          break
          
        case 'refresh':
          const currentData = await getNetworkStatus()
          peer.send(JSON.stringify({ type: 'status', data: currentData }))
          const currentServerData = await getServerDashboard()
          peer.send(JSON.stringify({ type: 'server', data: currentServerData }))
          break
          
        case 'refresh_server':
          const serverDashData = await getServerDashboard()
          peer.send(JSON.stringify({ type: 'server', data: serverDashData }))
          break
      }
    } catch (err) {
      console.error('[WebSocket] Message parse error:', err)
    }
  },
  
  close(peer) {
    console.log('[WebSocket] Client disconnected')
    const client = clients.get(peer)
    if (client?.timer) {
      clearInterval(client.timer)
    }
    clients.delete(peer)
  },
  
  error(peer, error) {
    console.error('[WebSocket] Error:', error)
  }
})