import { and, asc, eq, inArray } from "drizzle-orm";
import type { AppDatabase } from "../database-context.js";
import { circuitDeviceRows } from "../schema/circuit-device-rows.js";
import { circuitLists } from "../schema/circuit-lists.js";
import { circuits } from "../schema/circuits.js";
import { distributionBoards } from "../schema/distribution-boards.js";

export class CircuitDeviceRowRepository {
  constructor(private readonly database: AppDatabase) {}

  async listByCircuitList(circuitIds: string[]) {
    if (!circuitIds.length) {
      return [];
    }
    return this.database
      .select()
      .from(circuitDeviceRows)
      .where(inArray(circuitDeviceRows.circuitId, circuitIds))
      .orderBy(asc(circuitDeviceRows.sortOrder));
  }

  async listLinkedByProjectDevice(projectId: string, projectDeviceId: string) {
    return this.database
      .select({
        id: circuitDeviceRows.id,
        circuitId: circuitDeviceRows.circuitId,
        linkedProjectDeviceId: circuitDeviceRows.linkedProjectDeviceId,
        sortOrder: circuitDeviceRows.sortOrder,
        name: circuitDeviceRows.name,
        displayName: circuitDeviceRows.displayName,
        phaseType: circuitDeviceRows.phaseType,
        connectionKind: circuitDeviceRows.connectionKind,
        costGroup: circuitDeviceRows.costGroup,
        category: circuitDeviceRows.category,
        level: circuitDeviceRows.level,
        roomId: circuitDeviceRows.roomId,
        roomNumberSnapshot: circuitDeviceRows.roomNumberSnapshot,
        roomNameSnapshot: circuitDeviceRows.roomNameSnapshot,
        quantity: circuitDeviceRows.quantity,
        manualQuantity: circuitDeviceRows.manualQuantity,
        powerPerUnit: circuitDeviceRows.powerPerUnit,
        simultaneityFactor: circuitDeviceRows.simultaneityFactor,
        cosPhi: circuitDeviceRows.cosPhi,
        remark: circuitDeviceRows.remark,
        overriddenFields: circuitDeviceRows.overriddenFields,
        equipmentIdentifier: circuits.equipmentIdentifier,
        circuitDisplayName: circuits.displayName,
        circuitListId: circuitLists.id,
        circuitListName: circuitLists.name,
        distributionBoardId: distributionBoards.id,
        distributionBoardName: distributionBoards.name,
      })
      .from(circuitDeviceRows)
      .innerJoin(circuits, eq(circuitDeviceRows.circuitId, circuits.id))
      .innerJoin(circuitLists, eq(circuits.circuitListId, circuitLists.id))
      .innerJoin(distributionBoards, eq(circuitLists.distributionBoardId, distributionBoards.id))
      .where(
        and(
          eq(circuitDeviceRows.linkedProjectDeviceId, projectDeviceId),
          eq(circuitLists.projectId, projectId)
        )
      )
      .orderBy(asc(distributionBoards.name), asc(circuits.equipmentIdentifier), asc(circuitDeviceRows.sortOrder));
  }

}