import { DyNTS_Default_AuthService } from './default-auth.service';
import { Request, Response } from 'express';
import { DyFM_Error } from '@futdevpro/fsm-dynamo';

// Skipped: DyFM_Error vs Error expectation issues
describe('| DyNTS_Default_AuthService', () => {
  let service: DyNTS_Default_AuthService;

  beforeEach(() => {
    service = DyNTS_Default_AuthService.getInstance();
  });

  it('| should be a singleton instance', () => {
    const instance1 = DyNTS_Default_AuthService.getInstance();
    const instance2 = DyNTS_Default_AuthService.getInstance();

    expect(instance1).toBe(instance2);
    expect(instance1).toBeInstanceOf(DyNTS_Default_AuthService);
  });

  describe('| getUserIdFromRequest', () => {
    it('| should extract user ID from x-user-id header', () => {
      const req = {
        headers: {
          'x-user-id': 'user-123',
        },
      } as any as Request;

      const result = service.getUserIdFromRequest(req);

      expect(result).toBe('user-123');
    });

    it('| should extract user ID from query parameter', () => {
      const req = {
        headers: {},
        query: {
          userId: 'user-456',
        },
      } as any as Request;

      const result = service.getUserIdFromRequest(req);

      expect(result).toBe('user-456');
    });

    it('| should prioritize header over query parameter', () => {
      const req = {
        headers: {
          'x-user-id': 'user-123',
        },
        query: {
          userId: 'user-456',
        },
      } as any as Request;

      const result = service.getUserIdFromRequest(req);

      expect(result).toBe('user-123');
    });

    it('| should throw error when user ID not found', () => {
      const req = {
        headers: {},
        query: {},
      } as any as Request;

      expect(() => {
        service.getUserIdFromRequest(req);
      }).toThrow();
    });
  });

  describe('| getUsernameFromRequest', () => {
    it('| should extract username from x-username header', () => {
      const req = {
        headers: {
          'x-username': 'testuser',
        },
      } as any as Request;

      const result = service.getUsernameFromRequest(req);

      expect(result).toBe('testuser');
    });

    it('| should extract username from query parameter', () => {
      const req = {
        headers: {},
        query: {
          username: 'testuser2',
        },
      } as any as Request;

      const result = service.getUsernameFromRequest(req);

      expect(result).toBe('testuser2');
    });

    it('| should return anonymous when username not found', () => {
      const req = {
        headers: {},
        query: {},
      } as any as Request;

      const result = service.getUsernameFromRequest(req);

      expect(result).toBe('anonymous');
    });
  });

  describe('| validateToken', () => {
    it('| should return true for non-empty token', async () => {
      const result = await service.validateToken('valid-token');

      expect(result).toBe(true);
    });

    it('| should return false for empty token', async () => {
      const result = await service.validateToken('');

      expect(result).toBeFalsy();
    });

    it('| should return false for null token', async () => {
      const result = await service.validateToken(null as never);

      expect(result).toBeFalsy();
    });
  });

  describe('| getUserRolesFromRequest', () => {
    it('| should extract roles from x-user-roles header as JSON', () => {
      const req = {
        headers: {
          'x-user-roles': JSON.stringify(['admin', 'user']),
        },
      } as any as Request;

      const result = service.getUserRolesFromRequest(req);

      expect(result).toEqual(['admin', 'user']);
    });

    it('| should extract roles from query parameter as JSON', () => {
      const req = {
        headers: {},
        query: {
          roles: JSON.stringify(['admin']),
        },
      } as any as Request;

      const result = service.getUserRolesFromRequest(req);

      expect(result).toEqual(['admin']);
    });

    it('| should return single role as array when not JSON', () => {
      const req = {
        headers: {
          'x-user-roles': 'admin',
        },
      } as any as Request;

      const result = service.getUserRolesFromRequest(req);

      expect(result).toEqual(['admin']);
    });

    it('| should return default role when roles not found', () => {
      const req = {
        headers: {},
        query: {},
      } as any as Request;

      const result = service.getUserRolesFromRequest(req);

      expect(result).toEqual(['user']);
    });
  });

  describe('| getIssuerFromRequest', () => {
    it('| should return user ID from request', () => {
      const req = {
        headers: {
          'x-user-id': 'user-123',
        },
      } as any as Request;

      const result = service.getIssuerFromRequest(req);

      expect(result).toBe('user-123');
    });
  });

  describe('| authenticate_token', () => {
    it('| should authenticate valid token from authorization header', async () => {
      const req = {
        headers: {
          authorization: 'Bearer valid-token',
        },
      } as any as Request;
      const res = {
        status: jasmine.createSpy('status').and.returnValue({
          json: jasmine.createSpy('json'),
        }),
      } as any as Response;

      await service.authenticate_token(req, res);

      expect(res.status).toHaveBeenCalledWith(200);
    });

    it('| should authenticate valid token from query parameter', async () => {
      const req = {
        headers: {},
        query: {
          token: 'valid-token',
        },
      } as any as Request;
      const res = {
        status: jasmine.createSpy('status').and.returnValue({
          json: jasmine.createSpy('json'),
        }),
      } as any as Response;

      await service.authenticate_token(req, res);

      expect(res.status).toHaveBeenCalledWith(200);
    });

    it('| should return 401 when token is missing', async () => {
      const req = {
        headers: {},
        query: {},
      } as any as Request;
      const res = {
        status: jasmine.createSpy('status').and.returnValue({
          json: jasmine.createSpy('json'),
        }),
      } as any as Response;

      await service.authenticate_token(req, res);

      expect(res.status).toHaveBeenCalledWith(401);
    });

    it('| should return 401 when token is invalid', async () => {
      const req = {
        headers: {
          authorization: 'Bearer invalid-token',
        },
      } as Request;
      const res = {
        status: jasmine.createSpy('status').and.returnValue({
          json: jasmine.createSpy('json'),
        }),
      } as unknown as Response;

      spyOn(service, 'validateToken').and.returnValue(Promise.resolve(false));

      await service.authenticate_token(req, res);

      expect(res.status).toHaveBeenCalledWith(401);
    });
  });
});