import { DyFM_EnvironmentFlag } from '@futdevpro/fsm-dynamo';

import { DyNTS_createSecurityHeadersMiddleware, DyNTS_resolveSecurityHeaders } from './security-headers.util';
import { DyNTS_SecurityHeaders_Settings } from '../_models/interfaces/security-headers-settings.interface';

describe('DyNTS_resolveSecurityHeaders', () => {
  // AAA: Arrange-Act-Assert

  it('| defaults: pontosan a safe-készlet (3 header), HSTS NÉLKÜL test env-en', () => {
    const headers = DyNTS_resolveSecurityHeaders({ enabled: true }, DyFM_EnvironmentFlag.test);

    expect(headers['X-Frame-Options']).toBe('SAMEORIGIN');
    expect(headers['X-Content-Type-Options']).toBe('nosniff');
    expect(headers['Referrer-Policy']).toBe('strict-origin-when-cross-origin');
    expect(headers['Strict-Transport-Security']).toBeUndefined();
    expect(headers['Content-Security-Policy']).toBeUndefined();
    expect(Object.keys(headers).length).toBe(3);
  });

  it('| prod env → HSTS AUTO-on a default max-age + includeSubDomains értékkel', () => {
    const headers = DyNTS_resolveSecurityHeaders({ enabled: true }, DyFM_EnvironmentFlag.prod);

    expect(headers['Strict-Transport-Security']).toBe('max-age=15768000; includeSubDomains');
  });

  it('| explicit hsts.enabled=true → HSTS test env-en IS (+preload flag)', () => {
    const headers = DyNTS_resolveSecurityHeaders(
      { enabled: true, hsts: { enabled: true, maxAgeSeconds: 300, includeSubDomains: false, preload: true } },
      DyFM_EnvironmentFlag.test,
    );

    expect(headers['Strict-Transport-Security']).toBe('max-age=300; preload');
  });

  it('| hsts: false → prod-on SINCS HSTS', () => {
    const headers = DyNTS_resolveSecurityHeaders({ enabled: true, hsts: false }, DyFM_EnvironmentFlag.prod);

    expect(headers['Strict-Transport-Security']).toBeUndefined();
  });

  it('| csp string → Content-Security-Policy; cspReportOnly → Report-Only header-név', () => {
    const csp: string = "default-src 'self'";
    const normal = DyNTS_resolveSecurityHeaders({ enabled: true, csp: csp }, DyFM_EnvironmentFlag.test);
    const reportOnly = DyNTS_resolveSecurityHeaders(
      { enabled: true, csp: csp, cspReportOnly: true },
      DyFM_EnvironmentFlag.test,
    );

    expect(normal['Content-Security-Policy']).toBe(csp);
    expect(reportOnly['Content-Security-Policy']).toBeUndefined();
    expect(reportOnly['Content-Security-Policy-Report-Only']).toBe(csp);
  });

  it('| per-header false → kimarad; permissionsPolicy opt-in string → jelen', () => {
    const headers = DyNTS_resolveSecurityHeaders(
      { enabled: true, frameOptions: false, referrerPolicy: false, permissionsPolicy: 'camera=()' },
      DyFM_EnvironmentFlag.test,
    );

    expect(headers['X-Frame-Options']).toBeUndefined();
    expect(headers['Referrer-Policy']).toBeUndefined();
    expect(headers['Permissions-Policy']).toBe('camera=()');
    expect(headers['X-Content-Type-Options']).toBe('nosniff');
  });

  it('| additionalHeaders merge (felülírással)', () => {
    const headers = DyNTS_resolveSecurityHeaders(
      { enabled: true, additionalHeaders: { 'X-Custom': 'v1', 'X-Frame-Options': 'DENY' } },
      DyFM_EnvironmentFlag.test,
    );

    expect(headers['X-Custom']).toBe('v1');
    expect(headers['X-Frame-Options']).toBe('DENY');
  });

  it('| enabled: false → üres map', () => {
    const headers = DyNTS_resolveSecurityHeaders({ enabled: false, csp: 'x' }, DyFM_EnvironmentFlag.prod);

    expect(Object.keys(headers).length).toBe(0);
  });
});

describe('DyNTS_createSecurityHeadersMiddleware', () => {
  it('| a middleware minden resolvelt headert setHeader-öl és next()-et hív', () => {
    const settings: DyNTS_SecurityHeaders_Settings = { enabled: true };
    const middleware = DyNTS_createSecurityHeadersMiddleware(settings, DyFM_EnvironmentFlag.test);

    const setHeaderCalls: [string, string][] = [];
    const res: any = { setHeader: (k: string, v: string): void => { setHeaderCalls.push([k, v]); } };
    let nextCalled: boolean = false;

    middleware({} as any, res, ((): void => { nextCalled = true; }) as any);

    expect(nextCalled).toBe(true);
    expect(setHeaderCalls.length).toBe(3);
    expect(setHeaderCalls.map((c: [string, string]): string => c[0])).toContain('X-Frame-Options');
  });
});