import { expect, tap } from '@git.zone/tstest/tapbundle';
import { MetricsManager } from '../ts/monitoring/classes.metricsmanager.js';

const emptyProtocolDistribution = {
  h1Active: 0,
  h1Total: 0,
  h2Active: 0,
  h2Total: 0,
  h3Active: 0,
  h3Total: 0,
  wsActive: 0,
  wsTotal: 0,
  otherActive: 0,
  otherTotal: 0,
};

function createProxyMetrics(args: {
  connectionsByRoute: Map<string, number>;
  throughputByRoute: Map<string, { in: number; out: number }>;
  domainRequestsByIP: Map<string, Map<string, number>>;
  requestsTotal?: number;
}) {
  return {
    connections: {
      active: () => 0,
      total: () => 0,
      byRoute: () => args.connectionsByRoute,
      byIP: () => new Map<string, number>(),
      topIPs: () => [],
      domainRequestsByIP: () => args.domainRequestsByIP,
      topDomainRequests: () => [],
      frontendProtocols: () => emptyProtocolDistribution,
      backendProtocols: () => emptyProtocolDistribution,
    },
    throughput: {
      instant: () => ({ in: 0, out: 0 }),
      recent: () => ({ in: 0, out: 0 }),
      average: () => ({ in: 0, out: 0 }),
      custom: () => ({ in: 0, out: 0 }),
      history: () => [],
      byRoute: () => args.throughputByRoute,
      byIP: () => new Map<string, { in: number; out: number }>(),
    },
    requests: {
      perSecond: () => 0,
      perMinute: () => 0,
      total: () => args.requestsTotal || 0,
    },
    totals: {
      bytesIn: () => 0,
      bytesOut: () => 0,
      connections: () => 0,
    },
    backends: {
      byBackend: () => new Map<string, any>(),
      protocols: () => new Map<string, string>(),
      topByErrors: () => [],
      detectedProtocols: () => [],
    },
  };
}

tap.test('MetricsManager joins domain activity to id-keyed route metrics', async () => {
  const proxyMetrics = createProxyMetrics({
    connectionsByRoute: new Map([
      ['route-id-only', 4],
    ]),
    throughputByRoute: new Map([
      ['route-id-only', { in: 1200, out: 2400 }],
    ]),
    domainRequestsByIP: new Map([
      ['192.0.2.10', new Map([
        ['alpha.example.com', 3],
        ['beta.example.com', 1],
      ])],
    ]),
    requestsTotal: 4,
  });

  const smartProxy = {
    getMetrics: () => proxyMetrics,
    routeManager: {
      getRoutes: () => [
        {
          id: 'route-id-only',
          match: {
            ports: [443],
            domains: ['alpha.example.com', 'beta.example.com'],
          },
          action: {
            type: 'forward',
            targets: [{ host: '127.0.0.1', port: 8443 }],
          },
        },
      ],
    },
  };

  const manager = new MetricsManager({ smartProxy } as any);
  const stats = await manager.getNetworkStats();
  const alpha = stats.domainActivity.find((item) => item.domain === 'alpha.example.com');
  const beta = stats.domainActivity.find((item) => item.domain === 'beta.example.com');

  expect(alpha).toBeDefined();
  expect(beta).toBeDefined();

  expect(alpha!.requestCount).toEqual(3);
  expect(alpha!.routeCount).toEqual(1);
  expect(alpha!.activeConnections).toEqual(3);
  expect(alpha!.bytesInPerSecond).toEqual(900);
  expect(alpha!.bytesOutPerSecond).toEqual(1800);

  expect(beta!.requestCount).toEqual(1);
  expect(beta!.routeCount).toEqual(1);
  expect(beta!.activeConnections).toEqual(1);
  expect(beta!.bytesInPerSecond).toEqual(300);
  expect(beta!.bytesOutPerSecond).toEqual(600);
});

export default tap.start();