Procurement Cycle Logic

class ProcurementService {

  /** Step 1: Create Material Requisition — validates stock & BOM */
  async createMR(projectId, items) {
    for (const item of items) {
      const stock = await StockLedger.getBalance(item.material_id, projectId);
      const bomReq = await BOM.getRequirement(projectId, item.material_id);
      if (stock.available >= item.qty) throw new Error('Sufficient stock exists — issue from store');
      item.net_qty = item.qty - stock.available;
    }
    const mr = await MaterialRequisition.create({
      project_id: projectId, mr_number: await Sequence.next('MR'),
      mr_date: new Date(), status: 'draft', items
    });
    return mr;
  }

  /** Step 2: Convert approved MR(s) into Purchase Requisition */
  async convertMRtoPR(mrId) {
    const mr = await MaterialRequisition.findById(mrId);
    if (mr.status !== 'approved') throw new Error('MR must be approved');
    // Group MR lines by vendor preference / material category
    const groups = groupBy(mr.items, 'material_category');
    const prs = [];
    for (const [category, lines] of Object.entries(groups)) {
      const pr = await PurchaseRequisition.create({
        project_id: mr.project_id, mr_id: mrId,
        pr_number: await Sequence.next('PR'),
        buyer_id: await BuyerAssignment.resolve(category),
        status: 'open', items: lines
      });
      prs.push(pr);
    }
    return prs;
  }

  /** Step 3: Create RFQ and send to shortlisted vendors */
  async createRFQ(prId, vendorIds) {
    if (vendorIds.length < 3) throw new Error('Minimum 3 vendors required for RFQ');
    const pr = await PurchaseRequisition.findById(prId);
    const rfq = await RFQ.create({
      pr_id: prId, project_id: pr.project_id,
      rfq_number: await Sequence.next('RFQ'),
      closing_date: addDays(new Date(), 7),
      status: 'open', vendor_ids: vendorIds
    });
    await NotificationService.sendRFQInvitations(rfq, vendorIds);
    return rfq;
  }

  /** Step 4: Evaluate quotations and generate comparative statement */
  async evaluateQuotations(rfqId) {
    const quotes = await Quotation.findByRFQ(rfqId);
    const scored = quotes.map(q => ({
      vendor_id: q.vendor_id,
      price_score:  normalize(q.total, quotes, 'total')  * 0.6,
      delivery_score: normalize(q.lead_days, quotes, 'lead_days') * 0.2,
      quality_score:  q.vendor_rating * 0.1,
      terms_score:   normalize(q.credit_days, quotes, 'credit_days') * 0.1,
    }));
    scored.forEach(s => s.total_score = s.price_score + s.delivery_score
                                        + s.quality_score + s.terms_score);
    scored.sort((a, b) => b.total_score - a.total_score);
    return { comparative_statement: scored, recommended: scored[0] };
  }

  /** Step 5: Create Purchase Order — checks budget, creates commitment */
  async createPO(prId, vendorId) {
    const pr = await PurchaseRequisition.findById(prId);
    const poTotal = pr.items.reduce((s, i) => s + i.qty * i.unit_rate, 0);
    // Budget availability check
    await CommitmentService.checkBudgetAvailability(
      pr.project_id, pr.cost_code_id, poTotal
    );
    // Check for duplicate active PO for same PR
    const existing = await PurchaseOrder.findOne({
      pr_id: prId, vendor_id: vendorId, status: ['draft', 'approved']
    });
    if (existing) throw new Error('Active PO already exists for this PR + vendor');

    const po = await PurchaseOrder.create({
      pr_id: prId, vendor_id: vendorId, project_id: pr.project_id,
      po_number: await Sequence.next('PO'),
      total_amount: poTotal, status: 'draft'
    });
    // On approval → create financial commitment
    await CommitmentService.createCommitment('PO', po.po_id);
    return po;
  }

  /** Step 6: Process GRN — quality check, stock update */
  async processGRN(poId, receivedItems) {
    const po = await PurchaseOrder.findById(poId);
    for (const item of receivedItems) {
      const poLine = await POLine.findOne({ po_id: poId, material_id: item.material_id });
      const variance = Math.abs(item.received_qty - poLine.ordered_qty) / poLine.ordered_qty;
      if (variance > 0.05) throw new Error('GRN qty exceeds ±5% tolerance');
      // Quality inspection
      item.qc_status = await QualityService.inspect(item);
    }
    const grn = await GRN.create({
      po_id: poId, store_id: po.delivery_store_id,
      grn_number: await Sequence.next('GRN'),
      total_value: receivedItems.reduce((s, i) => s + i.received_qty * i.unit_rate, 0),
      status: 'accepted', items: receivedItems.filter(i => i.qc_status === 'pass')
    });
    // Update inventory stock ledger
    await InventoryService.updateStock(grn);
    // Post accrual entry
    await CommitmentService.createAccrual(po.commitment_id, grn.grn_id, grn.total_value);
    return grn;
  }

  /** Step 7: Three-way match — validates qty and price within tolerance */
  async threeWayMatch(poId, grnId, invoiceId) {
    const po = await PurchaseOrder.findById(poId);
    const grn = await GRN.findById(grnId);
    const inv = await APInvoice.findById(invoiceId);

    const qtyMatch  = Math.abs(grn.total_qty - inv.total_qty) / grn.total_qty <= 0.05;
    const rateMatch = Math.abs(po.unit_rate - inv.unit_rate) / po.unit_rate <= 0.02;
    const match_status = (qtyMatch && rateMatch) ? 'matched' : 'hold';

    const match = await ThreeWayMatch.create({
      po_id: poId, grn_id: grnId, invoice_id: invoiceId, match_status
    });
    if (match_status === 'matched') {
      await APInvoice.approve(invoiceId);
      await CommitmentService.onInvoiceBooked(po.commitment_id, inv.total_amount);
    }
    return match;
  }
}