import type { IRouteConfig } from '@push.rocks/smartproxy';

/**
 * A stored remote ingress edge registration.
 */
export interface IRemoteIngress {
  id: string;
  name: string;
  secret: string;
  listenPorts: number[];
  /** UDP listen ports (e.g. for QUIC/HTTP3). Derived from routes with transport 'udp' or 'all'. */
  listenPortsUdp?: number[];
  enabled: boolean;
  /** Whether to auto-derive ports from remoteIngress-tagged routes. Defaults to true. */
  autoDerivePorts: boolean;
  tags?: string[];
  createdAt: number;
  updatedAt: number;
  /** Effective ports (union of manual + derived) — only present in API responses. */
  effectiveListenPorts?: number[];
  /** Ports explicitly set by the user — only present in API responses. */
  manualPorts?: number[];
  /** Ports auto-derived from route configs — only present in API responses. */
  derivedPorts?: number[];
  /** Effective UDP ports (union of manual + derived) — only present in API responses. */
  effectiveListenPortsUdp?: number[];
}

/**
 * Runtime status of a remote ingress edge.
 */
export interface IRemoteIngressStatus {
  edgeId: string;
  connected: boolean;
  publicIp: string | null;
  activeTunnels: number;
  lastHeartbeat: number | null;
  connectedAt: number | null;
  transportMode?: 'tcpTls' | 'quic' | 'quicWithFallback';
  fallbackUsed?: boolean;
  performance?: IRemoteIngressPerformanceEffective;
  flowControl?: IRemoteIngressFlowControlStatus;
  queues?: IRemoteIngressQueueStatus;
  traffic?: IRemoteIngressTrafficStatus;
  udp?: IRemoteIngressUdpStatus;
}

export type TRemoteIngressPerformanceProfile = 'balanced' | 'throughput' | 'highConcurrency';

export interface IRemoteIngressPerformanceConfig {
  profile?: TRemoteIngressPerformanceProfile;
  maxStreamsPerEdge?: number;
  totalWindowBudgetBytes?: number;
  minStreamWindowBytes?: number;
  maxStreamWindowBytes?: number;
  sustainedStreamWindowBytes?: number;
  quicDatagramReceiveBufferBytes?: number;
}

export interface IRemoteIngressPerformanceEffective {
  profile: TRemoteIngressPerformanceProfile;
  maxStreamsPerEdge: number;
  totalWindowBudgetBytes: number;
  minStreamWindowBytes: number;
  maxStreamWindowBytes: number;
  sustainedStreamWindowBytes: number;
  quicDatagramReceiveBufferBytes: number;
}

export interface IRemoteIngressFlowControlStatus {
  applies: boolean;
  currentWindowBytes: number;
  minWindowBytes: number;
  maxWindowBytes: number;
  totalWindowBudgetBytes: number;
  estimatedInFlightBytes: number;
  stalledStreams: number;
}

export interface IRemoteIngressQueueStatus {
  ctrlQueueDepth: number;
  dataQueueDepth: number;
  sustainedQueueDepth: number;
}

export interface IRemoteIngressTrafficStatus {
  bytesIn: number;
  bytesOut: number;
  streamsOpenedTotal: number;
  streamsClosedTotal: number;
  rejectedStreams: number;
}

export interface IRemoteIngressUdpStatus {
  activeSessions: number;
  droppedDatagrams: number;
}

/**
 * Route-level remote ingress configuration.
 * When attached to a route, signals that traffic for this route
 * should be accepted from remote edge nodes.
 */
export interface IRouteRemoteIngress {
  /** Whether this route receives traffic from edge nodes */
  enabled: boolean;
  /** Optional filter: only edges whose id or tags match get this route's ports.
   *  When absent, the route applies to all edges. */
  edgeFilter?: string[];
}

/**
 * Extended route config used within dcrouter.
 * Adds optional `remoteIngress` and `vpnOnly` properties to SmartProxy's IRouteConfig.
 * SmartProxy ignores unknown properties at runtime.
 */
export type IDcRouterRouteConfig = IRouteConfig & {
  remoteIngress?: IRouteRemoteIngress;
  /** When true, only VPN clients whose TargetProfile matches this route get access.
   *  Matching is determined by domain overlap, target overlap, or direct routeRef. */
  vpnOnly?: boolean;
};