bedolaga-cabinet/src/api/banSystem.ts

import apiClient from './client'

// === Types ===

export interface BanSystemStatus {
  enabled: boolean
  configured: boolean
}

export interface BanSystemStats {
  total_users: number
  active_users: number
  users_over_limit: number
  total_requests: number
  total_punishments: number
  active_punishments: number
  nodes_online: number
  nodes_total: number
  agents_online: number
  agents_total: number
  panel_connected: boolean
  uptime_seconds: number | null
}

export interface BanUserIPInfo {
  ip: string
  first_seen: string | null
  last_seen: string | null
  node: string | null
  request_count: number
  country_code: string | null
  country_name: string | null
  city: string | null
}

export interface BanUserRequestLog {
  timestamp: string
  source_ip: string
  destination: string | null
  dest_port: number | null
  protocol: string | null
  action: string | null
  node: string | null
}

export interface BanUserListItem {
  email: string
  unique_ip_count: number
  total_requests: number
  limit: number | null
  is_over_limit: boolean
  blocked_count: number
  last_seen: string | null
}

export interface BanUsersListResponse {
  users: BanUserListItem[]
  total: number
  offset: number
  limit: number
}

export interface BanUserDetailResponse {
  email: string
  unique_ip_count: number
  total_requests: number
  limit: number | null
  is_over_limit: boolean
  blocked_count: number
  ips: BanUserIPInfo[]
  recent_requests: BanUserRequestLog[]
  network_type: string | null
}

export interface BanPunishmentItem {
  id: number | null
  user_id: string
  uuid: string | null
  username: string
  reason: string | null
  punished_at: string
  enable_at: string | null
  ip_count: number
  limit: number
  enabled: boolean
  enabled_at: string | null
  node_name: string | null
}

export interface BanPunishmentsListResponse {
  punishments: BanPunishmentItem[]
  total: number
}

export interface BanHistoryResponse {
  items: BanPunishmentItem[]
  total: number
}

export interface BanUserRequest {
  username: string
  minutes: number
  reason?: string
}

export interface UnbanResponse {
  success: boolean
  message: string
}

export interface BanNodeItem {
  name: string
  address: string | null
  is_connected: boolean
  last_seen: string | null
  users_count: number
  agent_stats: Record<string, unknown> | null
}

export interface BanNodesListResponse {
  nodes: BanNodeItem[]
  total: number
  online: number
}

export interface BanAgentItem {
  node_name: string
  sent_total: number
  dropped_total: number
  batches_total: number
  reconnects: number
  failures: number
  queue_size: number
  queue_max: number
  dedup_checked: number
  dedup_skipped: number
  filter_checked: number
  filter_filtered: number
  health: string
  is_online: boolean
  last_report: string | null
}

export interface BanAgentsSummary {
  total_agents: number
  online_agents: number
  total_sent: number
  total_dropped: number
  avg_queue_size: number
  healthy_count: number
  warning_count: number
  critical_count: number
}

export interface BanAgentsListResponse {
  agents: BanAgentItem[]
  summary: BanAgentsSummary | null
  total: number
  online: number
}

export interface BanTrafficViolationItem {
  id: number | null
  username: string
  email: string | null
  violation_type: string
  description: string | null
  bytes_used: number
  bytes_limit: number
  detected_at: string
  resolved: boolean
}

export interface BanTrafficViolationsResponse {
  violations: BanTrafficViolationItem[]
  total: number
}

export interface BanTrafficTopItem {
  username: string
  bytes_total: number
  bytes_limit: number | null
  over_limit: boolean
}

export interface BanTrafficResponse {
  enabled: boolean
  stats: Record<string, unknown> | null
  top_users: BanTrafficTopItem[]
  recent_violations: BanTrafficViolationItem[]
}

// === Settings Types ===

export interface BanSettingDefinition {
  key: string
  value: unknown
  type: string
  min_value: number | null
  max_value: number | null
  editable: boolean
  description: string | null
  category: string | null
}

export interface BanSettingsResponse {
  settings: BanSettingDefinition[]
}

export interface BanWhitelistRequest {
  username: string
}

// === Report Types ===

export interface BanReportTopViolator {
  username: string
  count: number
}

export interface BanReportResponse {
  period_hours: number
  current_users: number
  current_ips: number
  punishment_stats: Record<string, unknown> | null
  top_violators: BanReportTopViolator[]
}

// === Health Types ===

export interface BanHealthComponent {
  name: string
  status: string
  message: string | null
  details: Record<string, unknown> | null
}

export interface BanHealthResponse {
  status: string
  uptime: number | null
  components: BanHealthComponent[]
}

export interface BanHealthDetailedResponse {
  status: string
  uptime: number | null
  components: Record<string, unknown>
}

// === Agent History Types ===

export interface BanAgentHistoryItem {
  timestamp: string
  sent_total: number
  dropped_total: number
  queue_size: number
  batches_total: number
}

export interface BanAgentHistoryResponse {
  node: string
  hours: number
  records: number
  delta: Record<string, unknown> | null
  first: Record<string, unknown> | null
  last: Record<string, unknown> | null
  history: BanAgentHistoryItem[]
}

// === API ===

export const banSystemApi = {
  // Status
  getStatus: async (): Promise<BanSystemStatus> => {
    const response = await apiClient.get('/cabinet/admin/ban-system/status')
    return response.data
  },

  // Stats
  getStats: async (): Promise<BanSystemStats> => {
    const response = await apiClient.get('/cabinet/admin/ban-system/stats')
    return response.data
  },

  // Users
  getUsers: async (params: {
    offset?: number
    limit?: number
    status?: string
  } = {}): Promise<BanUsersListResponse> => {
    const response = await apiClient.get('/cabinet/admin/ban-system/users', { params })
    return response.data
  },

  getUsersOverLimit: async (limit: number = 50): Promise<BanUsersListResponse> => {
    const response = await apiClient.get('/cabinet/admin/ban-system/users/over-limit', {
      params: { limit }
    })
    return response.data
  },

  searchUsers: async (query: string): Promise<BanUsersListResponse> => {
    const response = await apiClient.get(`/cabinet/admin/ban-system/users/search/${encodeURIComponent(query)}`)
    return response.data
  },

  getUser: async (email: string): Promise<BanUserDetailResponse> => {
    const response = await apiClient.get(`/cabinet/admin/ban-system/users/${encodeURIComponent(email)}`)
    return response.data
  },

  // Punishments
  getPunishments: async (): Promise<BanPunishmentsListResponse> => {
    const response = await apiClient.get('/cabinet/admin/ban-system/punishments')
    return response.data
  },

  unbanUser: async (userId: string): Promise<UnbanResponse> => {
    const response = await apiClient.post(`/cabinet/admin/ban-system/punishments/${userId}/unban`)
    return response.data
  },

  banUser: async (data: BanUserRequest): Promise<UnbanResponse> => {
    const response = await apiClient.post('/cabinet/admin/ban-system/ban', data)
    return response.data
  },

  getPunishmentHistory: async (query: string, limit: number = 20): Promise<BanHistoryResponse> => {
    const response = await apiClient.get(`/cabinet/admin/ban-system/history/${encodeURIComponent(query)}`, {
      params: { limit }
    })
    return response.data
  },

  // Nodes
  getNodes: async (): Promise<BanNodesListResponse> => {
    const response = await apiClient.get('/cabinet/admin/ban-system/nodes')
    return response.data
  },

  // Agents
  getAgents: async (params: {
    search?: string
    health?: string
    status?: string
  } = {}): Promise<BanAgentsListResponse> => {
    const response = await apiClient.get('/cabinet/admin/ban-system/agents', { params })
    return response.data
  },

  getAgentsSummary: async (): Promise<BanAgentsSummary> => {
    const response = await apiClient.get('/cabinet/admin/ban-system/agents/summary')
    return response.data
  },

  // Traffic violations
  getTrafficViolations: async (limit: number = 50): Promise<BanTrafficViolationsResponse> => {
    const response = await apiClient.get('/cabinet/admin/ban-system/traffic/violations', {
      params: { limit }
    })
    return response.data
  },

  // Full Traffic
  getTraffic: async (): Promise<BanTrafficResponse> => {
    const response = await apiClient.get('/cabinet/admin/ban-system/traffic')
    return response.data
  },

  getTrafficTop: async (limit: number = 20): Promise<BanTrafficTopItem[]> => {
    const response = await apiClient.get('/cabinet/admin/ban-system/traffic/top', {
      params: { limit }
    })
    return response.data
  },

  // Settings
  getSettings: async (): Promise<BanSettingsResponse> => {
    const response = await apiClient.get('/cabinet/admin/ban-system/settings')
    return response.data
  },

  getSetting: async (key: string): Promise<BanSettingDefinition> => {
    const response = await apiClient.get(`/cabinet/admin/ban-system/settings/${key}`)
    return response.data
  },

  setSetting: async (key: string, value: string): Promise<BanSettingDefinition> => {
    const response = await apiClient.post(`/cabinet/admin/ban-system/settings/${key}`, null, {
      params: { value }
    })
    return response.data
  },

  toggleSetting: async (key: string): Promise<BanSettingDefinition> => {
    const response = await apiClient.post(`/cabinet/admin/ban-system/settings/${key}/toggle`)
    return response.data
  },

  // Whitelist
  whitelistAdd: async (username: string): Promise<UnbanResponse> => {
    const response = await apiClient.post('/cabinet/admin/ban-system/settings/whitelist/add', { username })
    return response.data
  },

  whitelistRemove: async (username: string): Promise<UnbanResponse> => {
    const response = await apiClient.post('/cabinet/admin/ban-system/settings/whitelist/remove', { username })
    return response.data
  },

  // Reports
  getReport: async (hours: number = 24): Promise<BanReportResponse> => {
    const response = await apiClient.get('/cabinet/admin/ban-system/report', {
      params: { hours }
    })
    return response.data
  },

  // Health
  getHealth: async (): Promise<BanHealthResponse> => {
    const response = await apiClient.get('/cabinet/admin/ban-system/health')
    return response.data
  },

  getHealthDetailed: async (): Promise<BanHealthDetailedResponse> => {
    const response = await apiClient.get('/cabinet/admin/ban-system/health/detailed')
    return response.data
  },

  // Agent History
  getAgentHistory: async (nodeName: string, hours: number = 24): Promise<BanAgentHistoryResponse> => {
    const response = await apiClient.get(`/cabinet/admin/ban-system/agents/${encodeURIComponent(nodeName)}/history`, {
      params: { hours }
    })
    return response.data
  },

  // User Punishment History
  getUserHistory: async (email: string, limit: number = 20): Promise<BanHistoryResponse> => {
    const response = await apiClient.get(`/cabinet/admin/ban-system/users/${encodeURIComponent(email)}/history`, {
      params: { limit }
    })
    return response.data
  },
}