import { describe, it, expect } from 'vitest';
import {
  parseDbSetEntities,
  resolveAliases,
  parseDomainEntity,
  assemble,
} from '../discover.js';

const DBCONTEXT = `
using DomainProject = Test.Domain.Entities.Project;

public class ExtensionsDbContext : SmartStackExtensionDbContext
{
    public DbSet<Category> Categories => Set<Category>();
    public DbSet<DomainProject> Projects => Set<DomainProject>();
    public DbSet<Mandate> Mandates => Set<Mandate>();
}
`;

const DOMAIN_PROJECT = `
using SmartStack.Domain.Common;
namespace Test.Domain.Entities;

public class Project : ExtensionBaseEntity, ITenantEntity
{
    public Guid TenantId { get; private set; }
    public string Name { get; private set; } = null!;
}
`;

describe('discover / parsers', () => {
  it('resolveAliases + parseDbSetEntities resolve the aliased entity', () => {
    expect(resolveAliases(DBCONTEXT).get('DomainProject')).toBe('Test.Domain.Entities.Project');
    const ents = parseDbSetEntities(DBCONTEXT);
    expect(ents.map((e) => e.simpleName).sort()).toEqual(['Category', 'Mandate', 'Project']);
    expect(ents.find((e) => e.simpleName === 'Project')!.fqn).toBe('Test.Domain.Entities.Project');
  });

  it('parseDomainEntity detects ITenantEntity + namespace', () => {
    const r = parseDomainEntity(DOMAIN_PROJECT, 'Project')!;
    expect(r.tenantScoped).toBe(true);
    expect(r.fqn).toBe('Test.Domain.Entities.Project');
  });
});

describe('discover / assemble (fail-closed: NEVER registers)', () => {
  const base = {
    seamPresent: false,
    entities: [
      { simpleName: 'Project', fqn: 'Test.Domain.Entities.Project', tenantScoped: true },
      { simpleName: 'Mandate', fqn: 'Test.Domain.Entities.Mandate', tenantScoped: false },
    ],
  };

  it('returns every entity as an advisory candidate — none auto-registered', () => {
    const { candidates, review } = assemble(base);

    expect(candidates.map((c) => c.simpleName).sort()).toEqual(['Mandate', 'Project']);
    expect(review).toHaveLength(2);
    expect(review.every((r) => r.kind === 'candidate')).toBe(true);
  });

  it('suggests a ready-to-paste commented registration reflecting the tenant scope', () => {
    const { review } = assemble(base);

    const project = review.find((r) => r.entity === 'Project')!;
    expect(project.suggestion).toContain('// refs.Entity<Test.Domain.Entities.Project>("project", "Project", "FolderKanban")');
    expect(project.suggestion).toContain('.WithDisplay(x => x.Name)');
    expect(project.suggestion).toContain('.TenantScoped()');

    // A non-tenant entity omits .TenantScoped() from its suggestion.
    const mandate = review.find((r) => r.entity === 'Mandate')!;
    expect(mandate.suggestion).not.toContain('.TenantScoped()');
  });

  it('propagates seam presence', () => {
    expect(assemble({ ...base, seamPresent: true }).seamPresent).toBe(true);
    expect(assemble({ ...base, seamPresent: false }).seamPresent).toBe(false);
  });
});