mrp/server/src/modules/inventory/service.ts

import type {
  InventoryBomLineDto,
  InventoryBomLineInput,
  InventoryItemDetailDto,
  InventoryItemInput,
  InventoryStockBalanceDto,
  WarehouseDetailDto,
  WarehouseInput,
  WarehouseLocationOptionDto,
  WarehouseLocationDto,
  WarehouseLocationInput,
  WarehouseSummaryDto,
  InventoryItemStatus,
  InventoryItemSummaryDto,
  InventoryTransactionDto,
  InventoryTransactionInput,
  InventoryTransactionType,
  InventoryItemType,
  InventoryUnitOfMeasure,
} from "@mrp/shared/dist/inventory/types.js";

import { prisma } from "../../lib/prisma.js";

type BomLineRecord = {
  id: string;
  quantity: number;
  unitOfMeasure: string;
  notes: string;
  position: number;
  componentItem: {
    id: string;
    sku: string;
    name: string;
  };
};

type InventoryDetailRecord = {
  id: string;
  sku: string;
  name: string;
  description: string;
  type: string;
  status: string;
  unitOfMeasure: string;
  isSellable: boolean;
  isPurchasable: boolean;
  defaultCost: number | null;
  notes: string;
  createdAt: Date;
  updatedAt: Date;
  bomLines: BomLineRecord[];
  inventoryTransactions: InventoryTransactionRecord[];
};

type InventoryTransactionRecord = {
  id: string;
  transactionType: string;
  quantity: number;
  reference: string;
  notes: string;
  createdAt: Date;
  warehouse: {
    id: string;
    code: string;
    name: string;
  };
  location: {
    id: string;
    code: string;
    name: string;
  };
  createdBy: {
    firstName: string;
    lastName: string;
  } | null;
};

type WarehouseLocationRecord = {
  id: string;
  code: string;
  name: string;
  notes: string;
};

type WarehouseDetailRecord = {
  id: string;
  code: string;
  name: string;
  notes: string;
  createdAt: Date;
  updatedAt: Date;
  locations: WarehouseLocationRecord[];
};

function mapBomLine(record: BomLineRecord): InventoryBomLineDto {
  return {
    id: record.id,
    componentItemId: record.componentItem.id,
    componentSku: record.componentItem.sku,
    componentName: record.componentItem.name,
    quantity: record.quantity,
    unitOfMeasure: record.unitOfMeasure as InventoryUnitOfMeasure,
    notes: record.notes,
    position: record.position,
  };
}

function mapWarehouseLocation(record: WarehouseLocationRecord): WarehouseLocationDto {
  return {
    id: record.id,
    code: record.code,
    name: record.name,
    notes: record.notes,
  };
}

function getSignedQuantity(transactionType: InventoryTransactionType, quantity: number) {
  return transactionType === "RECEIPT" || transactionType === "ADJUSTMENT_IN" ? quantity : -quantity;
}

function mapInventoryTransaction(record: InventoryTransactionRecord): InventoryTransactionDto {
  const transactionType = record.transactionType as InventoryTransactionType;
  const signedQuantity = getSignedQuantity(transactionType, record.quantity);

  return {
    id: record.id,
    transactionType,
    quantity: record.quantity,
    signedQuantity,
    notes: record.notes,
    reference: record.reference,
    createdAt: record.createdAt.toISOString(),
    warehouseId: record.warehouse.id,
    warehouseCode: record.warehouse.code,
    warehouseName: record.warehouse.name,
    locationId: record.location.id,
    locationCode: record.location.code,
    locationName: record.location.name,
    createdByName: record.createdBy ? `${record.createdBy.firstName} ${record.createdBy.lastName}`.trim() : "System",
  };
}

function buildStockBalances(transactions: InventoryTransactionRecord[]): InventoryStockBalanceDto[] {
  const grouped = new Map<string, InventoryStockBalanceDto>();

  for (const transaction of transactions) {
    const transactionType = transaction.transactionType as InventoryTransactionType;
    const signedQuantity = getSignedQuantity(transactionType, transaction.quantity);
    const key = `${transaction.warehouse.id}:${transaction.location.id}`;
    const current = grouped.get(key);

    if (current) {
      current.quantityOnHand += signedQuantity;
      continue;
    }

    grouped.set(key, {
      warehouseId: transaction.warehouse.id,
      warehouseCode: transaction.warehouse.code,
      warehouseName: transaction.warehouse.name,
      locationId: transaction.location.id,
      locationCode: transaction.location.code,
      locationName: transaction.location.name,
      quantityOnHand: signedQuantity,
    });
  }

  return [...grouped.values()]
    .filter((balance) => balance.quantityOnHand !== 0)
    .sort((left, right) =>
      `${left.warehouseCode}-${left.locationCode}`.localeCompare(`${right.warehouseCode}-${right.locationCode}`)
    );
}

function mapSummary(record: {
  id: string;
  sku: string;
  name: string;
  type: string;
  status: string;
  unitOfMeasure: string;
  isSellable: boolean;
  isPurchasable: boolean;
  updatedAt: Date;
  _count: { bomLines: number };
}): InventoryItemSummaryDto {
  return {
    id: record.id,
    sku: record.sku,
    name: record.name,
    type: record.type as InventoryItemType,
    status: record.status as InventoryItemStatus,
    unitOfMeasure: record.unitOfMeasure as InventoryUnitOfMeasure,
    isSellable: record.isSellable,
    isPurchasable: record.isPurchasable,
    bomLineCount: record._count.bomLines,
    updatedAt: record.updatedAt.toISOString(),
  };
}

function mapDetail(record: InventoryDetailRecord): InventoryItemDetailDto {
  const recentTransactions = record.inventoryTransactions
    .slice()
    .sort((left, right) => right.createdAt.getTime() - left.createdAt.getTime())
    .map(mapInventoryTransaction);
  const stockBalances = buildStockBalances(record.inventoryTransactions);

  return {
    ...mapSummary({
      id: record.id,
      sku: record.sku,
      name: record.name,
      type: record.type,
      status: record.status,
      unitOfMeasure: record.unitOfMeasure,
      isSellable: record.isSellable,
      isPurchasable: record.isPurchasable,
      updatedAt: record.updatedAt,
      _count: { bomLines: record.bomLines.length },
    }),
    description: record.description,
    defaultCost: record.defaultCost,
    notes: record.notes,
    createdAt: record.createdAt.toISOString(),
    bomLines: record.bomLines.slice().sort((a, b) => a.position - b.position).map(mapBomLine),
    onHandQuantity: stockBalances.reduce((sum, balance) => sum + balance.quantityOnHand, 0),
    stockBalances,
    recentTransactions,
  };
}

function mapWarehouseSummary(record: {
  id: string;
  code: string;
  name: string;
  updatedAt: Date;
  _count: { locations: number };
}): WarehouseSummaryDto {
  return {
    id: record.id,
    code: record.code,
    name: record.name,
    locationCount: record._count.locations,
    updatedAt: record.updatedAt.toISOString(),
  };
}

function mapWarehouseDetail(record: WarehouseDetailRecord): WarehouseDetailDto {
  return {
    ...mapWarehouseSummary({
      id: record.id,
      code: record.code,
      name: record.name,
      updatedAt: record.updatedAt,
      _count: { locations: record.locations.length },
    }),
    notes: record.notes,
    createdAt: record.createdAt.toISOString(),
    locations: record.locations.map(mapWarehouseLocation),
  };
}

interface InventoryListFilters {
  query?: string;
  status?: InventoryItemStatus;
  type?: InventoryItemType;
}

function buildWhereClause(filters: InventoryListFilters) {
  const trimmedQuery = filters.query?.trim();

  return {
    ...(filters.status ? { status: filters.status } : {}),
    ...(filters.type ? { type: filters.type } : {}),
    ...(trimmedQuery
      ? {
          OR: [
            { sku: { contains: trimmedQuery } },
            { name: { contains: trimmedQuery } },
            { description: { contains: trimmedQuery } },
          ],
        }
      : {}),
  };
}

function normalizeBomLines(bomLines: InventoryBomLineInput[]) {
  return bomLines
    .map((line, index) => ({
      componentItemId: line.componentItemId,
      quantity: Number(line.quantity),
      unitOfMeasure: line.unitOfMeasure,
      notes: line.notes,
      position: line.position ?? (index + 1) * 10,
    }))
    .filter((line) => line.componentItemId.trim().length > 0);
}

function normalizeWarehouseLocations(locations: WarehouseLocationInput[]) {
  return locations
    .map((location) => ({
      code: location.code.trim(),
      name: location.name.trim(),
      notes: location.notes,
    }))
    .filter((location) => location.code.length > 0 && location.name.length > 0);
}

async function validateBomLines(parentItemId: string | null, bomLines: InventoryBomLineInput[]) {
  const normalized = normalizeBomLines(bomLines);

  if (normalized.some((line) => line.quantity <= 0)) {
    return { ok: false as const, reason: "BOM line quantity must be greater than zero." };
  }

  if (normalized.some((line) => !Number.isInteger(line.quantity))) {
    return { ok: false as const, reason: "BOM line quantity must be a whole number." };
  }

  if (parentItemId && normalized.some((line) => line.componentItemId === parentItemId)) {
    return { ok: false as const, reason: "An item cannot reference itself in its BOM." };
  }

  const componentIds = [...new Set(normalized.map((line) => line.componentItemId))];
  if (componentIds.length === 0) {
    return { ok: true as const, bomLines: normalized };
  }

  const existingComponents = await prisma.inventoryItem.findMany({
    where: {
      id: {
        in: componentIds,
      },
    },
    select: {
      id: true,
    },
  });

  if (existingComponents.length !== componentIds.length) {
    return { ok: false as const, reason: "One or more BOM components do not exist." };
  }

  return { ok: true as const, bomLines: normalized };
}

export async function listInventoryItems(filters: InventoryListFilters = {}) {
  const items = await prisma.inventoryItem.findMany({
    where: buildWhereClause(filters),
    include: {
      _count: {
        select: {
          bomLines: true,
        },
      },
    },
    orderBy: [{ sku: "asc" }],
  });

  return items.map(mapSummary);
}

export async function listInventoryItemOptions() {
  const items = await prisma.inventoryItem.findMany({
    where: {
      status: {
        not: "OBSOLETE",
      },
    },
    select: {
      id: true,
      sku: true,
      name: true,
    },
    orderBy: [{ sku: "asc" }],
  });

  return items.map((item) => ({
    id: item.id,
    sku: item.sku,
    name: item.name,
  }));
}

export async function getInventoryItemById(itemId: string) {
  const item = await prisma.inventoryItem.findUnique({
    where: { id: itemId },
    include: {
      bomLines: {
        include: {
          componentItem: {
            select: {
              id: true,
              sku: true,
              name: true,
            },
          },
        },
        orderBy: [{ position: "asc" }, { createdAt: "asc" }],
      },
      inventoryTransactions: {
        include: {
          warehouse: {
            select: {
              id: true,
              code: true,
              name: true,
            },
          },
          location: {
            select: {
              id: true,
              code: true,
              name: true,
            },
          },
          createdBy: {
            select: {
              firstName: true,
              lastName: true,
            },
          },
        },
        orderBy: [{ createdAt: "desc" }],
      },
    },
  });

  return item ? mapDetail(item) : null;
}

export async function listWarehouseLocationOptions() {
  const warehouses = await prisma.warehouse.findMany({
    include: {
      locations: {
        orderBy: [{ code: "asc" }],
      },
    },
    orderBy: [{ code: "asc" }],
  });

  return warehouses.flatMap((warehouse): WarehouseLocationOptionDto[] =>
    warehouse.locations.map((location) => ({
      warehouseId: warehouse.id,
      warehouseCode: warehouse.code,
      warehouseName: warehouse.name,
      locationId: location.id,
      locationCode: location.code,
      locationName: location.name,
    }))
  );
}

export async function createInventoryTransaction(itemId: string, payload: InventoryTransactionInput, createdById?: string | null) {
  const item = await prisma.inventoryItem.findUnique({
    where: { id: itemId },
    select: { id: true },
  });

  if (!item) {
    return { ok: false as const, reason: "Inventory item was not found." };
  }

  const location = await prisma.warehouseLocation.findUnique({
    where: { id: payload.locationId },
    select: {
      id: true,
      warehouseId: true,
    },
  });

  if (!location || location.warehouseId !== payload.warehouseId) {
    return { ok: false as const, reason: "Warehouse location is invalid for the selected warehouse." };
  }

  const detail = await getInventoryItemById(itemId);
  if (!detail) {
    return { ok: false as const, reason: "Inventory item was not found." };
  }

  const signedQuantity = getSignedQuantity(payload.transactionType, payload.quantity);
  if (signedQuantity < 0 && detail.onHandQuantity + signedQuantity < 0) {
    return { ok: false as const, reason: "Transaction would drive on-hand quantity below zero." };
  }

  await prisma.inventoryTransaction.create({
    data: {
      itemId,
      warehouseId: payload.warehouseId,
      locationId: payload.locationId,
      transactionType: payload.transactionType,
      quantity: payload.quantity,
      reference: payload.reference.trim(),
      notes: payload.notes,
      createdById: createdById ?? null,
    },
  });

  const nextDetail = await getInventoryItemById(itemId);
  return nextDetail ? { ok: true as const, item: nextDetail } : { ok: false as const, reason: "Unable to load updated inventory item." };
}

export async function createInventoryItem(payload: InventoryItemInput) {
  const validatedBom = await validateBomLines(null, payload.bomLines);
  if (!validatedBom.ok) {
    return null;
  }

  const item = await prisma.inventoryItem.create({
    data: {
      sku: payload.sku,
      name: payload.name,
      description: payload.description,
      type: payload.type,
      status: payload.status,
      unitOfMeasure: payload.unitOfMeasure,
      isSellable: payload.isSellable,
      isPurchasable: payload.isPurchasable,
      defaultCost: payload.defaultCost,
      notes: payload.notes,
      bomLines: validatedBom.bomLines.length
        ? {
            create: validatedBom.bomLines,
          }
        : undefined,
    },
    select: {
      id: true,
    },
  });

  return getInventoryItemById(item.id);
}

export async function updateInventoryItem(itemId: string, payload: InventoryItemInput) {
  const existingItem = await prisma.inventoryItem.findUnique({
    where: { id: itemId },
  });

  if (!existingItem) {
    return null;
  }

  const validatedBom = await validateBomLines(itemId, payload.bomLines);
  if (!validatedBom.ok) {
    return null;
  }

  const item = await prisma.inventoryItem.update({
    where: { id: itemId },
    data: {
      sku: payload.sku,
      name: payload.name,
      description: payload.description,
      type: payload.type,
      status: payload.status,
      unitOfMeasure: payload.unitOfMeasure,
      isSellable: payload.isSellable,
      isPurchasable: payload.isPurchasable,
      defaultCost: payload.defaultCost,
      notes: payload.notes,
      bomLines: {
        deleteMany: {},
        create: validatedBom.bomLines,
      },
    },
    select: {
      id: true,
    },
  });

  return getInventoryItemById(item.id);
}

export async function listWarehouses() {
  const warehouses = await prisma.warehouse.findMany({
    include: {
      _count: {
        select: {
          locations: true,
        },
      },
    },
    orderBy: [{ code: "asc" }],
  });

  return warehouses.map(mapWarehouseSummary);
}

export async function getWarehouseById(warehouseId: string) {
  const warehouse = await prisma.warehouse.findUnique({
    where: { id: warehouseId },
    include: {
      locations: {
        orderBy: [{ code: "asc" }],
      },
    },
  });

  return warehouse ? mapWarehouseDetail(warehouse) : null;
}

export async function createWarehouse(payload: WarehouseInput) {
  const locations = normalizeWarehouseLocations(payload.locations);

  const warehouse = await prisma.warehouse.create({
    data: {
      code: payload.code.trim(),
      name: payload.name.trim(),
      notes: payload.notes,
      locations: locations.length
        ? {
            create: locations,
          }
        : undefined,
    },
    include: {
      locations: {
        orderBy: [{ code: "asc" }],
      },
    },
  });

  return mapWarehouseDetail(warehouse);
}

export async function updateWarehouse(warehouseId: string, payload: WarehouseInput) {
  const existingWarehouse = await prisma.warehouse.findUnique({
    where: { id: warehouseId },
  });

  if (!existingWarehouse) {
    return null;
  }

  const locations = normalizeWarehouseLocations(payload.locations);

  const warehouse = await prisma.warehouse.update({
    where: { id: warehouseId },
    data: {
      code: payload.code.trim(),
      name: payload.name.trim(),
      notes: payload.notes,
      locations: {
        deleteMany: {},
        create: locations,
      },
    },
    include: {
      locations: {
        orderBy: [{ code: "asc" }],
      },
    },
  });

  return mapWarehouseDetail(warehouse);
}