import { describe, it, expect, vi, beforeEach } from 'vitest';
import { ProjectService } from '../src/services/project.service.js';
import { NotFoundError, ConflictError } from '../src/services/mcp-server.service.js';
import type { IProjectRepository } from '../src/repositories/project.repository.js';
import type { IMcpProfileRepository, IMcpServerRepository } from '../src/repositories/interfaces.js';

function mockProjectRepo(): IProjectRepository {
  return {
    findAll: vi.fn(async () => []),
    findById: vi.fn(async () => null),
    findByName: vi.fn(async () => null),
    create: vi.fn(async (data) => ({
      id: 'proj-1',
      name: data.name,
      description: data.description ?? '',
      ownerId: data.ownerId,
      version: 1,
      createdAt: new Date(),
      updatedAt: new Date(),
    })),
    update: vi.fn(async (id) => ({
      id, name: 'test', description: '', ownerId: 'u1', version: 2,
      createdAt: new Date(), updatedAt: new Date(),
    })),
    delete: vi.fn(async () => {}),
    setProfiles: vi.fn(async () => {}),
    getProfileIds: vi.fn(async () => []),
  };
}

function mockProfileRepo(): IMcpProfileRepository {
  return {
    findAll: vi.fn(async () => []),
    findById: vi.fn(async () => null),
    findByServerAndName: vi.fn(async () => null),
    create: vi.fn(async () => ({} as never)),
    update: vi.fn(async () => ({} as never)),
    delete: vi.fn(async () => {}),
  };
}

function mockServerRepo(): IMcpServerRepository {
  return {
    findAll: vi.fn(async () => []),
    findById: vi.fn(async () => null),
    findByName: vi.fn(async () => null),
    create: vi.fn(async () => ({} as never)),
    update: vi.fn(async () => ({} as never)),
    delete: vi.fn(async () => {}),
  };
}

describe('ProjectService', () => {
  let projectRepo: ReturnType<typeof mockProjectRepo>;
  let profileRepo: ReturnType<typeof mockProfileRepo>;
  let serverRepo: ReturnType<typeof mockServerRepo>;
  let service: ProjectService;

  beforeEach(() => {
    projectRepo = mockProjectRepo();
    profileRepo = mockProfileRepo();
    serverRepo = mockServerRepo();
    service = new ProjectService(projectRepo, profileRepo, serverRepo);
  });

  describe('create', () => {
    it('creates a project', async () => {
      const result = await service.create({ name: 'my-project' }, 'user-1');
      expect(result.name).toBe('my-project');
      expect(result.ownerId).toBe('user-1');
    });

    it('throws ConflictError when name exists', async () => {
      vi.mocked(projectRepo.findByName).mockResolvedValue({ id: '1' } as never);
      await expect(service.create({ name: 'taken' }, 'u1')).rejects.toThrow(ConflictError);
    });

    it('validates input', async () => {
      await expect(service.create({ name: '' }, 'u1')).rejects.toThrow();
    });
  });

  describe('getById', () => {
    it('throws NotFoundError when not found', async () => {
      await expect(service.getById('missing')).rejects.toThrow(NotFoundError);
    });
  });

  describe('setProfiles', () => {
    it('sets profile associations', async () => {
      vi.mocked(projectRepo.findById).mockResolvedValue({ id: 'p1' } as never);
      vi.mocked(profileRepo.findById).mockResolvedValue({ id: 'prof-1' } as never);
      const result = await service.setProfiles('p1', { profileIds: ['prof-1'] });
      expect(result).toEqual(['prof-1']);
      expect(projectRepo.setProfiles).toHaveBeenCalledWith('p1', ['prof-1']);
    });

    it('throws NotFoundError for missing profile', async () => {
      vi.mocked(projectRepo.findById).mockResolvedValue({ id: 'p1' } as never);
      await expect(service.setProfiles('p1', { profileIds: ['missing'] })).rejects.toThrow(NotFoundError);
    });

    it('throws NotFoundError for missing project', async () => {
      await expect(service.setProfiles('missing', { profileIds: [] })).rejects.toThrow(NotFoundError);
    });
  });

  describe('getMcpConfig', () => {
    it('returns empty config for project with no profiles', async () => {
      vi.mocked(projectRepo.findById).mockResolvedValue({ id: 'p1' } as never);
      const result = await service.getMcpConfig('p1');
      expect(result).toEqual({ mcpServers: {} });
    });

    it('generates config from profiles', async () => {
      vi.mocked(projectRepo.findById).mockResolvedValue({ id: 'p1' } as never);
      vi.mocked(projectRepo.getProfileIds).mockResolvedValue(['prof-1']);
      vi.mocked(profileRepo.findById).mockResolvedValue({
        id: 'prof-1', name: 'default', serverId: 's1',
        permissions: [], envOverrides: {},
        version: 1, createdAt: new Date(), updatedAt: new Date(),
      });
      vi.mocked(serverRepo.findById).mockResolvedValue({
        id: 's1', name: 'slack', description: '', packageName: '@anthropic/slack-mcp',
        dockerImage: null, transport: 'STDIO', repositoryUrl: null, envTemplate: [],
        version: 1, createdAt: new Date(), updatedAt: new Date(),
      });

      const result = await service.getMcpConfig('p1');
      expect(result.mcpServers['slack--default']).toBeDefined();
    });

    it('throws NotFoundError for missing project', async () => {
      await expect(service.getMcpConfig('missing')).rejects.toThrow(NotFoundError);
    });
  });

  describe('delete', () => {
    it('deletes project', async () => {
      vi.mocked(projectRepo.findById).mockResolvedValue({ id: 'p1' } as never);
      await service.delete('p1');
      expect(projectRepo.delete).toHaveBeenCalledWith('p1');
    });
  });
});