Subcontractor Cycle Logic

class SubcontractorService {

  /** Create a new work order for a subcontractor */
  async createWorkOrder(scId, projectId, scopeItems) {
    const sc = await SubcontractorMaster.findById(scId);
    if (!sc || sc.status !== 'empanelled') throw new Error('SC not empanelled');
    const totalValue = scopeItems.reduce((s, i) => s + i.quantity * i.rate, 0);
    await CommitmentService.checkBudgetAvailability(projectId, totalValue);
    const wo = await WorkOrder.create({
      sc_id: scId, project_id: projectId,
      wo_number: await generateWONumber(projectId),
      original_value: totalValue, revised_value: totalValue,
      retention_percent: 5, sd_percent: 2.5, ld_rate: 0.5,
      status: 'draft'
    });
    for (const item of scopeItems) {
      await WOItem.create({
        wo_id: wo.wo_id, boq_item_id: item.boqItemId,
        description: item.description, uom: item.uom,
        quantity: item.quantity, rate: item.rate, amount: item.quantity * item.rate
      });
    }
    return wo;
  }

  /** Record daily measurement in LBHQ format */
  async recordMeasurement(woId, items) {
    const wo = await WorkOrder.findById(woId);
    const dmb = await DMB.create({
      wo_id: woId, dmb_number: await generateDMBNumber(woId),
      dmb_date: new Date(), status: 'draft'
    });
    let total = 0;
    for (const m of items) {
      const woItem = await WOItem.findById(m.woItemId);
      const qty = m.length * m.breadth * m.height * m.nos;
      const cumQty = await DMBItem.sumQty(m.woItemId);
      if (cumQty + qty > woItem.quantity) throw new Error('Exceeds WO qty');
      const amount = qty * woItem.rate;
      await DMBItem.create({
        dmb_id: dmb.dmb_id, wo_item_id: m.woItemId,
        length: m.length, breadth: m.breadth, height: m.height,
        quantity: qty, rate: woItem.rate, amount
      });
      total += amount;
    }
    await dmb.update({ total_value: total });
    return dmb;
  }

  /** Generate RA Bill from certified DMBs for a given period */
  async generateRABill(woId, fromDate, toDate) {
    const wo = await WorkOrder.findById(woId);
    const certifiedDMBs = await DMB.findAll({
      wo_id: woId, status: 'certified',
      dmb_date: { between: [fromDate, toDate] }
    });
    const grossAmount = certifiedDMBs.reduce((s, d) => s + d.total_value, 0);
    const prevCumulative = await RABill.maxCumulative(woId);
    if (prevCumulative + grossAmount > wo.revised_value)
      throw new Error('Cumulative exceeds WO value');
    const bill = await RABill.create({
      wo_id: woId, sc_id: wo.sc_id,
      bill_number: await generateBillNumber(woId),
      gross_amount: grossAmount,
      cumulative_amount: prevCumulative + grossAmount,
      status: 'draft'
    });
    const deductions = await this.calculateDeductions(bill.bill_id);
    return { bill, deductions };
  }

  /** Calculate all deductions for an RA bill */
  async calculateDeductions(billId) {
    const bill = await RABill.findById(billId);
    const wo = await WorkOrder.findById(bill.wo_id);
    const retention = bill.gross_amount * wo.retention_percent / 100;
    const sd = bill.gross_amount * wo.sd_percent / 100;
    const advRecovery = Math.min(
      bill.gross_amount * 10 / 100,
      await AdvanceBalance.remaining(wo.wo_id)
    );
    const ld = await LDCalculator.compute(wo.wo_id);
    const materialRecovery = await MaterialIssue.unrecovered(wo.wo_id);
    const netAmount = bill.gross_amount - retention - sd - advRecovery - ld - materialRecovery;
    await bill.update({ retention_amount: retention, advance_recovery: advRecovery, net_amount: netAmount });
    await SCRetention.upsert({ wo_id: wo.wo_id, retention_amount: literal('retention_amount + ' + retention) });
    return { retention, sd, advRecovery, ld, materialRecovery, netAmount };
  }

  /** Process final settlement after DLP expiry */
  async processSettlement(woId) {
    const wo = await WorkOrder.findById(woId);
    const totalBilled = await RABill.sumGross(woId);
    const totalPaid = await RABill.sumNet(woId);
    const retention = await SCRetention.findByWO(woId);
    const ldApplied = await LDCalculator.totalLD(woId);
    const settlement = await SCSettlement.create({
      wo_id: woId, total_billed: totalBilled, total_paid: totalPaid,
      retention_released: retention.balance, ld_applied: ldApplied,
      net_settlement: retention.balance - ldApplied
    });
    await this.releaseRetention(woId, retention.balance);
    await CommitmentService.closeCommitment(woId);
    return settlement;
  }

  /** Release retention amount after defect liability period */
  async releaseRetention(woId, amount) {
    const retention = await SCRetention.findByWO(woId);
    if (amount > retention.balance) throw new Error('Release exceeds balance');
    await retention.update({
      released_amount: literal('released_amount + ' + amount),
      balance: literal('balance - ' + amount)
    });
    // Create AP invoice for retention release payment
    await APService.createInvoice({
      vendor_id: (await WorkOrder.findById(woId)).sc_id,
      amount, type: 'retention_release', reference: 'WO-' + woId
    });
    return retention;
  }
}