import {
  ConflictException,
  NotFoundException,
} from '@nestjs/common';
import { Test, TestingModule } from '@nestjs/testing';
import { beforeEach, describe, expect, it, vi } from 'vitest';
import { AuthService } from '../auth/auth.service.js';
import type { SafeUser } from '../auth/types/auth.types.js';
import { PrismaService } from '../prisma/prisma.service.js';
import { UsersService } from './users.service.js';

describe('UsersService', () => {
  let service: UsersService;
  let prisma: {
    db: {
      orm: {
        public: {
          User: {
            select: ReturnType<typeof vi.fn>;
            where: ReturnType<typeof vi.fn>;
            aggregate: ReturnType<typeof vi.fn>;
          };
        };
      };
    };
  };
  let authService: { createUser: ReturnType<typeof vi.fn> };

  const admin: SafeUser = {
    id: 'admin-1',
    firstName: 'Admin',
    lastName: 'User',
    email: 'admin@example.com',
    role: 'ADMIN',
    isActive: true,
    createdAt: new Date('2026-01-01T00:00:00.000Z'),
    updatedAt: new Date('2026-01-01T00:00:00.000Z'),
  };

  const sales: SafeUser = {
    id: 'sales-1',
    firstName: 'Sales',
    lastName: 'User',
    email: 'sales@example.com',
    role: 'SALES_USER',
    isActive: true,
    createdAt: new Date('2026-01-01T00:00:00.000Z'),
    updatedAt: new Date('2026-01-01T00:00:00.000Z'),
  };

  beforeEach(async () => {
    vi.clearAllMocks();

    prisma = {
      db: {
        orm: {
          public: {
            User: {
              select: vi.fn(),
              where: vi.fn(),
              aggregate: vi.fn(),
            },
          },
        },
      },
    };

    authService = {
      createUser: vi.fn().mockResolvedValue(sales),
    };

    const module: TestingModule = await Test.createTestingModule({
      providers: [
        UsersService,
        { provide: PrismaService, useValue: prisma },
        { provide: AuthService, useValue: authService },
      ],
    }).compile();

    service = module.get(UsersService);
  });

  it('lists all users for admin with pagination', async () => {
    prisma.db.orm.public.User.aggregate.mockResolvedValue({ total: 2 });
    prisma.db.orm.public.User.select.mockReturnValue({
      orderBy: vi.fn().mockReturnValue({
        limit: vi.fn().mockReturnValue({
          offset: vi.fn().mockReturnValue({
            all: vi.fn().mockResolvedValue([admin, sales]),
          }),
        }),
      }),
    });

    const result = await service.findAll({ page: 1, limit: 20 });

    expect(result).toEqual({
      data: [admin, sales],
      meta: { total: 2, page: 1, limit: 20, totalPages: 1 },
    });
  });

  it('lists only active users for assignees', async () => {
    const aggregate = vi.fn().mockResolvedValue({ total: 1 });
    prisma.db.orm.public.User.where.mockReturnValue({ aggregate });
    prisma.db.orm.public.User.select.mockReturnValue({
      where: vi.fn().mockReturnValue({
        orderBy: vi.fn().mockReturnValue({
          limit: vi.fn().mockReturnValue({
            offset: vi.fn().mockReturnValue({
              all: vi.fn().mockResolvedValue([sales]),
            }),
          }),
        }),
      }),
    });

    const result = await service.listAssignees({ page: 1, limit: 20 });
    expect(result.data).toEqual([sales]);
    expect(prisma.db.orm.public.User.where).toHaveBeenCalled();
  });

  it('gets a user by id', async () => {
    prisma.db.orm.public.User.select.mockReturnValue({
      where: vi.fn().mockReturnValue({
        first: vi.fn().mockResolvedValue(sales),
      }),
    });

    await expect(service.findOne(sales.id)).resolves.toEqual(sales);
  });

  it('creates a user through auth provisioning', async () => {
    await service.create({
      firstName: 'Sales',
      lastName: 'User',
      email: 'sales@example.com',
      password: 'password123',
      role: 'SALES_USER',
    });

    expect(authService.createUser).toHaveBeenCalled();
  });

  it('rejects demoting the last active admin', async () => {
    prisma.db.orm.public.User.select
      .mockReturnValueOnce({
        where: vi.fn().mockReturnValue({
          first: vi.fn().mockResolvedValue(admin),
        }),
      })
      .mockReturnValueOnce({
        where: vi.fn().mockReturnValue({
          first: vi.fn().mockResolvedValue({
            id: admin.id,
            role: 'ADMIN',
            isActive: true,
          }),
        }),
      });

    prisma.db.orm.public.User.where.mockReturnValue({
      where: vi.fn().mockReturnValue({
        aggregate: vi.fn().mockResolvedValue({ total: 1 }),
      }),
    });

    await expect(
      service.update(admin.id, { role: 'SALES_USER' }),
    ).rejects.toBeInstanceOf(ConflictException);
  });

  it('rejects deactivating the last active admin', async () => {
    prisma.db.orm.public.User.select
      .mockReturnValueOnce({
        where: vi.fn().mockReturnValue({
          first: vi.fn().mockResolvedValue(admin),
        }),
      })
      .mockReturnValueOnce({
        where: vi.fn().mockReturnValue({
          first: vi.fn().mockResolvedValue({
            id: admin.id,
            role: 'ADMIN',
            isActive: true,
          }),
        }),
      });

    prisma.db.orm.public.User.where.mockReturnValue({
      where: vi.fn().mockReturnValue({
        aggregate: vi.fn().mockResolvedValue({ total: 1 }),
      }),
    });

    await expect(
      service.updateStatus(admin.id, { isActive: false }),
    ).rejects.toBeInstanceOf(ConflictException);
  });

  it('throws not found when updating a missing user', async () => {
    prisma.db.orm.public.User.select.mockReturnValue({
      where: vi.fn().mockReturnValue({
        first: vi.fn().mockResolvedValue(null),
      }),
    });

    await expect(
      service.update('missing', { firstName: 'Nope' }),
    ).rejects.toBeInstanceOf(NotFoundException);
  });
});
