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

import type { ContractorEntry } from '@shared/contracts/contractors';
import type { ContractorPendingEntryResponse } from '../../../shared/api/repositories/ContractorsRepository';
import type { ContractorUnifiedEntry } from '@shared/contracts/contractors';

/**
 * Calculate unified list combining entries and pending entries
 * Logic adopted 1:1 from Blacklist feature
 */
export function calculateUnifiedList(
  entries: ContractorEntry[],
  pendingEntries: ContractorPendingEntryResponse[]
): ContractorUnifiedEntry[] {
  // 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: ContractorUnifiedEntry[] = [];
  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,
          contractNumber: pending.contractNumber,
          phone: pending.phone,
          email: pending.email,
          webLink: pending.webLink,
          managerName: pending.managerName,
          managerPhone: pending.managerPhone,
          managerEmail: pending.managerEmail,
          comment: pending.comment,
          
          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,
            contractNumber: original.contractNumber,
            phone: original.phone,
            email: original.email,
            webLink: original.webLink,
            managerName: original.managerName,
            managerPhone: original.managerPhone,
            managerEmail: original.managerEmail,
            comment: original.comment,
          },
          // Добавляем creatorName для отображения в UI
          ...(pending.creatorName && { creatorName: pending.creatorName }),
        });
      }
    }
  }

  // 4. Обрабатываем pending записи без targetId (новые записи)
  const newEntries: ContractorUnifiedEntry[] = pendingEntries
    .filter((p) => p.targetId === null)
    .map((p) => ({
      id: p.id,
      name: p.name,
      category: p.category,
      contractNumber: p.contractNumber,
      phone: p.phone,
      email: p.email,
      webLink: p.webLink,
      managerName: p.managerName,
      managerPhone: p.managerPhone,
      managerEmail: p.managerEmail,
      comment: p.comment,
      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()
  );
}