// src/client/entities/inventory/model/unifiedList.ts
// Unified list calculation logic for inventory entries
// COPIED FROM CONTRACTOR IMPLEMENTATION (src/client/entities/contractor/model/unifiedList.ts)

import type { InventoryEntry } from '@shared/contracts/inventory';
import type { InventoryPendingEntryResponse } from '../../../shared/api/repositories/InventoryRepository';
import type { InventoryUnifiedEntry } from '@shared/contracts/inventory';

/**
 * Calculate unified list combining entries and pending entries
 * Logic adopted 1:1 from Contractor feature
 */
export function calculateUnifiedList(
  entries: InventoryEntry[],
  pendingEntries: InventoryPendingEntryResponse[]
): InventoryUnifiedEntry[] {
  // 1. Собираем ID оригинальных записей, которые редактируются
  const targetIds = new Set(
    pendingEntries
      .filter((p) => p.targetId !== null)
      .map((p) => p.targetId!)
  );

  // 2. Создаем Map для быстрого доступа к оригинальным записям
  const entriesMap = new Map(
    entries.map((e) => [e.id, e])
  );

  // 3. Обрабатываем pending записи с targetId (редактирования и удаления)
  const modifiedEntries: InventoryUnifiedEntry[] = [];
  for (const pending of pendingEntries) {
    if (pending.targetId) {
      const original = entriesMap.get(pending.targetId);
      if (original) {
        const isDeleteRequest = pending.status === 'to_delete';

        modifiedEntries.push({
          // Для isPendingDelete используем pending.id, иначе original.id
          id: isDeleteRequest ? pending.id : original.id,
          name: pending.name,
          category: pending.category,
          quantity: pending.quantity,
          unit: pending.unit,
          location: pending.location,
          comment: pending.comment,
          weightPerUnit: pending.weightPerUnit,
          manufacturer: pending.manufacturer,
          model: pending.model,
          serialNumber: pending.serialNumber,
          orderingLink: pending.orderingLink,
          articleNumber: pending.articleNumber,

          isApproved: !!original.isApproved,
          createdBy: pending.createdBy,
          createdAt: original.createdAt,
          updatedAt: pending.updatedAt,
          archivedAt: original.archivedAt,
          targetId: pending.targetId,
          reviewedBy: pending.reviewedBy || null,
          reviewedAt: pending.reviewedAt || null,
          rejectionReason: pending.rejectionReason || null,

          isModified: !isDeleteRequest,
          isNew: false,
          isPendingDelete: isDeleteRequest,

          originalData: {
            name: original.name,
            category: original.category,
            quantity: original.quantity,
            unit: original.unit,
            location: original.location,
            comment: original.comment,
            weightPerUnit: original.weightPerUnit,
            manufacturer: original.manufacturer,
            model: original.model,
            serialNumber: original.serialNumber,
            orderingLink: original.orderingLink,
            articleNumber: original.articleNumber,
          },
          // Добавляем creatorName для отображения в UI
          ...(pending.creatorName && { creatorName: pending.creatorName }),
        });
      }
    }
  }

  // 4. Обрабатываем pending записи без targetId (новые записи)
  const newEntries: InventoryUnifiedEntry[] = pendingEntries
    .filter((p) => p.targetId === null)
    .map((p) => ({
      id: p.id,
      name: p.name,
      category: p.category,
      quantity: p.quantity,
      unit: p.unit,
      location: p.location,
      comment: p.comment,
      weightPerUnit: p.weightPerUnit,
      manufacturer: p.manufacturer,
      model: p.model,
      serialNumber: p.serialNumber,
      orderingLink: p.orderingLink,
      articleNumber: p.articleNumber,
      isApproved: false,
      status: p.status,
      targetId: p.targetId,
      createdBy: p.createdBy,
      creatorName: p.creatorName,
      reviewedBy: p.reviewedBy,
      reviewedAt: p.reviewedAt,
      rejectionReason: p.rejectionReason,
      createdAt: p.createdAt,
      updatedAt: p.updatedAt,
      archivedAt: null,
      isModified: false,
      isNew: true,
      isPendingDelete: false,
      ...(p.creatorName && { creatorName: p.creatorName }),
    }));

  // 5. Фильтруем оригинальные записи: оставляем только те, у которых нет pending версии
  const filteredEntries = entries.filter((e) => !targetIds.has(e.id));

  // 6. Добавляем флаг isApproved для записей без флагов (для старых данных)
  const entriesWithApproved = filteredEntries.map((e) => ({
    ...e,
    isApproved: !!e.isApproved,
  }));

  // 7. Объединяем и сортируем по createdAt
  return [...entriesWithApproved, ...modifiedEntries, ...newEntries].sort(
    (a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime()
  );
}