func bucketsFromMetricPoints(metricPoints []metricPoint, resultField func(metricPoint) float64, timerange api.Timerange) [][]float64 {
	buckets := make([][]float64, timerange.Slots())
	for _, point := range metricPoints {
		addMetricPoint(point, resultField, timerange, buckets)
	}
	return buckets
}

func (value ScalarValue) ToSeriesList(timerange api.Timerange) (api.SeriesList, error) {

	series := make([]float64, timerange.Slots())
	for i := range series {
		series[i] = float64(value)
	}

	return api.SeriesList{
		Series:    []api.Timeseries{api.Timeseries{Values: series, TagSet: api.NewTagSet()}},
		Timerange: timerange,
	}, nil
}

func processResult(parsedResult queryResponse, timerange api.Timerange, sampler sampler) []float64 {
	// buckets are each filled with from the points stored in result.Values, according to their timestamps.
	buckets := bucketsFromMetricPoints(parsedResult.Values, sampler.fieldSelector, timerange)

	// values will hold the final values to be returned as the series.
	values := make([]float64, timerange.Slots())

	for i, bucket := range buckets {
		if len(bucket) == 0 {
			values[i] = math.NaN()
			continue
		}
		values[i] = sampler.bucketSampler(bucket)
	}
	return values
}

// Blueflood will use the finest-grained resolution which doesn't exceed the slot limit.
// Thus, if you request too many points, it will automatically reduce the resolution.
func (b *Blueflood) ChooseResolution(requested api.Timerange, smallestResolution time.Duration) time.Duration {
	// In some cases, coarser-resolution data may have a shorter TTL.
	// To accomodate these cases, it must be verified that the requested timerange will
	// actually be present for the chosen resolution.
	// TODO: figure out how to make this work with moving averages and timeshifts

	requiredAge := b.timeSource().Sub(requested.StartTime())

	for _, resolution := range Resolutions {
		survivesFor := b.config.oldestViableDataForResolution(resolution)
		if survivesFor < requiredAge {
			// The data probably won't be around for the earliest part of the timerange,
			// so don't use this resolution
			continue
		}
		if resolution.duration < requested.Resolution() {
			// Skip this timerange, it is finer than the one requested.
			continue
		}
		// Check that the timerange is large enough
		if resolution.duration >= smallestResolution {
			return resolution.duration
		}
	}
	// Leave it alone, since a better one can't be found
	return requested.Resolution()
}

func processResult(
	points []metricPoint,
	timerange api.Timerange,
	sampler sampler,
	queryResolution Resolution) []float64 {
	// buckets are each filled with from the points stored in `points`, according to their timestamps.
	buckets := bucketsFromMetricPoints(points, sampler.fieldSelector, timerange)

	// values will hold the final values to be returned as the series.
	values := make([]float64, timerange.Slots())

	for i, bucket := range buckets {
		if len(bucket) == 0 {
			values[i] = math.NaN()
			continue
		}
		values[i] = sampler.bucketSampler(bucket)
	}

	// interpolate.
	return values
}

func addMetricPoint(metricPoint metricPoint, field func(metricPoint) float64, timerange api.Timerange, buckets [][]float64) bool {
	value := field(metricPoint)
	// The index to assign within the array is computed using the timestamp.
	// It floors to the nearest index.
	index := (metricPoint.Timestamp - timerange.Start()) / timerange.ResolutionMillis()
	if index < 0 || index >= int64(timerange.Slots()) {
		return false
	}
	buckets[index] = append(buckets[index], value)
	return true
}

func (f FakeTimeseriesStorageAPI) ChooseResolution(requested api.Timerange, smallestResolution time.Duration) time.Duration {
	return requested.Resolution()
}