geMoldInsight/src/inventory/services/purchase_demand_service.py

"""采购需求自动推导服务

销售订单确认 → 按 BOM 展开物料需求 → 对比当前库存 → 自动生成采购建议（缺多少、建议供应商、预计金额）
"""
from math import ceil
from decimal import Decimal
from typing import List

from fastapi import HTTPException
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy import select, func

from shared.models.database import (
    User,
    Product,
    ProductMaterial,
    SalesOrder,
    SalesOrderItem,
    Inventory,
    MaterialSupplier,
    Supplier,
    PurchaseOrder,
    PurchaseOrderItem,
)
from ..utils import generate_order_no
from ..schemas.purchase_demand_schemas import (
    PurchaseDemandItemResponse,
    PurchaseDemandResponse,
    PurchaseDemandConvertRequest,
    PurchaseDemandConvertResponse,
    PurchaseOrderCreatedResponse,
)


class PurchaseDemandService:
    """采购需求推导服务"""

    @staticmethod
    async def calculate_demands(
        db_session: AsyncSession,
        sales_order_ids: List[int],
    ) -> PurchaseDemandResponse:
        """
        核心算法：
        1. 批量查询销售订单 + 明细项
        2. 按 BOM 展开所有成品所需的物料（含损耗率）
        3. 聚合跨订单的同一物料需求量
        4. 对比当前库存，计算缺口
        5. 查询 MaterialSupplier 推荐主供应商
        """
        # ── 1. 查询销售订单 ──
        order_result = await db_session.execute(
            select(SalesOrder).where(SalesOrder.id.in_(sales_order_ids))
        )
        orders = order_result.scalars().all()
        if not orders:
            raise HTTPException(status_code=404, detail="未找到有效的销售订单")

        order_ids_found = [o.id for o in orders]
        order_nos = [o.order_no for o in orders]

        # ── 2. 查询订单明细（成品列表） ──
        item_result = await db_session.execute(
            select(SalesOrderItem).where(SalesOrderItem.order_id.in_(order_ids_found))
        )
        order_items = item_result.scalars().all()
        if not order_items:
            return PurchaseDemandResponse(
                source_order_ids=order_ids_found,
                source_order_nos=order_nos,
            )

        # ── 3. 按 BOM 展开物料需求 ──
        finished_ids = list({int(i.product_id) for i in order_items})
        bom_result = await db_session.execute(
            select(ProductMaterial, Product)
            .join(Product, ProductMaterial.material_product_id == Product.id)
            .where(ProductMaterial.finished_product_id.in_(finished_ids))
            .where(Product.is_active == True)
            .where(Product.item_type == "material")
        )
        bom_rows = bom_result.all()
        if not bom_rows:
            return PurchaseDemandResponse(
                source_order_ids=order_ids_found,
                source_order_nos=order_nos,
            )

        # 按 finished_product_id 分组 BOM
        bom_by_finished: dict = {}
        for bom, material in bom_rows:
            bom_by_finished.setdefault(int(bom.finished_product_id), []).append((bom, material))

        # 聚合需求量：material_id → { material, required_qty }
        required_qty_map: dict = {}
        for order_item in order_items:
            bom_items = bom_by_finished.get(int(order_item.product_id)) or []
            for bom, material in bom_items:
                qty = (
                    Decimal(str(order_item.quantity))
                    * Decimal(str(bom.quantity or 0))
                    * (1 + Decimal(str(bom.loss_rate or 0)))
                )
                entry = required_qty_map.setdefault(
                    material.id,
                    {"material": material, "required_qty": Decimal("0")},
                )
                entry["required_qty"] += qty

        if not required_qty_map:
            return PurchaseDemandResponse(
                source_order_ids=order_ids_found,
                source_order_nos=order_nos,
            )

        # ── 4. 对比当前库存 ──
        material_ids = list(required_qty_map.keys())
        stock_result = await db_session.execute(
            select(Inventory.product_id, func.coalesce(func.sum(Inventory.quantity), 0))
            .where(Inventory.product_id.in_(material_ids))
            .group_by(Inventory.product_id)
        )
        stock_map = {row[0]: Decimal(str(row[1] or 0)) for row in stock_result.all()}

        # ── 5. 查询物料-供应商关联（推荐主供应商） ──
        ms_result = await db_session.execute(
            select(MaterialSupplier, Supplier)
            .join(Supplier, MaterialSupplier.supplier_id == Supplier.id)
            .where(MaterialSupplier.product_id.in_(material_ids))
            .where(Supplier.is_active == True)
            .order_by(MaterialSupplier.is_primary.desc(), MaterialSupplier.id.asc())
        )
        ms_rows = ms_result.all()
        # 每个物料取第一个（优先 is_primary=True）
        supplier_map: dict = {}
        for ms, supplier in ms_rows:
            if ms.product_id not in supplier_map:
                supplier_map[ms.product_id] = {
                    "supplier_id": supplier.id,
                    "supplier_name": supplier.name,
                    "lead_time": ms.lead_time,
                }

        # ── 6. 组装响应 ──
        items: List[PurchaseDemandItemResponse] = []
        total_estimated_cost = Decimal("0")
        shortage_count = 0

        for material_id, entry in required_qty_map.items():
            material = entry["material"]
            required_qty = int(ceil(entry["required_qty"]))
            available_qty = stock_map.get(material_id, Decimal("0"))
            shortage_qty = max(required_qty - int(available_qty), 0)
            unit_cost = Decimal(str(material.cost_price or 0))
            estimated_cost = Decimal(str(shortage_qty)) * unit_cost
            total_estimated_cost += estimated_cost

            if shortage_qty > 0:
                shortage_count += 1

            suggested = supplier_map.get(material_id)
            items.append(
                PurchaseDemandItemResponse(
                    material_id=material.id,
                    material_sku=material.sku,
                    material_name=material.name,
                    required_quantity=Decimal(str(required_qty)),
                    available_quantity=available_qty,
                    shortage_quantity=Decimal(str(shortage_qty)),
                    unit_cost=unit_cost,
                    estimated_cost=estimated_cost,
                    suggested_supplier_id=suggested["supplier_id"] if suggested else None,
                    suggested_supplier_name=suggested["supplier_name"] if suggested else None,
                    supplier_lead_time=suggested["lead_time"] if suggested else None,
                )
            )

        # 按缺口数量降序排列（最缺的排最前）
        items.sort(key=lambda x: (x.shortage_quantity, x.estimated_cost), reverse=True)

        return PurchaseDemandResponse(
            items=items,
            total_estimated_cost=total_estimated_cost,
            shortage_count=shortage_count,
            source_order_ids=order_ids_found,
            source_order_nos=order_nos,
        )

    @staticmethod
    async def convert_to_purchase_orders(
        db_session: AsyncSession,
        payload: PurchaseDemandConvertRequest,
        current_user: User,
    ) -> PurchaseDemandConvertResponse:
        """将采购需求按供应商分组，每组生成一张草稿采购单（status=pending）。

        只转换 quantity>0 的条目；物料/供应商需存在且启用。
        事务由 get_db_session 统一提交（路由返回成功即 commit，异常即 rollback）。
        """
        valid_items = [it for it in payload.items if it.quantity > 0]
        skipped = len(payload.items) - len(valid_items)
        if not valid_items:
            raise HTTPException(status_code=400, detail="没有可转换的有效需求（数量需 > 0）")

        material_ids = {it.material_id for it in valid_items}
        supplier_ids = {it.supplier_id for it in valid_items}

        # 校验物料
        mat_result = await db_session.execute(
            select(Product)
            .where(Product.id.in_(material_ids))
            .where(Product.is_active == True)
            .where(Product.item_type == "material")
        )
        materials = {m.id: m for m in mat_result.scalars().all()}
        if len(materials) != len(material_ids):
            raise HTTPException(status_code=400, detail="部分物料不存在或非物料类型")

        # 校验供应商
        sup_result = await db_session.execute(
            select(Supplier)
            .where(Supplier.id.in_(supplier_ids))
            .where(Supplier.is_active == True)
        )
        suppliers = {s.id: s for s in sup_result.scalars().all()}
        if len(suppliers) != len(supplier_ids):
            raise HTTPException(status_code=400, detail="部分供应商不存在或已停用")

        # 按供应商分组生成采购单
        groups: dict = {}
        for it in valid_items:
            groups.setdefault(it.supplier_id, []).append(it)

        created: List[PurchaseOrderCreatedResponse] = []
        for supplier_id, items in groups.items():
            po = PurchaseOrder(
                order_no=generate_order_no("PO"),
                supplier_id=supplier_id,
                expected_date=payload.expected_date,
                remark=payload.remark or "由采购需求一键生成",
                operator_id=current_user.id,
                status="pending",
            )
            db_session.add(po)
            await db_session.flush()

            total = Decimal("0")
            for it in items:
                amount = Decimal(str(it.quantity)) * Decimal(str(it.unit_cost))
                total += amount
                db_session.add(
                    PurchaseOrderItem(
                        order_id=po.id,
                        product_id=it.material_id,
                        quantity=int(it.quantity),
                        unit_price=Decimal(str(it.unit_cost)),
                        amount=amount,
                    )
                )
            po.total_amount = total
            created.append(
                PurchaseOrderCreatedResponse(
                    purchase_order_id=po.id,
                    order_no=po.order_no,
                    supplier_id=supplier_id,
                    supplier_name=suppliers[supplier_id].name,
                    item_count=len(items),
                    total_amount=total,
                )
            )
        await db_session.flush()
        return PurchaseDemandConvertResponse(created_orders=created, skipped=skipped)


purchase_demand_service = PurchaseDemandService()