EVM & Cost Control Logic

class EVMService {

  /** Establish the Performance Measurement Baseline for a project */
  async establishBaseline(projectId) {
    const project = await Project.findById(projectId);
    const wbsItems = await WBS.findAll({ project_id: projectId });
    const totalBAC = wbsItems.reduce((sum, w) => sum + w.budget, 0);

    // Deactivate any existing current baseline
    await PMBaseline.update({ is_current: false }, {
      where: { project_id: projectId, is_current: true }
    });

    const baseline = await PMBaseline.create({
      project_id: projectId,
      total_bac: totalBAC,
      time_phased_budget: this.distributeByPeriod(wbsItems, project),
      is_current: true
    });

    // Create control accounts for each WBS element
    for (const wbs of wbsItems) {
      await ControlAccount.create({
        project_id: projectId, wbs_id: wbs.id,
        bac: wbs.budget, eac: wbs.budget, etc: wbs.budget,
        acwp: 0, bcwp: 0, bcws: 0, spi: 1.0, cpi: 1.0
      });
    }
    return baseline;
  }

  /** Collect period data — BCWS, BCWP, ACWP for all control accounts */
  async collectPeriodData(projectId, periodDate) {
    const baseline = await PMBaseline.findOne({
      project_id: projectId, is_current: true
    });
    const accounts = await ControlAccount.findAll({ project_id: projectId });

    for (const ca of accounts) {
      const bcws = this.getBCWSFromBaseline(baseline, ca.wbs_id, periodDate);
      const bcwp = await this.calculateBCWP(ca.ca_id, periodDate);
      const acwp = await FinanceService.getActualCost(ca.wbs_id, periodDate);

      await this.calculateEVM(ca.ca_id, periodDate, bcws, bcwp, acwp);
    }
    await this.generateSCurve(projectId, periodDate);
    await this.checkThresholds(projectId);
  }

  /** Calculate all EVM metrics for a control account */
  async calculateEVM(caId, periodDate, bcws, bcwp, acwp) {
    const ca = await ControlAccount.findById(caId);
    const sv = bcwp - bcws;                      // Schedule Variance
    const cv = bcwp - acwp;                      // Cost Variance
    const spi = bcws > 0 ? bcwp / bcws : 1.0;   // Schedule Perf Index
    const cpi = acwp > 0 ? bcwp / acwp : 1.0;   // Cost Perf Index
    const eac = cpi > 0 ? ca.bac / cpi : ca.bac; // Estimate at Completion
    const etc = eac - acwp;                      // Estimate to Complete
    const vac = ca.bac - eac;                    // Variance at Completion
    const tcpi = (ca.bac - bcwp) > 0             // To-Complete Perf Index
      ? (ca.bac - bcwp) / (ca.bac - acwp) : 1.0;

    // Persist period EVM data
    await EarnedValue.create({
      project_id: ca.project_id, ca_id: caId, period_date: periodDate,
      bcws, bcwp, acwp, sv, cv, spi, cpi, eac
    });

    // Update control account running totals
    await ControlAccount.update(caId, {
      bcws, bcwp, acwp, spi, cpi, eac, etc
    });

    return { sv, cv, spi, cpi, eac, etc, vac, tcpi };
  }

  /** Generate S-curve data point for the period */
  async generateSCurve(projectId, periodDate) {
    const accounts = await ControlAccount.findAll({ project_id: projectId });
    const planned = accounts.reduce((s, ca) => s + ca.bcws, 0);
    const earned  = accounts.reduce((s, ca) => s + ca.bcwp, 0);
    const actual  = accounts.reduce((s, ca) => s + ca.acwp, 0);

    await SCurveData.create({
      project_id: projectId, data_date: periodDate,
      planned_cumulative: planned,
      earned_cumulative: earned,
      actual_cumulative: actual
    });
  }

  /** Check EVM thresholds and raise alerts */
  async checkThresholds(projectId) {
    const thresholds = await EVMThreshold.findAll({ project_id: projectId });
    const latest = await EarnedValue.findLatest(projectId);

    for (const t of thresholds) {
      const value = latest[t.metric]; // e.g., 'spi', 'cpi'
      if (value < t.critical_threshold) {
        await AlertService.escalate(projectId, t.metric, value, 'critical');
      } else if (value < t.warning_threshold) {
        await AlertService.notify(projectId, t.metric, value, 'warning');
      }
    }
  }

  /** Forecast completion using multiple EAC methods */
  async forecastCompletion(projectId) {
    const ev = await EarnedValue.findLatest(projectId);
    const bac = await PMBaseline.getBAC(projectId);

    const forecasts = [
      { type: 'CPI_BASED',    eac: bac / ev.cpi,
        etc: (bac / ev.cpi) - ev.acwp },
      { type: 'SPI_CPI',      eac: ev.acwp + (bac - ev.bcwp) / (ev.cpi * ev.spi),
        etc: (bac - ev.bcwp) / (ev.cpi * ev.spi) },
      { type: 'BOTTOM_UP',    eac: ev.acwp + await this.getBottomUpETC(projectId),
        etc: await this.getBottomUpETC(projectId) },
    ];

    for (const f of forecasts) {
      await EVMForecast.upsert({
        project_id: projectId, forecast_type: f.type,
        eac: f.eac, etc: f.etc,
        estimated_completion_date: this.estimateDate(f.eac, ev)
      });
    }
    return forecasts;
  }
}