import { describe, expect, it } from 'vitest';
import jwt from 'jsonwebtoken';
import { loadAppConfig, parseJwtExpiresIn } from './app.config.js';

describe('loadAppConfig', () => {
  const validEnv = {
    NODE_ENV: 'development',
    DATABASE_URL: 'postgresql://user:pass@localhost:5432/crm',
    JWT_SECRET: 'x'.repeat(32),
    JWT_EXPIRES_IN: '1d',
    PORT: '3000',
    HOST: '127.0.0.1',
    FRONTEND_URL: 'http://127.0.0.1:5173',
    ALLOW_PUBLIC_REGISTRATION: 'false',
  };

  it('loads valid configuration', () => {
    const config = loadAppConfig(validEnv);
    expect(config.jwtSecret).toHaveLength(32);
    expect(config.allowPublicRegistration).toBe(false);
    expect(config.port).toBe(3000);
  });

  it('fails when JWT_SECRET is missing', () => {
    const { JWT_SECRET: _, ...env } = validEnv;
    expect(() => loadAppConfig(env)).toThrow(/JWT_SECRET/);
  });

  it('fails when JWT_SECRET is too short', () => {
    expect(() =>
      loadAppConfig({ ...validEnv, JWT_SECRET: 'too-short' }),
    ).toThrow(/at least 32/);
  });

  it('fails when DATABASE_URL is missing', () => {
    const { DATABASE_URL: _, ...env } = validEnv;
    expect(() => loadAppConfig(env)).toThrow(/DATABASE_URL/);
  });

  it('defaults allowPublicRegistration to false', () => {
    const { ALLOW_PUBLIC_REGISTRATION: _, ...env } = validEnv;
    expect(loadAppConfig(env).allowPublicRegistration).toBe(false);
  });

  it('parses JWT_EXPIRES_IN timespan for JwtModule/jsonwebtoken', () => {
    const config = loadAppConfig(validEnv);
    expect(config.jwtExpiresIn).toBe('1d');

    const token = jwt.sign({ sub: 'user-1' }, config.jwtSecret, {
      expiresIn: config.jwtExpiresIn,
    });
    const decoded = jwt.decode(token) as { exp?: number; iat?: number };
    expect(decoded.exp).toBeDefined();
    expect(decoded.iat).toBeDefined();
    expect((decoded.exp as number) - (decoded.iat as number)).toBe(86_400);
  });

  it('accepts quoted JWT_EXPIRES_IN values from env files', () => {
    const config = loadAppConfig({
      ...validEnv,
      JWT_EXPIRES_IN: '"1d"',
    });
    expect(config.jwtExpiresIn).toBe('1d');
    expect(() =>
      jwt.sign({ sub: 'user-1' }, config.jwtSecret, {
        expiresIn: config.jwtExpiresIn,
      }),
    ).not.toThrow();
  });

  it('parses numeric JWT_EXPIRES_IN as seconds', () => {
    const config = loadAppConfig({
      ...validEnv,
      JWT_EXPIRES_IN: '3600',
    });
    expect(config.jwtExpiresIn).toBe(3600);
  });

  it('defaults JWT_EXPIRES_IN when unset', () => {
    const { JWT_EXPIRES_IN: _, ...env } = validEnv;
    expect(loadAppConfig(env).jwtExpiresIn).toBe('1d');
  });

  it('rejects invalid JWT_EXPIRES_IN', () => {
    expect(() =>
      loadAppConfig({ ...validEnv, JWT_EXPIRES_IN: 'not-a-timespan' }),
    ).toThrow(/JWT_EXPIRES_IN/);
  });
});

describe('parseJwtExpiresIn', () => {
  it('returns timespan strings accepted by jsonwebtoken', () => {
    expect(parseJwtExpiresIn('20h')).toBe('20h');
    expect(parseJwtExpiresIn("'7d'")).toBe('7d');
  });

  it('returns positive integer seconds as numbers', () => {
    expect(parseJwtExpiresIn('60')).toBe(60);
  });
});
