import { useMemo } from 'react'

import type { UseStoreDataReturn, StoreData, TotalsData, StoreDataField } from '../types'

/**
 * ⚠️ КРИТИЧНО ВАЖНЫЙ ХУК - СОДЕРЖИТ КЛЮЧЕВУЮ БИЗНЕС-ЛОГИКУ ⚠️
 * 
 * Хук для создания и обработки данных магазинов склада
 * 
 * ВАЖНО: Этот хук содержит сложную логику группировки:
 * - Товары группируются по названию с суммированием количества
 * - Расходники группируются по СЕЛЛЕРУ-ВЛАДЕЛЬЦУ (НЕ по названию!)
 * - Строгая валидация типа SELLER_CONSUMABLES
 * - Сохранены все console.warn для отладки
 */
export function useStoreData(
  sellerPartners: any[],
  allProducts: any[],
  sellerSupplies: any[],
  searchTerm: string,
  sortField: StoreDataField,
  sortOrder: 'asc' | 'desc',
): UseStoreDataReturn {
  
  // === СОЗДАНИЕ СТРУКТУРИРОВАННЫХ ДАННЫХ СКЛАДА ===
  
  const storeData: StoreData[] = useMemo(() => {
    if (!sellerPartners.length && !allProducts.length) return []

    // 1. ГРУППИРОВКА ТОВАРОВ ПО НАЗВАНИЮ (суммирование количества)
    const groupedProducts = new Map<
      string,
      {
        name: string
        totalQuantity: number
        suppliers: string[]
        categories: string[]
        prices: number[]
        articles: string[]
        originalProducts: any[]
      }
    >()

    // Группируем товары из allProducts
    allProducts.forEach((product: any) => {
      const productName = product.name
      const quantity = product.orderedQuantity || 0

      if (groupedProducts.has(productName)) {
        const existing = groupedProducts.get(productName)!
        existing.totalQuantity += quantity
        existing.suppliers.push(product.organization?.name || product.organization?.fullName || 'Неизвестно')
        existing.categories.push(product.category?.name || 'Без категории')
        existing.prices.push(product.price || 0)
        existing.articles.push(product.article || '')
        existing.originalProducts.push(product)
      } else {
        groupedProducts.set(productName, {
          name: productName,
          totalQuantity: quantity,
          suppliers: [product.organization?.name || product.organization?.fullName || 'Неизвестно'],
          categories: [product.category?.name || 'Без категории'],
          prices: [product.price || 0],
          articles: [product.article || ''],
          originalProducts: [product],
        })
      }
    })

    // 2. ⚠️ КРИТИЧНО: ГРУППИРОВКА РАСХОДНИКОВ ПО СЕЛЛЕРУ-ВЛАДЕЛЬЦУ ⚠️
    const suppliesByOwner = new Map<string, Map<string, { quantity: number; ownerName: string }>>()

    sellerSupplies.forEach((supply: any) => {
      const ownerId = supply.sellerOwner?.id
      const ownerName = supply.sellerOwner?.name || supply.sellerOwner?.fullName || 'Неизвестный селлер'
      const supplyName = supply.name
      const currentStock = supply.currentStock || 0
      const supplyType = supply.type

      // ⚠️ КРИТИЧНО: Строгая проверка согласно правилам
      if (!ownerId || supplyType !== 'SELLER_CONSUMABLES') {
        console.warn('⚠️ ОТФИЛЬТРОВАН расходник в компоненте (нарушение правил):', {
          id: supply.id,
          name: supplyName,
          type: supplyType,
          ownerId,
          ownerName,
          reason: !ownerId ? 'нет sellerOwner.id' : 'тип не SELLER_CONSUMABLES',
        })
        return // Пропускаем согласно ПРАВИЛУ 6 из секции 11.6
      }

      // Инициализируем группу для селлера, если её нет
      if (!suppliesByOwner.has(ownerId)) {
        suppliesByOwner.set(ownerId, new Map())
      }

      const ownerSupplies = suppliesByOwner.get(ownerId)!

      if (ownerSupplies.has(supplyName)) {
        // Суммируем количество, если расходник уже есть у этого селлера
        const existing = ownerSupplies.get(supplyName)!
        existing.quantity += currentStock
      } else {
        // Добавляем новый расходник для этого селлера
        ownerSupplies.set(supplyName, {
          quantity: currentStock,
          ownerName: ownerName,
        })
      }
    })

    // Логирование группировки (сохраняем из оригинала)
    console.warn('📊 Группировка товаров и расходников:', {
      groupedProductsCount: groupedProducts.size,
      suppliesByOwnerCount: suppliesByOwner.size,
      groupedProducts: Array.from(groupedProducts.entries()).map(([name, data]) => ({
        name,
        totalQuantity: data.totalQuantity,
        suppliersCount: data.suppliers.length,
        uniqueSuppliers: [...new Set(data.suppliers)],
      })),
    })

    // 3. СОЗДАНИЕ ВИРТУАЛЬНЫХ ПАРТНЕРОВ НА ОСНОВЕ ТОВАРОВ
    const uniqueProductNames = Array.from(groupedProducts.keys())
    const virtualPartners = Math.max(1, Math.min(sellerPartners.length, Math.ceil(uniqueProductNames.length / 8)))

    return Array.from({ length: virtualPartners }, (_, index) => {
      const startIndex = index * 8
      const endIndex = Math.min(startIndex + 8, uniqueProductNames.length)
      const partnerProductNames = uniqueProductNames.slice(startIndex, endIndex)

      // Создаем товары для этого партнера
      const items = partnerProductNames.map((productName, itemIndex) => {
        const productData = groupedProducts.get(productName)!
        const itemProducts = productData.totalQuantity

        // Ищем расходники конкретного селлера-владельца
        let itemSuppliesQuantity = 0
        let suppliesOwners: string[] = []

        const realSeller = sellerPartners[index]
        if (realSeller?.id && suppliesByOwner.has(realSeller.id)) {
          const sellerSupplies = suppliesByOwner.get(realSeller.id)!
          const matchingSupply = sellerSupplies.get(productName)

          if (matchingSupply) {
            itemSuppliesQuantity = matchingSupply.quantity
            suppliesOwners = [matchingSupply.ownerName]
          }
        }

        return {
          id: `grouped-${productName}-${itemIndex}`,
          name: productName,
          article: productData.articles[0] || `ART${(index + 1).toString().padStart(2, '0')}${(itemIndex + 1).toString().padStart(2, '0')}`,
          productPlace: `A${index + 1}-${itemIndex + 1}`,
          productQuantity: itemProducts,
          goodsPlace: `B${index + 1}-${itemIndex + 1}`,
          goodsQuantity: 0,
          defectsPlace: `C${index + 1}-${itemIndex + 1}`,
          defectsQuantity: 0,
          sellerSuppliesPlace: `D${index + 1}-${itemIndex + 1}`,
          sellerSuppliesQuantity: itemSuppliesQuantity,
          sellerSuppliesOwners: suppliesOwners,
          pvzReturnsPlace: `E${index + 1}-${itemIndex + 1}`,
          pvzReturnsQuantity: 0,
        }
      })

      // Подсчитываем суммы
      const totalProducts = items.reduce((sum, item) => sum + item.productQuantity, 0)
      const totalSellerSupplies = items.reduce((sum, item) => sum + item.sellerSuppliesQuantity, 0)

      const partnerName = sellerPartners[index]
        ? sellerPartners[index].name || sellerPartners[index].fullName || `Селлер ${index + 1}`
        : `Склад ${index + 1}`

      return {
        id: sellerPartners[index]?.id || `virtual-partner-${index}`,
        name: partnerName,
        logo: sellerPartners[index]?.logo,
        avatar: sellerPartners[index]?.avatar,
        products: totalProducts,
        goods: 0,
        defects: 0,
        sellerSupplies: totalSellerSupplies,
        pvzReturns: 0,
        // Изменения за сутки (пока нули)
        productsChange: 0,
        goodsChange: 0,
        defectsChange: 0,
        sellerSuppliesChange: 0,
        pvzReturnsChange: 0,
        items,
      }
    })
  }, [sellerPartners, allProducts, sellerSupplies])

  // === ФИЛЬТРАЦИЯ И СОРТИРОВКА ===
  
  const filteredAndSortedStores = useMemo(() => {
    let filtered = storeData

    // Фильтрация по поисковому термину
    if (searchTerm) {
      filtered = filtered.filter(store => 
        store.name.toLowerCase().includes(searchTerm.toLowerCase()),
      )
    }

    // Сортировка
    const sorted = [...filtered].sort((a, b) => {
      const aValue = a[sortField]
      const bValue = b[sortField]

      if (typeof aValue === 'string' && typeof bValue === 'string') {
        return sortOrder === 'asc' 
          ? aValue.localeCompare(bValue)
          : bValue.localeCompare(aValue)
      }

      if (typeof aValue === 'number' && typeof bValue === 'number') {
        return sortOrder === 'asc' ? aValue - bValue : bValue - aValue
      }

      return 0
    })

    return sorted
  }, [storeData, searchTerm, sortField, sortOrder])

  // === ПОДСЧЕТ ОБЩИХ ИТОГОВ ===
  
  const totals: TotalsData = useMemo(() => {
    return filteredAndSortedStores.reduce(
      (acc, store) => ({
        products: acc.products + store.products,
        goods: acc.goods + store.goods,
        defects: acc.defects + store.defects,
        sellerSupplies: acc.sellerSupplies + store.sellerSupplies,
        pvzReturns: acc.pvzReturns + store.pvzReturns,
        productsChange: acc.productsChange + store.productsChange,
        goodsChange: acc.goodsChange + store.goodsChange,
        defectsChange: acc.defectsChange + store.defectsChange,
        sellerSuppliesChange: acc.sellerSuppliesChange + store.sellerSuppliesChange,
        pvzReturnsChange: acc.pvzReturnsChange + store.pvzReturnsChange,
      }),
      {
        products: 0,
        goods: 0,
        defects: 0,
        sellerSupplies: 0,
        pvzReturns: 0,
        productsChange: 0,
        goodsChange: 0,
        defectsChange: 0,
        sellerSuppliesChange: 0,
        pvzReturnsChange: 0,
      },
    )
  }, [filteredAndSortedStores])

  const isProcessing = false // Можно добавить состояние загрузки при необходимости

  return {
    storeData,
    filteredAndSortedStores,
    totals,
    isProcessing,
  }
}