shanxia2.0/web-admin/src/composables/usePlPlanViewDetail.ts

import { getContract } from '@/api/crm/contract'
import type { ContractVO } from '@/api/crm/contract/types'
import {
  inventoryApi,
  type InventoryRecord,
  type InventoryWeighingRecord
} from '@/api/db/inventory'
import {
  planApi,
  transportApi,
  type Plan,
  type PlanProduct,
  type Transport,
  type TransportInventoryLink
} from '@/api/pl'
import type { PlanFormProductRow } from '@/composables/usePlContractToPlan'
import { loadVehicleViewBundle, type VehicleViewBundle } from '@/composables/usePlVehicleViewDetail'
import { enrichPlanProductsHazardFromCrm } from '@/composables/usePlToxicProductCertCheck'
import { pickBxData } from '@/utils/http/bx'

export interface PlPlanTransportDibangRow {
  link: TransportInventoryLink
  inventory: InventoryRecord | null
  weighing: InventoryWeighingRecord | null
}

export function mapPlanProductToFormRow(item: PlanProduct, index: number): PlanFormProductRow {
  return {
    productId: String(item.productId || index),
    productNo: item.productNo || String(item.productId || index),
    productName: item.productName || '',
    model: item.model,
    categoryName: item.categoryName,
    unit: item.unit || '吨',
    quantity: Number(item.quantity || item.inboundEstimateQty || item.outboundEstimateQty || 0),
    actualQty: Number(
      item.actualQty ?? item.quantity ?? item.inboundEstimateQty ?? item.outboundEstimateQty ?? 0
    ),
    packageSpec: item.packageSpec,
    deliveryMethod: item.deliveryMethod,
    taxRate: item.taxRate != null ? Number(item.taxRate) : undefined,
    taxPrice: item.taxPrice ?? item.inboundPrice ?? item.outboundPrice,
    taxSubtotal: item.taxSubtotal ?? item.inboundAmount ?? item.outboundAmount,
    taxAmount: item.taxAmount,
    remark: item.remark,
    isExplosive: Number(item.isExplosive ?? 0),
    isToxic: Number(item.isToxic ?? 0)
  }
}

export function buildContractSnapshotFromPlan(data: Plan, rows: PlanFormProductRow[]): ContractVO {
  return {
    id: data.contractId || '',
    contractNo: data.contractNo || '',
    contractName: data.contractNo || '',
    customerId: data.customerId || '',
    customerName: data.customerName || '',
    contactName: data.contactName || '',
    contactMobile: data.contactPhone || '',
    contractType: '',
    amount: data.totalAmount || 0,
    signDate: '',
    startDate: data.contractStartDate || '',
    endDate: data.contractEndDate || '',
    contractPeriod: 0,
    status: '',
    approvalStatus: '',
    contractFile: '',
    attachmentFiles: '',
    ownerUserId: '',
    ownerUserName: '',
    receivedAmount: 0,
    unreceivedAmount: 0,
    invoiceAmount: 0,
    uninvoiceAmount: 0,
    partyA: data.partyA || data.supplierName || '',
    partyAAddress: '',
    partyAContact: '',
    partyAMobile: '',
    partyALegalPerson: '',
    partyAAgent: '',
    partyAPhoneFax: '',
    partyABank: '',
    partyAAccount: '',
    supplierName: data.supplierName,
    settlementMethod: data.settlementMethod,
    partyB: data.partyB || data.customerName || '',
    partyBAddress: '',
    partyBContact: data.contactName || '',
    partyBMobile: data.contactPhone || '',
    partyBLegalPerson: '',
    partyBAgent: '',
    partyBPhoneFax: '',
    partyBBank: '',
    partyBAccount: '',
    paymentTerms: '',
    deliveryTerms: '',
    contractTerms: '',
    invalidReason: '',
    invalidTime: '',
    createTime: '',
    remark: data.remark || '',
    products: rows as unknown as ContractVO['products']
  }
}

function normalizeContractSnapshot(raw: unknown): ContractVO | null {
  if (!raw || typeof raw !== 'object') return null
  const payload = raw as Record<string, unknown>
  const nested = payload.data
  if (nested && typeof nested === 'object') {
    return nested as ContractVO
  }
  return raw as ContractVO
}

export function usePlPlanViewDetail() {
  const loading = ref(false)
  const plan = ref<Plan | null>(null)
  const products = ref<PlanProduct[]>([])
  const transport = ref<Transport | null>(null)
  const vehicleBundle = ref<VehicleViewBundle | null>(null)
  const contractSnapshot = ref<ContractVO | null>(null)
  const dibangRows = ref<PlPlanTransportDibangRow[]>([])

  async function loadDibangRows(planId: string, data: Plan) {
    dibangRows.value = []
    if (data.followStatus === 'cancelled' || data.transportStatus !== 'arranged') {
      return
    }
    try {
      const infoRes = await planApi.getArrangeInfo(planId)
      const info = pickBxData<{ inventoryRecords?: TransportInventoryLink[] }>(infoRes)
      const links = info?.inventoryRecords || []
      if (!links.length) return

      dibangRows.value = await Promise.all(
        links.map(async (link) => {
          let inventory: InventoryRecord | null = null
          let weighing: InventoryWeighingRecord | null = null
          try {
            inventory = await inventoryApi.get(link.dbInventoryId)
          } catch {
            inventory = null
          }
          try {
            const related = await inventoryApi.getRelated(link.dbInventoryId)
            weighing = related?.weighing ?? null
          } catch {
            weighing = null
          }
          return { link, inventory, weighing }
        })
      )
    } catch {
      dibangRows.value = []
    }
  }

  async function loadDetail(planId: string) {
    loading.value = true
    plan.value = null
    products.value = []
    transport.value = null
    vehicleBundle.value = null
    contractSnapshot.value = null
    dibangRows.value = []
    try {
      const res = await planApi.get(planId)
      const data = pickBxData<Plan>(res)
      plan.value = data || null

      const rows = (data?.products || []).map(mapPlanProductToFormRow)
      products.value = await enrichPlanProductsHazardFromCrm(data?.products || [])

      if (data?.contractId) {
        try {
          const contractRes = await getContract(data.contractId)
          contractSnapshot.value = normalizeContractSnapshot(contractRes.data ?? contractRes)
        } catch {
          contractSnapshot.value = buildContractSnapshotFromPlan(data, rows)
        }
      } else if (data) {
        contractSnapshot.value = buildContractSnapshotFromPlan(data, rows)
      }

      const detailTasks: Promise<void>[] = []

      if (data?.transportId) {
        detailTasks.push(
          transportApi
            .get(data.transportId)
            .then((transportRes) => {
              transport.value = pickBxData<Transport>(transportRes)
            })
            .catch(() => {
              transport.value = null
            })
        )
      }

      if (data?.vehicleId) {
        detailTasks.push(
          loadVehicleViewBundle(data.vehicleId)
            .then((bundle) => {
              vehicleBundle.value = bundle
            })
            .catch(() => {
              vehicleBundle.value = null
            })
        )
      }

      if (detailTasks.length) {
        await Promise.all(detailTasks)
      }

      if (data) {
        await loadDibangRows(planId, data)
      }
    } finally {
      loading.value = false
    }
  }

  function resetDetail() {
    plan.value = null
    products.value = []
    transport.value = null
    vehicleBundle.value = null
    contractSnapshot.value = null
    dibangRows.value = []
  }

  return {
    loading,
    plan,
    products,
    transport,
    vehicleBundle,
    contractSnapshot,
    dibangRows,
    loadDetail,
    resetDetail
  }
}