leistungsbilanz-ts/src/db/repositories/project-settings-project-command.repository.ts

import { and, eq, isNotNull } from "drizzle-orm";
import {
  assertProjectSettingsUpdateProjectCommand,
  createProjectSettingsUpdateProjectCommand,
  legacyProjectSettingsUpdateCommandSchemaVersion,
  normalizeProjectSettingsValues,
  previousProjectSettingsUpdateCommandSchemaVersion,
  type ProjectSettingsValues,
} from "../../domain/models/project-settings-project-command.model.js";
import type {
  ExecuteProjectSettingsUpdateCommandInput,
  ProjectSettingsProjectCommandStore,
} from "../../domain/ports/project-settings-project-command.store.js";
import type { AppDatabase } from "../database-context.js";
import { projects } from "../schema/projects.js";
import { distributionBoards } from "../schema/distribution-boards.js";
import { executeProjectCommandTransaction } from "./project-command-transaction.persistence.js";

export class ProjectSettingsProjectCommandRepository
  implements ProjectSettingsProjectCommandStore
{
  constructor(private readonly database: AppDatabase) {}

  executeUpdate(input: ExecuteProjectSettingsUpdateCommandInput) {
    assertProjectSettingsUpdateProjectCommand(input.command);
    return executeProjectCommandTransaction(
      this.database,
      input,
      (tx) => this.applyCommand(tx, input)
    );
  }

  private applyCommand(
    tx: AppDatabase,
    input: ExecuteProjectSettingsUpdateCommandInput
  ) {
    const current = tx
      .select()
      .from(projects)
      .where(eq(projects.id, input.projectId))
      .get();
    if (!current) {
      throw new Error("Project not found.");
    }
    const target = normalizeProjectSettingsValues(input.command, current);
    if (projectSettingsEqual(current, target)) {
      throw new Error("Project settings did not change.");
    }

    const inverse =
      input.command.schemaVersion ===
      legacyProjectSettingsUpdateCommandSchemaVersion
        ? {
            schemaVersion: legacyProjectSettingsUpdateCommandSchemaVersion,
            type: input.command.type,
            payload: {
              singlePhaseVoltageV: current.singlePhaseVoltageV,
              threePhaseVoltageV: current.threePhaseVoltageV,
            },
          }
        : input.command.schemaVersion ===
            previousProjectSettingsUpdateCommandSchemaVersion
          ? {
              schemaVersion:
                previousProjectSettingsUpdateCommandSchemaVersion,
              type: input.command.type,
              payload: {
                name: current.name,
                internalProjectNumber: current.internalProjectNumber,
                externalProjectNumber: current.externalProjectNumber,
                buildingOwner: current.buildingOwner,
                description: current.description,
                singlePhaseVoltageV: current.singlePhaseVoltageV,
                threePhaseVoltageV: current.threePhaseVoltageV,
              },
            }
          : createProjectSettingsUpdateProjectCommand({
            name: current.name,
            internalProjectNumber: current.internalProjectNumber,
            externalProjectNumber: current.externalProjectNumber,
            buildingOwner: current.buildingOwner,
            description: current.description,
            singlePhaseVoltageV: current.singlePhaseVoltageV,
            threePhaseVoltageV: current.threePhaseVoltageV,
            enabledDistributionBoardSupplyTypes:
              current.enabledDistributionBoardSupplyTypes,
          });
    assertDisabledSupplyTypesAreUnused(tx, input.projectId, target);
    const updated = tx
      .update(projects)
      .set(target)
      .where(eq(projects.id, input.projectId))
      .run();
    if (updated.changes !== 1) {
      throw new Error("Project changed before settings update.");
    }

    return inverse;
  }
}

function projectSettingsEqual(
  current: ProjectSettingsValues,
  target: ProjectSettingsValues
) {
  return (
    current.name === target.name &&
    current.internalProjectNumber === target.internalProjectNumber &&
    current.externalProjectNumber === target.externalProjectNumber &&
    current.buildingOwner === target.buildingOwner &&
    current.description === target.description &&
    current.singlePhaseVoltageV === target.singlePhaseVoltageV &&
    current.threePhaseVoltageV === target.threePhaseVoltageV
    && sameSupplyTypes(
      current.enabledDistributionBoardSupplyTypes,
      target.enabledDistributionBoardSupplyTypes
    )
  );
}

function sameSupplyTypes(
  left: ProjectSettingsValues["enabledDistributionBoardSupplyTypes"],
  right: ProjectSettingsValues["enabledDistributionBoardSupplyTypes"]
) {
  return (
    left.length === right.length &&
    left.every((value, index) => value === right[index])
  );
}

function assertDisabledSupplyTypesAreUnused(
  database: AppDatabase,
  projectId: string,
  target: ProjectSettingsValues
) {
  const used = database
    .select({ supplyType: distributionBoards.supplyType })
    .from(distributionBoards)
    .where(
      and(
        eq(distributionBoards.projectId, projectId),
        isNotNull(distributionBoards.supplyType)
      )
    )
    .all();
  const disabledUsedTypes = [
    ...new Set(
      used
        .map((entry) => entry.supplyType)
        .filter(
          (supplyType) =>
            supplyType !== null &&
            !target.enabledDistributionBoardSupplyTypes.some(
              (enabled) => enabled === supplyType
            )
        )
    ),
  ];
  if (disabledUsedTypes.length > 0) {
    throw new Error(
      `Verwendete Netzarten können nicht deaktiviert werden: ${disabledUsedTypes.join(", ")}.`
    );
  }
}