import { INestApplication, ValidationPipe } from '@nestjs/common';
import { Test } from '@nestjs/testing';
import {
  IdentityProvider,
  InvalidAccessTokenError,
} from '@task-stream/api/identity/application';
import { User, UserFactory } from '@task-stream/api/identity/domain';
import { DomainErrorFilter } from '@task-stream/api/shared/presenters';
import { Client, createClient } from 'graphql-ws';
import WebSocket from 'ws';

process.env['POSTGRES_URL'] ??=
  'postgres://taskstream:taskstream@localhost:5432/taskstream';
process.env['POSTGRES_SYNCHRONIZE'] = 'true';
process.env['MONGO_URL'] ??= 'mongodb://localhost:27017/taskstream_e2e';
process.env['REDIS_URL'] ??= 'redis://localhost:6379';
process.env['EVENT_STREAM_KEY'] = `task-stream:e2e:${Date.now()}`;
process.env['GRAPHQL_SCHEMA_FILE'] = '';
process.env['AUTH_SESSION_TTL_SECONDS'] = '0';

const { AppModule } = require('../src/app/app.module');

/** Pireon is replaced by fixed tokens: the rest of the stack is real. */
const users = new UserFactory();
const person = (id: string, name: string, email: string) =>
  users.create({ id, name, email, isActive: true });
const people: Record<string, User> = {
  'token-ana': person('101', 'Ana (lead)', 'ana@x.dev'),
  'token-bob': person('102', 'Bob (frontend)', 'bob@x.dev'),
  'token-qa': person('103', 'Quinn (QA)', 'qa@x.dev'),
  'token-eve': person('104', 'Eve (outsider)', 'eve@x.dev'),
};
const byId = (id: string) =>
  Object.values(people).find((p) => p.id === id) ?? null;

const fakePireon: Pick<IdentityProvider, 'whoAmI' | 'findUser' | 'listUsers'> =
  {
    whoAmI: async (token) => {
      const user = people[token];
      if (!user) throw new InvalidAccessTokenError();
      return user;
    },
    findUser: async (id) => byId(id),
    listUsers: async () => Object.values(people),
  };

describe('task-stream (e2e)', () => {
  let app: INestApplication;
  let url: string;
  const clients: Client[] = [];

  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- test reads arbitrary GraphQL shapes
  async function gql<T = Record<string, any>>(
    token: string,
    query: string,
    variables?: object,
  ): Promise<T> {
    const response = await fetch(`${url}/graphql`, {
      method: 'POST',
      headers: {
        'content-type': 'application/json',
        authorization: `Bearer ${token}`,
      },
      body: JSON.stringify({ query, variables }),
    });
    const body = await response.json();
    if (body.errors)
      throw new Error(
        body.errors.map((e: { message: string }) => e.message).join('; '),
      );
    return body.data;
  }

  /** The read model is eventually consistent: poll until it catches up. */
  async function eventually<T>(
    read: () => Promise<T>,
    ok: (value: T) => boolean,
  ): Promise<T> {
    const deadline = Date.now() + 10_000;
    let last: unknown;
    while (Date.now() < deadline) {
      try {
        const value = await read();
        if (ok(value)) return value;
        last = value;
      } catch (error) {
        last = error;
      }
      await new Promise((r) => setTimeout(r, 100));
    }
    throw new Error(`Read model did not converge: ${JSON.stringify(last)}`);
  }

  function subscribe<T>(
    token: string | null,
    query: string,
    variables: Record<string, unknown>,
  ) {
    const client = createClient({
      url: url.replace('http', 'ws') + '/graphql',
      webSocketImpl: WebSocket,
      connectionParams: token ? { authorization: `Bearer ${token}` } : {},
      retryAttempts: 0,
    });
    clients.push(client);
    const received: T[] = [];
    const errors: unknown[] = [];
    client.subscribe<T>(
      { query, variables },
      {
        next: (msg) =>
          msg.errors ? errors.push(msg.errors) : received.push(msg.data as T),
        error: (e) => errors.push(e),
        complete: () => undefined,
      },
    );
    return { received, errors };
  }

  beforeAll(async () => {
    const moduleRef = await Test.createTestingModule({ imports: [AppModule] })
      .overrideProvider(IdentityProvider)
      .useValue(fakePireon)
      .compile();
    app = moduleRef.createNestApplication({ rawBody: true });
    app.useGlobalPipes(
      new ValidationPipe({ transform: true, whitelist: true }),
    );
    app.useGlobalFilters(new DomainErrorFilter());
    await app.listen(0);
    url = await app.getUrl();
    url = url.replace('[::1]', 'localhost');
  });

  afterAll(async () => {
    await Promise.all(clients.map((c) => c.dispose()));
    await app?.close();
  });

  it('runs the whole ticket lifecycle with CQRS and realtime updates', async () => {
    const key = `E${Date.now().toString(36).slice(-5).toUpperCase()}`;

    // --- Project & team (identity comes from Pireon) ---
    const { createProject } = await gql(
      'token-ana',
      `mutation($i: CreateProjectInput!) { createProject(input: $i) { id key version } }`,
      {
        i: { key, name: 'Checkout revamp' },
      },
    );
    const projectId = createProject.id;
    expect(createProject.key).toBe(key);

    await eventually(
      () =>
        gql('token-ana', `query($k: String!) { project(idOrKey: $k) { id } }`, {
          k: key,
        }),
      (d) => !!d.project,
    );
    for (const userId of ['102', '103']) {
      await gql(
        'token-ana',
        `mutation($i: ProjectMemberInput!) { addProjectMember(input: $i) { version } }`,
        {
          i: { projectId, userId, role: 'MEMBER' },
        },
      );
    }

    // Subscriptions are authorised against the read model: wait for Bob's membership.
    await eventually(
      async () => (await gql('token-bob', `{ myProjects { id } }`)).myProjects,
      (p) => p.some((x: { id: string }) => x.id === projectId),
    );

    // --- Realtime: Bob watches the board ---
    const board = subscribe<{
      issueChanged: { action: string; issue: { key: string; status: string } };
    }>(
      'token-bob',
      `subscription($p: ID!) { issueChanged(projectId: $p) { action version issue { key status assignee { name } } } }`,
      { p: projectId },
    );
    const feed = subscribe<{ activityAdded: { summary: string } }>(
      'token-ana',
      `subscription($p: ID!) { activityAdded(projectId: $p) { summary } }`,
      { p: projectId },
    );
    const intruder = subscribe(
      'token-eve',
      `subscription($p: ID!) { issueChanged(projectId: $p) { action } }`,
      { p: projectId },
    );
    const anonymous = subscribe(
      null,
      `subscription($p: ID!) { issueChanged(projectId: $p) { action } }`,
      { p: projectId },
    );
    await new Promise((r) => setTimeout(r, 300)); // let subscriptions register

    // --- QA reports a bug, a UI change against Figma, and the backend dependency ---
    const create = `mutation($i: CreateIssueInput!) { createIssue(input: $i) { id key version } }`;
    const bug = (
      await gql('token-qa', create, {
        i: {
          projectId,
          type: 'BUG',
          title: 'Pay button does nothing on Safari',
          area: 'FRONTEND',
          priority: 'CRITICAL',
          assigneeId: '102',
          labels: ['Safari', 'checkout'],
        },
      })
    ).createIssue;
    const ui = (
      await gql('token-qa', create, {
        i: {
          projectId,
          type: 'UI_CHANGE',
          title: 'Summary card spacing differs from Figma',
          area: 'FRONTEND',
          figmaUrl: 'https://www.figma.com/design/abc/Checkout',
        },
      })
    ).createIssue;
    const api = (
      await gql('token-ana', create, {
        i: {
          projectId,
          type: 'FEATURE',
          title: 'Expose /payments/intent',
          area: 'BACKEND',
        },
      })
    ).createIssue;
    expect([bug.key, ui.key, api.key]).toEqual([
      `${key}-1`,
      `${key}-2`,
      `${key}-3`,
    ]);

    // --- Relations FE ↔ BE ---
    await gql(
      'token-bob',
      `mutation($i: LinkIssuesInput!) { linkIssues(input: $i) { version } }`,
      {
        i: { issueId: bug.id, type: 'DEPENDS_ON', targetIssueId: api.id },
      },
    );
    const backend = await eventually(
      () =>
        gql(
          'token-bob',
          `query($k: String!) { issue(idOrKey: $k) { links { type direction issueKey } } }`,
          { k: api.key },
        ),
      (d) => d.issue.links.length === 1,
    );
    expect(backend.issue.links[0]).toEqual({
      type: 'DEPENDS_ON',
      direction: 'INWARD',
      issueKey: bug.key,
    });

    // --- Workflow including a failed QA round ---
    const move = (token: string, status: string, reason?: string) =>
      gql(
        token,
        `mutation($i: ChangeIssueStatusInput!) { changeIssueStatus(input: $i) { version } }`,
        {
          i: { issueId: bug.id, status, reason },
        },
      );
    await move('token-bob', 'IN_PROGRESS');
    await move('token-bob', 'READY_FOR_QA');
    await move('token-qa', 'IN_QA');
    await expect(move('token-qa', 'QA_FAILED')).rejects.toThrow(
      /reason is required/,
    );
    await move('token-qa', 'QA_FAILED', 'Still failing on Safari 17');
    await expect(move('token-bob', 'DONE')).rejects.toThrow(/Cannot move/);

    // --- Comments ---
    await gql(
      'token-bob',
      `mutation($i: ID!, $b: String!) { addComment(issueId: $i, body: $b) { id } }`,
      {
        i: bug.id,
        b: 'Root cause: Safari blocks the payment popup. Decision: use redirect flow.',
      },
    );

    // --- Releases ---
    const release = (
      await gql(
        'token-ana',
        `mutation($i: CreateReleaseInput!) { createRelease(input: $i) { id } }`,
        {
          i: { projectId, name: 'v2.0.0' },
        },
      )
    ).createRelease;
    await eventually(
      () =>
        gql('token-ana', `query($id: ID!) { release(id: $id) { id } }`, {
          id: release.id,
        }),
      (d) => !!d.release,
    );
    await gql(
      'token-ana',
      `mutation($i: ID!, $r: ID) { setIssueRelease(issueId: $i, releaseId: $r) { version } }`,
      { i: bug.id, r: release.id },
    );
    await expect(
      gql(
        'token-ana',
        `mutation($r: ID!) { publishRelease(releaseId: $r) { version } }`,
        { r: release.id },
      ),
    ).rejects.toThrow(/unfinished/);

    // --- Read model (MongoDB) converged ---
    const view = await eventually(
      () =>
        gql(
          'token-bob',
          `query($k: String!) {
          issue(idOrKey: $k) {
            key status priority labels commentCount allowedTransitions
            assignee { name } reporter { name } release { name }
            links { type direction issueKey } linkedIssues { key }
            comments { total items { body author { name } } }
            history { summary }
          }
        }`,
          { k: bug.key },
        ),
      (d) => d.issue.commentCount === 1 && d.issue.release?.name === 'v2.0.0',
    );
    expect(view.issue).toMatchObject({
      status: 'QA_FAILED',
      priority: 'CRITICAL',
      labels: ['safari', 'checkout'],
      assignee: { name: 'Bob (frontend)' },
      reporter: { name: 'Quinn (QA)' },
      allowedTransitions: ['IN_PROGRESS', 'TODO'],
      links: [{ type: 'DEPENDS_ON', direction: 'OUTWARD', issueKey: api.key }],
      linkedIssues: [{ key: api.key }],
      comments: { total: 1, items: [{ author: { name: 'Bob (frontend)' } }] },
    });
    expect(
      view.issue.history.map((h: { summary: string }) => h.summary),
    ).toContain(
      `Quinn (QA) movió ${bug.key} de En QA a QA fallido: Still failing on Safari 17`,
    );

    const { project } = await gql(
      'token-ana',
      `query($k: String!) {
      project(idOrKey: $k) {
        members { user { name } role }
        stats { total open byStatus { key count } byAssignee { user { name } count } }
        board { status total }
        releases { name progress { total finished percent } }
      }
    }`,
      { k: key },
    );
    expect(project.members).toHaveLength(3);
    expect(project.stats).toMatchObject({ total: 3, open: 3 });
    expect(
      project.board.find((c: { status: string }) => c.status === 'QA_FAILED')
        .total,
    ).toBe(1);
    expect(project.releases[0]).toMatchObject({
      name: 'v2.0.0',
      progress: { total: 1, finished: 0, percent: 0 },
    });

    // --- Authorisation on the read side ---
    await expect(
      gql('token-eve', `query($k: String!) { issue(idOrKey: $k) { key } }`, {
        k: bug.key,
      }),
    ).rejects.toThrow(/not found/);

    // --- Realtime delivered ---
    await eventually(
      async () => board.received,
      (r) => r.some((m) => m.issueChanged.issue.status === 'QA_FAILED'),
    );
    expect(board.received[0].issueChanged).toMatchObject({
      action: 'IssueCreatedEvent',
      issue: { key: bug.key },
    });
    expect(feed.received.map((m) => m.activityAdded.summary)).toContain(
      `Bob (frontend) comentó en ${bug.key}`,
    );
    // Non-members get an error at subscribe time; unauthenticated sockets are closed.
    expect(intruder.received).toHaveLength(0);
    expect(JSON.stringify(intruder.errors)).toMatch(/not found/);
    expect(anonymous.received).toHaveLength(0);
    expect(anonymous.errors).toHaveLength(1);
  });
});