/**
   * If the measurement baselines for the corresponding resources are the same, that value will be
   * returned; otherwise null will be returned
   */
  public MeasurementBaseline getBaselineIfEqual(Subject subject, int groupId, int definitionId) {
    Query query =
        entityManager.createQuery(
            "" //
                + "SELECT MIN(mb.baselineMin),  MAX(mb.baselineMin), " //
                + "       MIN(mb.baselineMean), MAX(mb.baselineMean), " //
                + "       MIN(mb.baselineMax),  MAX(mb.baselineMax), " //
                + "       COUNT(mb.id) " //
                + "  FROM MeasurementBaseline mb " //
                + "  JOIN mb.schedule ms " //
                + "  JOIN ms.resource res " //
                + "  JOIN res.implicitGroups rg " //
                + " WHERE rg.id = :groupId " //
                + "   AND ms.definition.id = :definitionId ");
    query.setParameter("groupId", groupId);
    query.setParameter("definitionId", definitionId);
    Object[] results = (Object[]) query.getSingleResult();

    MeasurementBaseline baseline = new MeasurementBaseline();
    if ((Long) results[6] == 0) {
      // no baselines calculated yet, return null to indicate that
      return null;
    }

    // there was at least one baseline, so one or more of min/mean/max might be non-null
    if (results[0] == null || results[1] == null) {
      baseline.setMin(null);
    } else if (Math.abs((Double) results[0] - (Double) results[1]) < 1e-9) {
      baseline.setMin((Double) results[0]); // they are close enough to being equal
    } else {
      baseline.setMin(
          -1.0); // use negative to represent mixed, because we currently don't support graphing
      // negs
    }
    if (results[2] == null || results[3] == null) {
      baseline.setMean(null);
    } else if (Math.abs((Double) results[2] - (Double) results[3]) < 1e-9) {
      baseline.setMean((Double) results[2]); // they are close enough to being equal
    } else {
      baseline.setMean(
          -1.0); // use negative to represent mixed, because we currently don't support graphing
      // negs
    }
    if (results[4] == null || results[5] == null) {
      baseline.setMax(null);
    } else if (Math.abs((Double) results[4] - (Double) results[5]) < 1e-9) {
      baseline.setMax((Double) results[4]); // they are close enough to being equal
    } else {
      baseline.setMax(
          -1.0); // use negative to represent mixed, because we currently don't support graphing
      // negs
    }
    return baseline;
  }
  private MeasurementBaseline calculateBaselineForGroup(
      int groupId,
      int definitionId,
      boolean userEntered,
      long startDate,
      long endDate,
      boolean save)
      throws DataNotAvailableException, BaselineCreationException {

    MeasurementAggregate agg =
        dataManager.getAggregate(
            subjectManager.getOverlord(), groupId, definitionId, startDate, endDate);

    Subject overlord = subjectManager.getOverlord();
    List<Integer> resourceIds = resourceManager.findImplicitResourceIdsByResourceGroup(groupId);
    List<MeasurementSchedule> schedules =
        measurementScheduleManager.findSchedulesByResourceIdsAndDefinitionId(
            overlord, ArrayUtils.unwrapCollection(resourceIds), definitionId);

    MeasurementBaseline baseline = null;
    for (MeasurementSchedule schedule : schedules) {
      // attach the entity, so we can find the baseline
      schedule = entityManager.merge(schedule);

      if (save && (schedule.getBaseline() != null)) {
        /*
         * If saving, make sure we're updating the existing one, if it exists
         */
        baseline = schedule.getBaseline();
      } else {
        /*
         * Otherwise, if we're not saving or if the the schedule doesn't have a current baseline, we create a new
         * baseline object
         */
        baseline = new MeasurementBaseline();

        if (save) {
          /*
           * But, if we *are* in save mode, then set the relationship so when we merge the schedule below it
           * persists this new baseline too
           */
          baseline.setSchedule(schedule);
        }
      }

      baseline.setUserEntered(userEntered);
      baseline.setMean(agg.getAvg());
      baseline.setMin(agg.getMin());
      baseline.setMax(agg.getMax());

      if (save) {
        entityManager.persist(baseline);
        entityManager.merge(schedule);
      }
    }

    // all baselines should be the same
    return baseline;
  }
  private MeasurementBaseline calculateBaseline(
      MeasurementSchedule schedule, boolean userEntered, long startDate, long endDate, boolean save)
      throws DataNotAvailableException, BaselineCreationException {
    /*
     * jmarques: 2007-10-26
     *
     * navigation from schedule to definition is safe here because the only caller to this method is
     * calculateAutoBaseline( Subject, Integer, long, long, boolean ), which uses entityManager.find, so the
     * schedule should still be attached since the transaction is propagated to this method
     */
    if (schedule.getDefinition().getNumericType() != NumericType.DYNAMIC) {
      throw new BaselineCreationException(
          "Baseline calculation is only valid for a dynamic measurement");
    }

    MeasurementAggregate agg =
        dataManager.getAggregate(
            subjectManager.getOverlord(), schedule.getId(), startDate, endDate);

    // attach the entity, so we can find the baseline
    schedule = entityManager.merge(schedule);

    MeasurementBaseline baseline = null;
    if (save && (schedule.getBaseline() != null)) {
      /*
       * If saving, make sure we're updating the existing one, if it exists
       */
      baseline = schedule.getBaseline();
    } else {
      /*
       * Otherwise, if we're not saving or if the the schedule doesn't have a current baseline, we create a new
       * baseline object
       */
      baseline = new MeasurementBaseline();

      if (save) {
        /*
         * But, if we *are* in save mode, then set the relationship so when we merge the schedule below it
         * persists this new baseline too
         */
        baseline.setSchedule(schedule);
      }
    }

    baseline.setUserEntered(userEntered);
    baseline.setMean(agg.getAvg());
    baseline.setMin(agg.getMin());
    baseline.setMax(agg.getMax());

    if (save) {
      entityManager.persist(baseline);
      entityManager.merge(schedule);
    }

    return baseline;
  }