package bps

import (
	"bytes"
	"io"
	"log"
	"testing"
	"time"
)

func init() {
	log.SetFlags(log.Ldate | log.Ltime | log.Lshortfile)
}

func validate(t *testing.T, actual, expected []float64) {
	if len(actual) != len(expected) {
		t.Errorf("len is not same: %d expected %d", len(actual), len(expected))
	}
	for i, _ := range actual {
		if actual[i] != expected[i] {
			t.Errorf("%dth: got %f expected %f", i, actual[i], expected[i])
		}
	}
}

func TestEmpty(t *testing.T) {
	bw, err := New([]int{1, 10, 60}, 100*time.Second)
	if err != nil {
		t.Error(err)
	}
	bw.timeBuckets = []int64{1, 10, 60}
	validate(t, bw.Cur(), []float64{0, 0, 0})
	bw.Close()
}

func TestEmptySeconds(t *testing.T) {
	_, err := New([]int{}, 100*time.Second)
	if err == nil {
		t.Errorf("got no error wanted one: %v")
	}
}

func TestTimeBucketsSize(t *testing.T) {
	bw, _ := New([]int{1, 2, 5}, 1*time.Second)
	if len(bw.timeBuckets) != 5 {
		t.Errorf("buckets slice wrong length: %d, expected %d", len(bw.timeBuckets), 5)
	}
	bw.Close()
}

func TestOnes(t *testing.T) {
	bw, _ := New([]int{1, 2, 5}, 1*time.Second)
	var i int64
	for i = 0; i < bw.max; i++ {
		bw.timeBuckets[i] = 1.0
	}
	avgs := bw.averages(bw.timeBuckets)
	// try a large range of starting points:
	for i := 0; i < 10; i++ {
		bw.timeI = i
		validate(t, avgs, []float64{1.0, 1.0, 1.0})
	}
	bw.Close()
}

func TestManyOnes(t *testing.T) {
	bw, _ := New([]int{1, 10, 60}, 1*time.Second)
	var i int64
	for i = 0; i < bw.max; i++ {
		bw.timeBuckets[i] = 1.0
	}
	avgs := bw.averages(bw.timeBuckets)
	// try a large range of starting points:
	for i := -70; i < 70; i++ {
		bw.timeI = i
		validate(t, avgs, []float64{1.0, 1.0, 1.0})
	}
	bw.Close()
}

func TestLinear(t *testing.T) {
	bw, _ := New([]int{1, 10, 60}, 1*time.Second)
	var i int64
	for i = 0; i < bw.max; i++ {
		bw.timeBuckets[i] = i
	}
	avgs := bw.averages(bw.timeBuckets)
	validate(t, avgs, []float64{0.0, 4.5, 29.5})
	bw.Close()
}

func TestInverseLinear(t *testing.T) {
	bw, _ := New([]int{1, 10, 60}, 1*time.Second)
	var i int64
	for i = 0; i < bw.max; i++ {
		bw.timeBuckets[i] = bw.max - i
	}
	avgs := bw.averages(bw.timeBuckets)
	validate(t, avgs, []float64{60.0, 55.5, 30.5})
	bw.Close()
}

func TestSpecific(t *testing.T) {
	bw, _ := New([]int{1, 2, 10}, 1*time.Second)
	bw.timeBuckets[8] = 1.0
	var avgs []float64

	bw.timeI = 8
	avgs = bw.averages(bw.timeBuckets)
	validate(t, avgs, []float64{1.0, 0.5, 0.1})

	bw.timeI = 7
	avgs = bw.averages(bw.timeBuckets)
	validate(t, avgs, []float64{0.0, 0.5, 0.1})

	bw.timeI = 9
	avgs = bw.averages(bw.timeBuckets)
	validate(t, avgs, []float64{0.0, 0.0, 0.1})
	bw.Close()
}

func TestWriter(t *testing.T) {
	t.Parallel()
	bw, _ := New([]int{1, 10, 100}, 1*time.Second)
	defer bw.Close()
	b := &bytes.Buffer{}
	b.Write([]byte("helloooooooooooooooooooooooooooooooooooooooooooooo"))
	io.Copy(bw, b)
	validate(t, bw.Cur(), []float64{50, 5, 0.5})
	time.Sleep(3 * time.Second)
	validate(t, bw.Cur(), []float64{0, 5, 0.5})
}

func TestAdd(t *testing.T) {
	t.Parallel()
	bw, _ := New([]int{1, 10, 100}, 1*time.Second)
	bw.Add(314)
	validate(t, bw.Cur(), []float64{314, 31.4, 3.14})
	time.Sleep(3 * time.Second)
	validate(t, bw.Cur(), []float64{0, 31.4, 3.14})
	bw.Close()
}