iloom-flatten/src/hooks/useInventoryData.ts

import { useState, useEffect, useCallback, useRef } from 'react';
import { supabase } from '../supabase/client';
import { useInventoryRealtime } from './useRealtime';
import type {
  Product,
  ProductWithInventory,
  ProductYarnRatio,
  FabricBatch,
  ProductInRecord
} from '../types';

interface UseInventoryDataOptions {
  companyId: string | null;
  activeType: string;
}

interface InventoryDataState {
  products: ProductWithInventory[];
  productRatios: Record<string, ProductYarnRatio[]>;
  batches: FabricBatch[];
  loading: boolean;
  error: Error | null;
}

/**
 * 优化的库存数据获取 Hook
 * 使用缓存和防抖来减少不必要的请求
 */
export function useInventoryData({ companyId, activeType }: UseInventoryDataOptions) {
  const [state, setState] = useState<InventoryDataState>({
    products: [],
    productRatios: {},
    batches: [],
    loading: true,
    error: null
  });

  const cacheRef = useRef<{
    data: InventoryDataState | null;
    timestamp: number;
    key: string;
  }>({ data: null, timestamp: 0, key: '' });

  const CACHE_DURATION = 5000; // 5秒缓存

  const fetchData = useCallback(async () => {
    if (!companyId || activeType !== 'raw_fabric') {
      setState(prev => ({ ...prev, loading: false }));
      return;
    }

    const cacheKey = `${companyId}-${activeType}`;
    const now = Date.now();

    // 检查缓存
    if (
      cacheRef.current.data &&
      cacheRef.current.key === cacheKey &&
      now - cacheRef.current.timestamp < CACHE_DURATION
    ) {
      setState(cacheRef.current.data);
      return;
    }

    setState(prev => ({ ...prev, loading: true, error: null }));

    try {
      // 并行获取数据
      const [productsResult, batchesResult, outboundResult] = await Promise.all([
        // 获取产品列表
        supabase
          .from('products')
          .select('*')
          .eq('company_id', companyId)
          .order('created_at', { ascending: false }),
        // 获取入库记录
        supabase
          .from('product_inventory_records')
          .select('*')
          .eq('company_id', companyId)
          .order('created_at', { ascending: false }),
        // 获取出库记录
        supabase
          .from('product_outbound_records')
          .select('*')
          .eq('company_id', companyId)
          .order('created_at', { ascending: false })
      ]);

      if (productsResult.error) throw productsResult.error;
      if (batchesResult.error) throw batchesResult.error;
      if (outboundResult.error) throw outboundResult.error;

      const productsData = productsResult.data || [];
      const batchesData = batchesResult.data || [];
      const outboundData = outboundResult.data || [];

      // 获取纱线配比
      const productIds = productsData.map(p => p.id);
      let ratiosMap: Record<string, ProductYarnRatio[]> = {};

      if (productIds.length > 0) {
        const { data: ratiosData, error: ratiosError } = await supabase
          .from('product_yarn_ratios')
          .select('*')
          .in('product_id', productIds);

        if (ratiosError) throw ratiosError;

        ratiosData?.forEach((r: ProductYarnRatio) => {
          if (!ratiosMap[r.product_id]) ratiosMap[r.product_id] = [];
          ratiosMap[r.product_id].push(r);
        });
      }

      // 获取纺织厂入库数据
      const fabricCodes = productsData.map(p => p.fabric_code);
      const { data: plansData } = await supabase
        .from('production_plans')
        .select('id, fabric_code, completed_quantity')
        .eq('purchaser_id', companyId)
        .in('fabric_code', fabricCodes);

      const planIds = plansData?.map((p: any) => p.id).filter(Boolean) || [];

      // 获取工厂信息
      const { data: planFactoriesData } = await supabase
        .from('plan_factories')
        .select('plan_id, factory_id')
        .in('plan_id', planIds)
        .eq('factory_type', 'textile');

      const factoryIds = [...new Set((planFactoriesData || []).map(pf => pf.factory_id).filter(Boolean))];
      const { data: factoriesData } = await supabase
        .from('companies')
        .select('id, name')
        .in('id', factoryIds);

      // 建立映射
      const planToFactoryName: Record<string, string> = {};
      planFactoriesData?.forEach((pf: any) => {
        const factory = factoriesData?.find(f => f.id === pf.factory_id);
        if (factory) {
          planToFactoryName[pf.plan_id] = factory.name;
        }
      });

      // 获取入库记录
      let textileInventoryRecords: any[] = [];
      if (planIds.length > 0) {
        const { data: records } = await supabase
          .from('inventory_records')
          .select('plan_id, quantity, rolls, warehouse_location')
          .in('plan_id', planIds);
        textileInventoryRecords = records || [];
      }

      // 处理数据
      const updatedProducts = processInventoryData({
        products: productsData,
        plansData: plansData || [],
        textileInventoryRecords,
        planToFactoryName,
        batchesData,
        outboundData
      });

      const newState: InventoryDataState = {
        products: updatedProducts,
        productRatios: ratiosMap,
        batches: batchesData as FabricBatch[],
        loading: false,
        error: null
      };

      // 更新缓存
      cacheRef.current = {
        data: newState,
        timestamp: now,
        key: cacheKey
      };

      setState(newState);
    } catch (err) {
      setState(prev => ({
        ...prev,
        loading: false,
        error: err instanceof Error ? err : new Error('Unknown error')
      }));
    }
  }, [companyId, activeType]);

  useEffect(() => {
    fetchData();
  }, [fetchData]);

  // 使用统一的实时订阅管理器
  useInventoryRealtime(companyId, () => {
    // 清除缓存并刷新
    cacheRef.current.timestamp = 0;
    fetchData();
  });

  return {
    ...state,
    refetch: fetchData
  };
}

// 处理库存数据的辅助函数
interface ProcessInventoryDataParams {
  products: Product[];
  plansData: any[];
  textileInventoryRecords: any[];
  planToFactoryName: Record<string, string>;
  batchesData: any[];
  outboundData: any[];
}

function processInventoryData({
  products,
  plansData,
  textileInventoryRecords,
  planToFactoryName,
  batchesData,
  outboundData
}: ProcessInventoryDataParams): ProductWithInventory[] {
  // 建立 plan_id 到 fabric_code 的映射
  const planToFabricCode: Record<string, string> = {};
  const planCompletedMap: Record<string, number> = {};
  plansData?.forEach((plan: any) => {
    planToFabricCode[plan.id] = plan.fabric_code;
    planCompletedMap[plan.id] = plan.completed_quantity || 0;
  });

  // 按 plan_id 汇总库存
  const planInventoryMap: Record<string, { meters: number; rolls: number; factory_id: string; factory_name: string }> = {};

  textileInventoryRecords?.forEach((r: any) => {
    const factoryName = planToFactoryName[r.plan_id] || r.warehouse_location || '纺织厂';
    const factoryId = planToFactoryName[r.plan_id] || r.warehouse_location || `factory_${r.plan_id}`;
    if (!planInventoryMap[r.plan_id]) {
      planInventoryMap[r.plan_id] = { meters: 0, rolls: 0, factory_id: factoryId, factory_name: factoryName };
    }
    planInventoryMap[r.plan_id].meters += (Number(r.quantity) || 0);
    planInventoryMap[r.plan_id].rolls += (Number(r.rolls) || 0);
  });

  // 汇总每个坯布码的库存
  const fabricCodeInventory: Record<string, { meters: number; rolls: number }> = {};
  const fabricCodeFactoryInventory: Record<string, Record<string, any>> = {};

  Object.entries(planInventoryMap).forEach(([planId, inventory]) => {
    const fabricCode = planToFabricCode[planId];
    if (fabricCode) {
      if (!fabricCodeInventory[fabricCode]) {
        fabricCodeInventory[fabricCode] = { meters: 0, rolls: 0 };
      }
      fabricCodeInventory[fabricCode].meters += inventory.meters || 0;
      fabricCodeInventory[fabricCode].rolls += inventory.rolls || 0;

      if (!fabricCodeFactoryInventory[fabricCode]) {
        fabricCodeFactoryInventory[fabricCode] = {};
      }
      const factoryKey = inventory.factory_name || 'unknown';
      if (!fabricCodeFactoryInventory[fabricCode][factoryKey]) {
        fabricCodeFactoryInventory[fabricCode][factoryKey] = {
          factory_id: inventory.factory_id || 'unknown',
          factory_name: inventory.factory_name || '纺织厂',
          rolls: 0,
          meters: 0,
          records: []
        };
      }
      fabricCodeFactoryInventory[fabricCode][factoryKey].rolls += inventory.rolls || 0;
      fabricCodeFactoryInventory[fabricCode][factoryKey].meters += inventory.meters || 0;
    }
  });

  // 处理入库记录 - 合并自录入和纺织厂入库
  const inRecordsMap: Record<string, ProductInRecord[]> = {};

  // 1. 先添加自录入的入库记录
  batchesData?.forEach((b: any) => {
    if (!inRecordsMap[b.product_id]) {
      inRecordsMap[b.product_id] = [];
    }
    inRecordsMap[b.product_id].push({
      id: b.id,
      product_id: b.product_id,
      company_id: b.company_id,
      batch_no: b.batch_no,
      rolls: b.rolls || 0,
      meters: b.meters || 0,
      notes: b.notes,
      operator_id: b.operator_id,
      warehouse_id: b.warehouse_id,
      created_at: b.created_at,
      time: b.created_at,
      source: 'self'
    });
  });

  // 2. 添加纺织厂的入库记录
  // 建立 fabric_code 到 product_id 的映射
  const fabricCodeToProductId: Record<string, string> = {};
  products.forEach((p: any) => {
    fabricCodeToProductId[p.fabric_code] = p.id;
  });

  // 将纺织厂入库记录按 fabric_code 关联到对应产品
  textileInventoryRecords?.forEach((r: any) => {
    const fabricCode = planToFabricCode[r.plan_id];
    const productId = fabricCodeToProductId[fabricCode];
    if (productId) {
      if (!inRecordsMap[productId]) {
        inRecordsMap[productId] = [];
      }
      const factoryName = planToFactoryName[r.plan_id] || r.warehouse_location || '纺织厂';
      inRecordsMap[productId].push({
        id: r.id || `${r.plan_id}-${r.created_at}`,
        product_id: productId,
        company_id: r.company_id,
        batch_no: r.batch_no || '-',
        rolls: Number(r.rolls) || 0,
        meters: Number(r.quantity) || 0,
        notes: r.notes || `来自${factoryName}`,
        operator_id: r.operator_id,
        warehouse_id: r.warehouse_id,
        created_at: r.created_at,
        time: r.created_at,
        factory_name: factoryName,
        factory_id: r.plan_id,
        source: 'textile'
      });
    }
  });

  // 按时间排序
  Object.keys(inRecordsMap).forEach(productId => {
    inRecordsMap[productId].sort((a, b) => new Date(b.time || b.created_at).getTime() - new Date(a.time || a.created_at).getTime());
  });

  // 处理出库记录 - 按 product_id 汇总
  const outboundMap: Record<string, { totalRolls: number; totalMeters: number; records: any[] }> = {};
  outboundData?.forEach((r: any) => {
    if (!outboundMap[r.product_id]) {
      outboundMap[r.product_id] = { totalRolls: 0, totalMeters: 0, records: [] };
    }
    outboundMap[r.product_id].totalRolls += Number(r.rolls) || 0;
    outboundMap[r.product_id].totalMeters += Number(r.meters) || 0;
    outboundMap[r.product_id].records.push({
      id: r.id,
      product_id: r.product_id,
      batch_no: r.batch_no,
      rolls: r.rolls,
      meters: r.meters,
      notes: r.notes,
      outbound_type: r.outbound_type,
      washing_plan_id: r.washing_plan_id,
      created_at: r.created_at,
      time: r.created_at,
      // 新增字段：生产批号和接手公司
      source_batch_id: r.source_batch_id,
      recipient_company_id: r.recipient_company_id,
      recipient_company_name: r.recipient_company_name
    });
  });

  // 计算每个产品的自录入库总量（从 batchesData）
  const selfInventoryMap: Record<string, { rolls: number; meters: number }> = {};
  batchesData?.forEach((b: any) => {
    if (!selfInventoryMap[b.product_id]) {
      selfInventoryMap[b.product_id] = { rolls: 0, meters: 0 };
    }
    selfInventoryMap[b.product_id].rolls += Number(b.rolls) || 0;
    selfInventoryMap[b.product_id].meters += Number(b.meters) || 0;
  });

  // 更新产品数据 - 扣除出库数量
  return products.map((p: any) => {
    const textileInventory = fabricCodeInventory[p.fabric_code] || { meters: 0, rolls: 0 };
    const factoryInventories = fabricCodeFactoryInventory[p.fabric_code] || {};
    // 使用实时计算的入库记录，而不是 products 表中的字段
    const selfInventory = selfInventoryMap[p.id] || { rolls: 0, meters: 0 };
    const outboundInfo = outboundMap[p.id] || { totalRolls: 0, totalMeters: 0, records: [] };

    // 计算实际可用库存（入库 - 出库）
    const totalInRolls = selfInventory.rolls + textileInventory.rolls;
    const totalInMeters = selfInventory.meters + textileInventory.meters;
    const availableRolls = Math.max(0, totalInRolls - outboundInfo.totalRolls);
    const availableMeters = Math.max(0, totalInMeters - outboundInfo.totalMeters);

    return {
      ...p,
      production_price: p.production_price || 0,
      raw_fabric_rolls: availableRolls,
      raw_fabric_meters: availableMeters,
      total_stock: availableMeters,
      factory_inventories: factoryInventories,
      in_records: inRecordsMap[p.id] || [],
      out_records: outboundInfo.records,
      total_in_rolls: totalInRolls,
      total_in_meters: totalInMeters,
      total_out_rolls: outboundInfo.totalRolls,
      total_out_meters: outboundInfo.totalMeters
    };
  }) as ProductWithInventory[];
}