import { describe, it, expect } from 'vitest';
import {
  createCompany,
  updateCompany,
  archiveCompany,
  listCompanies,
  autocomplete,
  upsertByName,
  getCompanyById,
} from '@/lib/services/companies.service';
import { makeCompany, makePort, makeAuditMeta } from '../../helpers/factories';
import { db } from '@/lib/db';
import { companies } from '@/lib/db/schema';
import { eq } from 'drizzle-orm';
import { ConflictError, NotFoundError } from '@/lib/errors';

describe('companies.service — createCompany', () => {
  it('creates a company with minimal required fields', async () => {
    const port = await makePort();

    const company = await createCompany(
      port.id,
      { name: 'Aegean Holdings' },
      makeAuditMeta({ portId: port.id }),
    );

    expect(company.id).toBeTruthy();
    expect(company.name).toBe('Aegean Holdings');
    expect(company.status).toBe('active');
    expect(company.portId).toBe(port.id);
  });

  it('rejects duplicate name case-insensitively (ConflictError)', async () => {
    const port = await makePort();
    await createCompany(port.id, { name: 'Aegean Holdings' }, makeAuditMeta({ portId: port.id }));

    await expect(
      createCompany(port.id, { name: 'AEGEAN HOLDINGS' }, makeAuditMeta({ portId: port.id })),
    ).rejects.toBeInstanceOf(ConflictError);
  });

  it('allows same name in different ports (tenant isolation)', async () => {
    const portA = await makePort();
    const portB = await makePort();

    const a = await createCompany(
      portA.id,
      { name: 'Shared Name Co' },
      makeAuditMeta({ portId: portA.id }),
    );
    const b = await createCompany(
      portB.id,
      { name: 'Shared Name Co' },
      makeAuditMeta({ portId: portB.id }),
    );

    expect(a.id).not.toBe(b.id);
    expect(a.portId).toBe(portA.id);
    expect(b.portId).toBe(portB.id);
  });
});

describe('companies.service — upsertByName', () => {
  it('returns existing company on case-insensitive match', async () => {
    const port = await makePort();
    const original = await createCompany(
      port.id,
      { name: 'Poseidon Maritime' },
      makeAuditMeta({ portId: port.id }),
    );

    const result = await upsertByName(
      port.id,
      'POSEIDON maritime',
      makeAuditMeta({ portId: port.id }),
    );

    expect(result.id).toBe(original.id);
  });

  it('creates a new company when name not found', async () => {
    const port = await makePort();

    const result = await upsertByName(port.id, 'Brand New Co', makeAuditMeta({ portId: port.id }));

    expect(result.id).toBeTruthy();
    expect(result.name).toBe('Brand New Co');
    expect(result.portId).toBe(port.id);
  });

  it('is tenant-scoped (same name in different ports creates distinct rows)', async () => {
    const portA = await makePort();
    const portB = await makePort();

    const a = await upsertByName(portA.id, 'Cross Tenant Co', makeAuditMeta({ portId: portA.id }));
    const b = await upsertByName(portB.id, 'Cross Tenant Co', makeAuditMeta({ portId: portB.id }));

    expect(a.id).not.toBe(b.id);
    expect(a.portId).toBe(portA.id);
    expect(b.portId).toBe(portB.id);
  });
});

describe('companies.service — updateCompany', () => {
  it('updates fields', async () => {
    const port = await makePort();
    const company = await makeCompany({
      portId: port.id,
      overrides: { name: 'Original Name', notes: 'Old notes' },
    });

    const updated = await updateCompany(
      company.id,
      port.id,
      { name: 'New Name', notes: 'New notes' },
      makeAuditMeta({ portId: port.id }),
    );

    expect(updated.name).toBe('New Name');
    expect(updated.notes).toBe('New notes');

    const [row] = await db.select().from(companies).where(eq(companies.id, company.id));
    expect(row!.name).toBe('New Name');
  });

  it('throws NotFoundError for cross-tenant', async () => {
    const portA = await makePort();
    const portB = await makePort();
    const companyInB = await makeCompany({ portId: portB.id });

    await expect(
      updateCompany(
        companyInB.id,
        portA.id,
        { name: 'Hijack' },
        makeAuditMeta({ portId: portA.id }),
      ),
    ).rejects.toBeInstanceOf(NotFoundError);
  });
});

describe('companies.service — archiveCompany', () => {
  it('sets archivedAt to a non-null timestamp', async () => {
    const port = await makePort();
    const company = await makeCompany({ portId: port.id });

    await archiveCompany(company.id, port.id, makeAuditMeta({ portId: port.id }));

    const [row] = await db.select().from(companies).where(eq(companies.id, company.id));
    expect(row!.archivedAt).not.toBeNull();
  });

  it('throws NotFoundError for missing or cross-tenant', async () => {
    const portA = await makePort();
    const portB = await makePort();
    const companyInB = await makeCompany({ portId: portB.id });

    await expect(
      archiveCompany(companyInB.id, portA.id, makeAuditMeta({ portId: portA.id })),
    ).rejects.toBeInstanceOf(NotFoundError);

    await expect(
      archiveCompany('nonexistent-id', portA.id, makeAuditMeta({ portId: portA.id })),
    ).rejects.toBeInstanceOf(NotFoundError);
  });
});

describe('companies.service — listCompanies', () => {
  it('is tenant-scoped', async () => {
    const portA = await makePort();
    const portB = await makePort();
    await makeCompany({ portId: portA.id, overrides: { name: 'In A' } });
    await makeCompany({ portId: portB.id, overrides: { name: 'In B' } });

    const result = await listCompanies(portA.id, {
      page: 1,
      limit: 20,
      order: 'desc',
      includeArchived: false,
    });
    expect(result.data.some((c) => c.name === 'In A')).toBe(true);
    expect(result.data.some((c) => c.name === 'In B')).toBe(false);
  });

  it('filters by status', async () => {
    const port = await makePort();
    await makeCompany({
      portId: port.id,
      overrides: { name: 'Active Co', status: 'active' },
    });
    await makeCompany({
      portId: port.id,
      overrides: { name: 'Dissolved Co', status: 'dissolved' },
    });

    const result = await listCompanies(port.id, {
      page: 1,
      limit: 20,
      order: 'desc',
      includeArchived: false,
      status: 'dissolved',
    });
    expect(result.data.map((c) => c.name)).toContain('Dissolved Co');
    expect(result.data.map((c) => c.name)).not.toContain('Active Co');
  });

  it('searches by name (ILIKE)', async () => {
    const port = await makePort();
    await makeCompany({ portId: port.id, overrides: { name: 'Aegean Shipping' } });
    await makeCompany({ portId: port.id, overrides: { name: 'Pacific Marine' } });

    const result = await listCompanies(port.id, {
      page: 1,
      limit: 20,
      order: 'desc',
      includeArchived: false,
      search: 'aegean',
    });
    expect(result.data.map((c) => c.name)).toContain('Aegean Shipping');
    expect(result.data.map((c) => c.name)).not.toContain('Pacific Marine');
  });
});

describe('companies.service — autocomplete', () => {
  it('matches by name', async () => {
    const port = await makePort();
    await makeCompany({ portId: port.id, overrides: { name: 'Phoenix Ltd' } });

    const result = await autocomplete(port.id, 'phoe');
    expect(result.some((c) => c.name === 'Phoenix Ltd')).toBe(true);
  });

  it('is tenant-scoped', async () => {
    const portA = await makePort();
    const portB = await makePort();
    await makeCompany({ portId: portA.id, overrides: { name: 'Only-A Co' } });

    const result = await autocomplete(portB.id, 'only-a');
    expect(result).toHaveLength(0);
  });
});

describe('companies.service — getCompanyById', () => {
  it('returns the company when same tenant', async () => {
    const port = await makePort();
    const company = await makeCompany({ portId: port.id });

    const result = await getCompanyById(company.id, port.id);
    expect(result.id).toBe(company.id);
  });

  it('throws NotFoundError for cross-tenant', async () => {
    const portA = await makePort();
    const portB = await makePort();
    const companyInB = await makeCompany({ portId: portB.id });

    await expect(getCompanyById(companyInB.id, portA.id)).rejects.toBeInstanceOf(NotFoundError);
  });
});