import type { ConnectionConfig, QueryResult } from "@/types/database";
import { effectiveDatabaseTypeForConnection } from "@/lib/database/jdbcDialect";

export interface XuguClusterNode {
  nodeId: string;
  rackNo: string;
  host: string;
  port: string;
  nodeType: string;
  state: string;
  cpuLoad: string;
  bootTime: string;
  storeCount: string;
  majorCount: string;
}

export interface XuguRunInfo {
  nodeId: string;
  activeTransactions: string;
  diskReadCount: string;
  diskReadBytes: string;
  diskWriteCount: string;
  diskWriteBytes: string;
  maxTransactionId: string;
  minTransactionId: string;
  xlogWritePosition: string;
  xlogCheckpointPosition: string;
  freeStores: string;
}

export interface XuguSessionSummary {
  nodeId: string;
  sessions: string;
  activeSessions: string;
  memoryBytes: string;
  oldestStatement: string;
}

export interface XuguTransactionSummary {
  nodeId: string;
  activeTransactions: string;
  oldestTransaction: string;
}

export interface XuguMemoryStatus {
  nodeId: string;
  bufferTotalBytes: string;
  bufferFreeBytes: string;
  bufferDirtyBytes: string;
  bufferLruBytes: string;
  sgaTotalBytes: string;
  sgaFreeBytes: string;
  sgaPeakBytes: string;
  swapTotalBytes: string;
  swapFreeBytes: string;
}

export interface XuguSessionStatusSummary {
  nodeId: string;
  status: string;
  sessions: string;
}

export interface XuguLockModeSummary {
  nodeId: string;
  lockMode: string;
  locks: string;
}

export interface XuguTablespaceSummary {
  nodeId: string;
  spaceName: string;
  spaceType: string;
  datafiles: string;
  mediaError: string;
  totalBytes: string;
  freeBytes: string;
}

export const XUGU_VERSION_SQL = "SELECT VERSION() AS VERSION FROM DUAL;";

export const XUGU_CLUSTER_NODES_SQL = `
SELECT
  NODE_ID,
  RACK_NO,
  NODE_IP,
  NODE_PORT,
  NODE_TYPE,
  NODE_STATE,
  CPU_LOAD,
  BOOT_TIME,
  STORE_NUM,
  MAJOR_NUM
FROM SYS_CLUSTERS
ORDER BY NODE_ID;`.trim();

export const XUGU_RUN_INFO_SQL = `
SELECT
  NODEID,
  ACT_TRANS_NUM,
  DISK_R_N,
  DISK_R_BYTES,
  DISK_W_N,
  DISK_W_BYTES,
  MAX_TRANS_ID,
  MIN_TRANS_ID,
  XLOG_WPOS,
  XLOG_CKPT,
  FREE_STO_N
FROM SYS_ALL_RUN_INFO
ORDER BY NODEID;`.trim();

/** Per-node session totals. This is optional because restricted users may not see SYS_ALL_SESSIONS. */
export const XUGU_SESSION_SUMMARY_SQL = `
SELECT NODEID AS NODE_ID,
       COUNT(*) AS SESSIONS,
       SUM(MEM_SIZE) AS MEMORY_BYTES
FROM SYS_ALL_SESSIONS
GROUP BY NODEID
ORDER BY NODEID;`.trim();

/** The thread-session view is the Xugu-specific definition of an active statement. */
export const XUGU_ACTIVE_SESSION_SQL = `
SELECT T.NODEID AS NODE_ID,
       COUNT(*) AS ACTIVE_SESSIONS,
       MIN(S.CMD_START_T) AS OLDEST_STATEMENT
FROM SYS_ALL_THD_SESSION T
JOIN SYS_ALL_SESSIONS S
  ON T.NODEID = S.NODEID AND T.SESSION_ID = S.SESSION_ID
GROUP BY T.NODEID
ORDER BY T.NODEID;`.trim();

export const XUGU_TRANSACTION_SUMMARY_SQL = `
SELECT NODEID AS NODE_ID,
       COUNT(*) AS ACTIVE_TRANSACTIONS,
       MIN(START_T) AS OLDEST_TRANSACTION
FROM SYS_ALL_TRANS
GROUP BY NODEID
ORDER BY NODEID;`.trim();

/** Only table-level lock waiters are exposed by SYS_ALL_LWAITERS. */
export const XUGU_LOCK_WAITS_SQL = `
SELECT
  (SELECT COUNT(*) FROM SYS_ALL_LWAITERS) AS LOCK_WAITS,
  (SELECT COUNT(*) FROM SYS_ALL_LOWNERS) AS LOCK_OWNERS
FROM DUAL;`.trim();

export const XUGU_LOCK_MODE_SUMMARY_SQL = `
SELECT NODEID AS NODE_ID,
       LOCK_LEVEL AS LOCK_MODE,
       COUNT(*) AS LOCKS
FROM SYS_ALL_LOWNERS
GROUP BY NODEID, LOCK_LEVEL
ORDER BY NODEID, LOCK_LEVEL;`.trim();

export const XUGU_SESSION_STATUS_SUMMARY_SQL = `
SELECT NODEID AS NODE_ID,
       STATUS,
       COUNT(*) AS SESSIONS
FROM SYS_ALL_SESSIONS
GROUP BY NODEID, STATUS
ORDER BY NODEID, STATUS;`.trim();

export const XUGU_MEMORY_STATUS_SQL = `
SELECT
  NODEID,
  BUFF_SIZE * TOTAL_BUFF_NUM AS BUFFER_TOTAL_BYTES,
  BUFF_SIZE * FREE_BUFF_NUM AS BUFFER_FREE_BYTES,
  BUFF_SIZE * DIRTY_BUFF_NUM AS BUFFER_DIRTY_BYTES,
  BUFF_SIZE * LRU_BUFF_NUM AS BUFFER_LRU_BYTES,
  SGA_BLK_SIZE * TOTAL_SGA_MEM AS SGA_TOTAL_BYTES,
  SGA_BLK_SIZE * FREE_SGA_MEM AS SGA_FREE_BYTES,
  SGA_BLK_SIZE * PEAK_SGA_MEM AS SGA_PEAK_BYTES,
  SWAP_BLK_SIZE * TOTAL_SWAP_MEM AS SWAP_TOTAL_BYTES,
  SWAP_BLK_SIZE * FREE_SWAP_MEM AS SWAP_FREE_BYTES
FROM SYS_ALL_MEM_STATUS
ORDER BY NODEID;`.trim();

export const XUGU_TABLESPACE_SUMMARY_SQL = `
SELECT
  T.NODEID AS NODE_ID,
  T.SPACE_NAME,
  T.SPACE_TYPE,
  T.DATAFILE_NUM AS DATAFILES,
  T.MEDIA_ERROR,
  T.TOTAL_CHUNK_NUM * C.CHUNK_SIZE AS TOTAL_BYTES,
  T.FREE_CHUNK_NUM * C.CHUNK_SIZE AS FREE_BYTES
FROM SYS_ALL_TABLESPACES T, SYS_CTL_VARS C
ORDER BY T.NODEID, T.SPACE_NAME;`.trim();

export function connectionSupportsXuguServerDashboard(connection: ConnectionConfig | undefined): boolean {
  return !!connection && effectiveDatabaseTypeForConnection(connection) === "xugu";
}

export function xuguClusterNodeStateLabel(state: string): "joining" | "running" | "error" | "offline" | "unknown" {
  switch (Number(state)) {
    case 1:
      return "joining";
    case 2:
      return "running";
    case 3:
      return "error";
    case 4:
      return "offline";
    default:
      return "unknown";
  }
}

export type XuguClusterNodeRole = "master" | "standby" | "storage" | "query" | "worker" | "change";

export function xuguClusterNodeTypeLabels(type: string): XuguClusterNodeRole[] {
  const value = Number(type);
  if (!Number.isFinite(value) || value <= 0) return [];
  const roles: Array<[number, XuguClusterNodeRole]> = [
    [1, "master"],
    [2, "standby"],
    [4, "storage"],
    [8, "query"],
    [16, "worker"],
    [32, "change"],
  ];
  return roles.filter(([bit]) => (value & bit) === bit).map(([, role]) => role);
}

export function xuguClusterNodesFromResult(result: QueryResult): XuguClusterNode[] {
  return result.rows.map((row) => ({
    nodeId: valueAt(result, row, "NODE_ID"),
    rackNo: valueAt(result, row, "RACK_NO"),
    host: valueAt(result, row, "NODE_IP"),
    port: valueAt(result, row, "NODE_PORT"),
    nodeType: valueAt(result, row, "NODE_TYPE"),
    state: valueAt(result, row, "NODE_STATE"),
    cpuLoad: valueAt(result, row, "CPU_LOAD"),
    bootTime: valueAt(result, row, "BOOT_TIME"),
    storeCount: valueAt(result, row, "STORE_NUM"),
    majorCount: valueAt(result, row, "MAJOR_NUM"),
  }));
}

export function xuguRunInfoFromResult(result: QueryResult): XuguRunInfo[] {
  return result.rows.map((row) => ({
    nodeId: valueAt(result, row, "NODEID"),
    activeTransactions: valueAt(result, row, "ACT_TRANS_NUM"),
    diskReadCount: valueAt(result, row, "DISK_R_N"),
    diskReadBytes: valueAt(result, row, "DISK_R_BYTES"),
    diskWriteCount: valueAt(result, row, "DISK_W_N"),
    diskWriteBytes: valueAt(result, row, "DISK_W_BYTES"),
    maxTransactionId: valueAt(result, row, "MAX_TRANS_ID"),
    minTransactionId: valueAt(result, row, "MIN_TRANS_ID"),
    xlogWritePosition: valueAt(result, row, "XLOG_WPOS"),
    xlogCheckpointPosition: valueAt(result, row, "XLOG_CKPT"),
    freeStores: valueAt(result, row, "FREE_STO_N"),
  }));
}

export function xuguSessionSummaryFromResult(result: QueryResult): XuguSessionSummary[] {
  return result.rows.map((row) => ({
    nodeId: valueAt(result, row, "NODE_ID"),
    sessions: valueAt(result, row, "SESSIONS"),
    activeSessions: valueAt(result, row, "ACTIVE_SESSIONS"),
    memoryBytes: valueAt(result, row, "MEMORY_BYTES"),
    oldestStatement: valueAt(result, row, "OLDEST_STATEMENT"),
  }));
}

export function xuguTransactionSummaryFromResult(result: QueryResult): XuguTransactionSummary[] {
  return result.rows.map((row) => ({
    nodeId: valueAt(result, row, "NODE_ID"),
    activeTransactions: valueAt(result, row, "ACTIVE_TRANSACTIONS"),
    oldestTransaction: valueAt(result, row, "OLDEST_TRANSACTION"),
  }));
}

export function xuguMemoryStatusFromResult(result: QueryResult): XuguMemoryStatus[] {
  return result.rows.map((row) => ({
    nodeId: valueAt(result, row, "NODEID"),
    bufferTotalBytes: valueAt(result, row, "BUFFER_TOTAL_BYTES"),
    bufferFreeBytes: valueAt(result, row, "BUFFER_FREE_BYTES"),
    bufferDirtyBytes: valueAt(result, row, "BUFFER_DIRTY_BYTES"),
    bufferLruBytes: valueAt(result, row, "BUFFER_LRU_BYTES"),
    sgaTotalBytes: valueAt(result, row, "SGA_TOTAL_BYTES"),
    sgaFreeBytes: valueAt(result, row, "SGA_FREE_BYTES"),
    sgaPeakBytes: valueAt(result, row, "SGA_PEAK_BYTES"),
    swapTotalBytes: valueAt(result, row, "SWAP_TOTAL_BYTES"),
    swapFreeBytes: valueAt(result, row, "SWAP_FREE_BYTES"),
  }));
}

export function xuguSessionStatusSummaryFromResult(result: QueryResult): XuguSessionStatusSummary[] {
  return result.rows.map((row) => ({
    nodeId: valueAt(result, row, "NODE_ID"),
    status: valueAt(result, row, "STATUS"),
    sessions: valueAt(result, row, "SESSIONS"),
  }));
}

export function xuguLockModeSummaryFromResult(result: QueryResult): XuguLockModeSummary[] {
  return result.rows.map((row) => ({
    nodeId: valueAt(result, row, "NODE_ID"),
    lockMode: valueAt(result, row, "LOCK_MODE"),
    locks: valueAt(result, row, "LOCKS"),
  }));
}

export function xuguTablespaceSummaryFromResult(result: QueryResult): XuguTablespaceSummary[] {
  return result.rows.map((row) => ({
    nodeId: valueAt(result, row, "NODE_ID"),
    spaceName: valueAt(result, row, "SPACE_NAME"),
    spaceType: valueAt(result, row, "SPACE_TYPE"),
    datafiles: valueAt(result, row, "DATAFILES"),
    mediaError: valueAt(result, row, "MEDIA_ERROR"),
    totalBytes: valueAt(result, row, "TOTAL_BYTES"),
    freeBytes: valueAt(result, row, "FREE_BYTES"),
  }));
}

export function xuguScalarFromResult(result: QueryResult, column: string): string {
  return result.rows.length > 0 ? valueAt(result, result.rows[0], column) : "";
}

export function xuguVersionFromResult(result: QueryResult): string {
  return xuguScalarFromResult(result, "VERSION");
}

function valueAt(result: QueryResult, row: unknown[], column: string): string {
  const index = result.columns.findIndex((candidate) => candidate.toUpperCase() === column.toUpperCase());
  return index < 0 || row[index] == null ? "" : String(row[index]);
}