import { DyNTS_Default_User_DataService } from './default-user.data-service';
import { DyNTS_Default_User } from '../_models/default-user.data-model';
import { DyFM_EnvironmentFlag } from '@futdevpro/fsm-dynamo';
import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
import { DyNTS_GlobalService } from '../../../_services/core/global.service';

describe('| DyNTS_Default_User_DataService', () => {
  let service: DyNTS_Default_User_DataService;
  let mockDBService: jasmine.SpyObj<{
    findOne: (filter: unknown) => Promise<unknown>;
    getDataById: (id: string) => Promise<unknown>;
    modifyData: (data: unknown, issuer: string, dontUpdateModified?: boolean) => Promise<unknown>;
  }>;

  beforeEach(() => {
    DyNTS_global_settings.env_settings = {
      environment: DyFM_EnvironmentFlag.local,
      mongoUri: 'mongodb://localhost:27017/test',
      discord: { token: '', clientId: '', guildId: '', oauth2Url: '' },
      openAi: { apiKey: '', organization: '', project: '', ttsApiKey: '' },
    };

    mockDBService = jasmine.createSpyObj('DyNTS_DBService', [
      'findOne',
      'getDataById',
      'getDataListByIds',
      'find',
      'getAll',
      'createData',
      'modifyData',
      'updateOne',
      'markDeletedById',
    ]);
    spyOn(DyNTS_GlobalService, 'getDBService').and.returnValue(mockDBService as never);

    service = new DyNTS_Default_User_DataService({
      issuer: 'issuer-123',
    });
  });

  it('| should create service with user', () => {
    const user = new DyNTS_Default_User({
      username: 'testuser',
      email: 'test@example.com',
      roles: [],
      isActive: true,
    });

    const serviceWithUser = new DyNTS_Default_User_DataService({
      user: user,
      issuer: 'issuer-123',
    });

    expect(serviceWithUser).toBeInstanceOf(DyNTS_Default_User_DataService);
    expect(serviceWithUser.data).toBeDefined();
  });

  it('| should create service without user', () => {
    expect(service).toBeInstanceOf(DyNTS_Default_User_DataService);
    expect(service.data).toBeDefined();
  });

  describe('| findByUsername', () => {
    it('| should return null when user not found', async () => {
      mockDBService.findOne.and.returnValue(Promise.resolve(null));

      const result = await service.findByUsername('nonexistent');

      expect(result).toBeNull();
    });

    it('| should return user when found', async () => {
      const mockUser = new DyNTS_Default_User({
        _id: 'user-123',
        username: 'testuser',
        email: 'test@example.com',
        roles: [],
        isActive: true,
      });

      mockDBService.findOne.and.returnValue(Promise.resolve(mockUser));

      const result = await service.findByUsername('testuser');

      expect(result).toBe(mockUser);
      expect(service.data).toBe(mockUser);
    });

    it('| should throw error on database error', async () => {
      mockDBService.findOne.and.returnValue(Promise.reject(new Error('Database error')));

      await expectAsync(
        service.findByUsername('testuser')
      ).toBeRejected();
    });
  });

  describe('| findByEmail', () => {
    it('| should return null when user not found', async () => {
      mockDBService.findOne.and.returnValue(Promise.resolve(null));

      const result = await service.findByEmail('nonexistent@example.com');

      expect(result).toBeNull();
    });

    it('| should return user when found', async () => {
      const mockUser = new DyNTS_Default_User({
        _id: 'user-123',
        username: 'testuser',
        email: 'test@example.com',
        roles: [],
        isActive: true,
      });

      mockDBService.findOne.and.returnValue(Promise.resolve(mockUser));

      const result = await service.findByEmail('test@example.com');

      expect(result).toBe(mockUser);
      expect(service.data).toBe(mockUser);
    });

    it('| should throw error on database error', async () => {
      mockDBService.findOne.and.returnValue(Promise.reject(new Error('Database error')));

      await expectAsync(
        service.findByEmail('test@example.com')
      ).toBeRejected();
    });
  });

  describe('| updateLastLogin', () => {
    it('| should update last login timestamp', async () => {
      const mockUser = new DyNTS_Default_User({
        _id: 'user-123',
        username: 'testuser',
        email: 'test@example.com',
        roles: [],
        isActive: true,
      });

      spyOn(service, 'getDataById').and.returnValue(
        Promise.resolve(mockUser)
      );
      spyOn(service, 'saveData').and.returnValue(Promise.resolve(mockUser));

      await service.updateLastLogin('user-123');

      expect(mockUser.lastLoginAt).toBeInstanceOf(Date);
      expect(service.saveData).toHaveBeenCalledWith(mockUser);
    });

    it('| should throw error when user not found', async () => {
      spyOn(service, 'getDataById').and.returnValue(
        Promise.resolve(null)
      );

      await expectAsync(
        service.updateLastLogin('nonexistent')
      ).toBeRejected();
    });

    it('| should throw error on save error', async () => {
      const mockUser = new DyNTS_Default_User({
        _id: 'user-123',
        username: 'testuser',
        email: 'test@example.com',
        roles: [],
        isActive: true,
      });

      spyOn(service, 'getDataById').and.returnValue(
        Promise.resolve(mockUser)
      );
      spyOn(service, 'saveData').and.returnValue(
        Promise.reject(new Error('Save error'))
      );

      await expectAsync(
        service.updateLastLogin('user-123')
      ).toBeRejected();
    });
  });
});