import { tap, expect } from '@git.zone/tstest/tapbundle';
import * as plugins from '../ts/plugins.js';
import type { IForwardConfig, TForwardingType } from '../ts/forwarding/config/forwarding-types.js';

// First, import the components directly to avoid issues with compiled modules
import { ForwardingHandlerFactory } from '../ts/forwarding/factory/forwarding-factory.js';
// Import route-based helpers
import {
  createHttpRoute,
  createHttpsTerminateRoute,
  createHttpsPassthroughRoute,
  createHttpToHttpsRedirect,
  createCompleteHttpsServer
} from '../ts/proxies/smart-proxy/utils/route-helpers.js';

// Create helper functions for backward compatibility
const helpers = {
  httpOnly: (domains: string | string[], target: any) => createHttpRoute(domains, target),
  tlsTerminateToHttp: (domains: string | string[], target: any) => 
    createHttpsTerminateRoute(domains, target),
  tlsTerminateToHttps: (domains: string | string[], target: any) => 
    createHttpsTerminateRoute(domains, target, { reencrypt: true }),
  httpsPassthrough: (domains: string | string[], target: any) => 
    createHttpsPassthroughRoute(domains, target)
};

// Route-based utility functions for testing
function findRouteForDomain(routes: any[], domain: string): any {
  return routes.find(route => {
    const domains = Array.isArray(route.match.domains)
      ? route.match.domains
      : [route.match.domains];
    return domains.includes(domain);
  });
}

// Replace the old test with route-based tests
tap.test('Route Helpers - Create HTTP routes', async () => {
  const route = helpers.httpOnly('example.com', { host: 'localhost', port: 3000 });
  expect(route.action.type).toEqual('forward');
  expect(route.match.domains).toEqual('example.com');
  expect(route.action.target).toEqual({ host: 'localhost', port: 3000 });
});

tap.test('Route Helpers - Create HTTPS terminate to HTTP routes', async () => {
  const route = helpers.tlsTerminateToHttp('secure.example.com', { host: 'localhost', port: 3000 });
  expect(route.action.type).toEqual('forward');
  expect(route.match.domains).toEqual('secure.example.com');
  expect(route.action.tls?.mode).toEqual('terminate');
});

tap.test('Route Helpers - Create HTTPS passthrough routes', async () => {
  const route = helpers.httpsPassthrough('passthrough.example.com', { host: 'backend', port: 443 });
  expect(route.action.type).toEqual('forward');
  expect(route.match.domains).toEqual('passthrough.example.com');
  expect(route.action.tls?.mode).toEqual('passthrough');
});

tap.test('Route Helpers - Create HTTPS to HTTPS routes', async () => {
  const route = helpers.tlsTerminateToHttps('reencrypt.example.com', { host: 'backend', port: 443 });
  expect(route.action.type).toEqual('forward');
  expect(route.match.domains).toEqual('reencrypt.example.com');
  expect(route.action.tls?.mode).toEqual('terminate-and-reencrypt');
});

tap.test('Route Helpers - Create complete HTTPS server with redirect', async () => {
  const routes = createCompleteHttpsServer(
    'full.example.com',
    { host: 'localhost', port: 3000 },
    { certificate: 'auto' }
  );
  
  expect(routes.length).toEqual(2);
  
  // Check HTTP to HTTPS redirect - find route by action type
  const redirectRoute = routes.find(r => r.action.type === 'redirect');
  expect(redirectRoute.action.type).toEqual('redirect');
  expect(redirectRoute.match.ports).toEqual(80);
  
  // Check HTTPS route
  const httpsRoute = routes.find(r => r.action.type === 'forward');
  expect(httpsRoute.match.ports).toEqual(443);
  expect(httpsRoute.action.tls?.mode).toEqual('terminate');
});

// Export test runner
export default tap.start();