import path from "node:path";
import assert from "node:assert/strict";
import { describe, it } from "node:test";
import { asc, eq } from "drizzle-orm";
import { migrate } from "drizzle-orm/better-sqlite3/migrator";
import {
  createDatabaseContext,
  type DatabaseContext,
} from "../src/db/database-context.js";
import { CircuitSectionRenumberProjectCommandRepository } from "../src/db/repositories/circuit-section-renumber-project-command.repository.js";
import { DistributionBoardFixtureRepository } from "./support/distribution-board-fixture.js";
import { ProjectHistoryRepository } from "../src/db/repositories/project-history.repository.js";
import { circuitDeviceRows } from "../src/db/schema/circuit-device-rows.js";
import { circuitSections } from "../src/db/schema/circuit-sections.js";
import { circuits } from "../src/db/schema/circuits.js";
import { projectRevisions } from "../src/db/schema/project-revisions.js";
import { projects } from "../src/db/schema/projects.js";
import { createCircuitSectionRenumberProjectCommand } from "../src/domain/models/circuit-section-renumber-project-command.model.js";

interface TestFixture {
  context: DatabaseContext;
  sectionId: string;
  foreignSectionId: string;
}

function createTestDatabase(): TestFixture {
  const context = createDatabaseContext(":memory:");
  migrate(context.db, {
    migrationsFolder: path.resolve("src", "db", "migrations"),
  });
  context.db
    .insert(projects)
    .values([
      { id: "project-1", name: "Test project" },
      { id: "project-2", name: "Other project" },
    ])
    .run();
  const boards = new DistributionBoardFixtureRepository(context.db);
  const board = boards.createWithCircuitListAndDefaultSections(
    "project-1",
    "UV-01"
  );
  const foreignBoard = boards.createWithCircuitListAndDefaultSections(
    "project-2",
    "UV-02"
  );
  const ownSections = context.db
    .select()
    .from(circuitSections)
    .where(eq(circuitSections.circuitListId, board.id))
    .orderBy(asc(circuitSections.sortOrder))
    .all();
  const foreignSection = context.db
    .select()
    .from(circuitSections)
    .where(eq(circuitSections.circuitListId, foreignBoard.id))
    .get();
  assert.ok(ownSections[0]);
  assert.ok(ownSections[1]);
  assert.ok(foreignSection);

  context.db
    .insert(circuits)
    .values([
      {
        id: "circuit-1",
        circuitListId: board.id,
        sectionId: ownSections[0].id,
        equipmentIdentifier: "-1F1",
        sortOrder: 10,
      },
      {
        id: "circuit-2",
        circuitListId: board.id,
        sectionId: ownSections[0].id,
        equipmentIdentifier: "-1F2",
        sortOrder: 20,
      },
      {
        id: "circuit-3",
        circuitListId: board.id,
        sectionId: ownSections[0].id,
        equipmentIdentifier: "-1F3",
        sortOrder: 30,
      },
      {
        id: "circuit-other-section",
        circuitListId: board.id,
        sectionId: ownSections[1].id,
        equipmentIdentifier: "-2F1",
        sortOrder: 10,
      },
      {
        id: "circuit-foreign",
        circuitListId: foreignBoard.id,
        sectionId: foreignSection.id,
        equipmentIdentifier: "-1F1",
        sortOrder: 10,
      },
    ])
    .run();
  context.db
    .insert(circuitDeviceRows)
    .values({
      id: "row-1",
      circuitId: "circuit-1",
      sortOrder: 10,
      name: "Leuchte",
      displayName: "Leuchte",
      quantity: 1,
      powerPerUnit: 0.1,
      simultaneityFactor: 1,
    })
    .run();

  return {
    context,
    sectionId: ownSections[0].id,
    foreignSectionId: foreignSection.id,
  };
}

function getSectionCircuitState(
  context: DatabaseContext,
  sectionId: string
) {
  return context.db
    .select({
      id: circuits.id,
      equipmentIdentifier: circuits.equipmentIdentifier,
      sortOrder: circuits.sortOrder,
    })
    .from(circuits)
    .where(eq(circuits.sectionId, sectionId))
    .orderBy(asc(circuits.id))
    .all();
}

function createSwapCommand(sectionId: string) {
  return createCircuitSectionRenumberProjectCommand(sectionId, [
    {
      circuitId: "circuit-1",
      expectedEquipmentIdentifier: "-1F1",
      targetEquipmentIdentifier: "-1F2",
    },
    {
      circuitId: "circuit-2",
      expectedEquipmentIdentifier: "-1F2",
      targetEquipmentIdentifier: "-1F1",
    },
    {
      circuitId: "circuit-3",
      expectedEquipmentIdentifier: "-1F3",
      targetEquipmentIdentifier: "-1F3",
    },
  ]);
}

describe("circuit section renumber project-command repository", () => {
  it("swaps identifiers and supports persisted undo and redo", () => {
    const fixture = createTestDatabase();
    try {
      const store =
        new CircuitSectionRenumberProjectCommandRepository(
          fixture.context.db
        );
      const command = createSwapCommand(fixture.sectionId);
      const renumbered = store.execute({
        projectId: "project-1",
        expectedRevision: 0,
        source: "user",
        command,
      });
      assert.deepEqual(
        getSectionCircuitState(
          fixture.context,
          fixture.sectionId
        ),
        [
          {
            id: "circuit-1",
            equipmentIdentifier: "-1F2",
            sortOrder: 10,
          },
          {
            id: "circuit-2",
            equipmentIdentifier: "-1F1",
            sortOrder: 20,
          },
          {
            id: "circuit-3",
            equipmentIdentifier: "-1F3",
            sortOrder: 30,
          },
        ]
      );
      assert.equal(
        fixture.context.db
          .select()
          .from(circuitDeviceRows)
          .where(eq(circuitDeviceRows.id, "row-1"))
          .get()?.circuitId,
        "circuit-1"
      );

      store.execute({
        projectId: "project-1",
        expectedRevision: 1,
        source: "undo",
        historyTargetChangeSetId:
          renumbered.revision.changeSetId,
        command: renumbered.inverse,
      });
      assert.deepEqual(
        getSectionCircuitState(
          fixture.context,
          fixture.sectionId
        ).map((circuit) => circuit.equipmentIdentifier),
        ["-1F1", "-1F2", "-1F3"]
      );

      store.execute({
        projectId: "project-1",
        expectedRevision: 2,
        source: "redo",
        historyTargetChangeSetId:
          renumbered.revision.changeSetId,
        command,
      });
      assert.deepEqual(
        new ProjectHistoryRepository(fixture.context.db).getState(
          "project-1"
        ),
        {
          projectId: "project-1",
          currentRevision: 3,
          undoDepth: 1,
          redoDepth: 0,
          undoChangeSetId: renumbered.revision.changeSetId,
          redoChangeSetId: null,
        }
      );
    } finally {
      fixture.context.close();
    }
  });

  it("rejects incomplete, stale and foreign-section assignments", () => {
    const fixture = createTestDatabase();
    try {
      const store =
        new CircuitSectionRenumberProjectCommandRepository(
          fixture.context.db
        );
      assert.throws(
        () =>
          store.execute({
            projectId: "project-1",
            expectedRevision: 0,
            source: "user",
            command: createCircuitSectionRenumberProjectCommand(
              fixture.sectionId,
              [
                {
                  circuitId: "circuit-1",
                  expectedEquipmentIdentifier: "-1F1",
                  targetEquipmentIdentifier: "-1F2",
                },
                {
                  circuitId: "circuit-2",
                  expectedEquipmentIdentifier: "-1F2",
                  targetEquipmentIdentifier: "-1F1",
                },
              ]
            ),
          }),
        /every circuit/
      );
      assert.throws(
        () =>
          store.execute({
            projectId: "project-1",
            expectedRevision: 0,
            source: "user",
            command: createCircuitSectionRenumberProjectCommand(
              fixture.sectionId,
              [
                {
                  circuitId: "circuit-1",
                  expectedEquipmentIdentifier: "-1F999",
                  targetEquipmentIdentifier: "-1F2",
                },
                {
                  circuitId: "circuit-2",
                  expectedEquipmentIdentifier: "-1F2",
                  targetEquipmentIdentifier: "-1F1",
                },
                {
                  circuitId: "circuit-3",
                  expectedEquipmentIdentifier: "-1F3",
                  targetEquipmentIdentifier: "-1F3",
                },
              ]
            ),
          }),
        /changed before/
      );
      assert.throws(
        () =>
          store.execute({
            projectId: "project-1",
            expectedRevision: 0,
            source: "user",
            command: createCircuitSectionRenumberProjectCommand(
              fixture.foreignSectionId,
              [
                {
                  circuitId: "circuit-foreign",
                  expectedEquipmentIdentifier: "-1F1",
                  targetEquipmentIdentifier: "-1F2",
                },
              ]
            ),
          }),
        /does not belong to project/
      );
      assert.equal(
        fixture.context.db.select().from(projectRevisions).all()
          .length,
        0
      );
    } finally {
      fixture.context.close();
    }
  });

  it("rejects target identifiers used by another section", () => {
    const fixture = createTestDatabase();
    try {
      const store =
        new CircuitSectionRenumberProjectCommandRepository(
          fixture.context.db
        );
      assert.throws(
        () =>
          store.execute({
            projectId: "project-1",
            expectedRevision: 0,
            source: "user",
            command: createCircuitSectionRenumberProjectCommand(
              fixture.sectionId,
              [
                {
                  circuitId: "circuit-1",
                  expectedEquipmentIdentifier: "-1F1",
                  targetEquipmentIdentifier: "-2F1",
                },
                {
                  circuitId: "circuit-2",
                  expectedEquipmentIdentifier: "-1F2",
                  targetEquipmentIdentifier: "-1F1",
                },
                {
                  circuitId: "circuit-3",
                  expectedEquipmentIdentifier: "-1F3",
                  targetEquipmentIdentifier: "-1F2",
                },
              ]
            ),
          }),
        /already exists in circuit list/
      );
      assert.deepEqual(
        getSectionCircuitState(
          fixture.context,
          fixture.sectionId
        ).map((circuit) => circuit.equipmentIdentifier),
        ["-1F1", "-1F2", "-1F3"]
      );
    } finally {
      fixture.context.close();
    }
  });

  it("rolls back temporary and final identifiers for late history failures", () => {
    const fixture = createTestDatabase();
    try {
      fixture.context.sqlite.exec(`
        CREATE TRIGGER fail_renumber_history
        BEFORE INSERT ON project_history_stack_entries
        BEGIN
          SELECT RAISE(ABORT, 'forced renumber history failure');
        END;
      `);
      const store =
        new CircuitSectionRenumberProjectCommandRepository(
          fixture.context.db
        );
      assert.throws(
        () =>
          store.execute({
            projectId: "project-1",
            expectedRevision: 0,
            source: "user",
            command: createSwapCommand(fixture.sectionId),
          }),
        /forced renumber history failure/
      );
      assert.deepEqual(
        getSectionCircuitState(
          fixture.context,
          fixture.sectionId
        ).map((circuit) => circuit.equipmentIdentifier),
        ["-1F1", "-1F2", "-1F3"]
      );
      assert.equal(
        fixture.context.db.select().from(projectRevisions).all()
          .length,
        0
      );
    } finally {
      fixture.context.close();
    }
  });

  it("rolls back renumbering for a stale project revision", () => {
    const fixture = createTestDatabase();
    try {
      const store =
        new CircuitSectionRenumberProjectCommandRepository(
          fixture.context.db
        );
      assert.throws(
        () =>
          store.execute({
            projectId: "project-1",
            expectedRevision: 1,
            source: "user",
            command: createSwapCommand(fixture.sectionId),
          }),
        /at revision 0, expected 1/
      );
      assert.deepEqual(
        getSectionCircuitState(
          fixture.context,
          fixture.sectionId
        ).map((circuit) => circuit.equipmentIdentifier),
        ["-1F1", "-1F2", "-1F3"]
      );
    } finally {
      fixture.context.close();
    }
  });
});