// Copyright 2015 The Vanadium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package sbmodel_test

import (
	"reflect"
	"testing"
	"time"

	"v.io/x/sensorlog/internal/sbmodel"
	"v.io/x/sensorlog/internal/sbmodel/keyutil"
)

type keyTest interface {
	Run(t *testing.T, keyPrototype sbmodel.PersistentDataKey)
}

// validKeyTest verifies that the key is correctly parsed and built.
type validKeyTest struct {
	keyStr    string
	keyParsed sbmodel.PersistentDataKey
}

func (kt *validKeyTest) Run(t *testing.T, keyPrototype sbmodel.PersistentDataKey) {
	if err := keyPrototype.Parse(kt.keyStr); err != nil {
		t.Errorf("key %q parse failed: %v", kt.keyStr, err)
		return
	}
	if got, want := keyPrototype, kt.keyParsed; !reflect.DeepEqual(got, want) {
		t.Errorf("incorrect key parse: got %v, want %v", got, want)
	}
	if got, want := kt.keyParsed.Table(), keyPrototype.Table(); got != want {
		t.Errorf("incorrect parsed key table: got %v, want %v", got, want)
	}
	if got, want := kt.keyParsed.Key(), kt.keyStr; got != want {
		t.Errorf("incorrect key build: got %s, want %s", got, want)
	}
}

// invalidKeyTest verifies that malformed key parsing fails.
type invalidKeyTest struct {
	keyStr string
}

func (kt *invalidKeyTest) Run(t *testing.T, keyPrototype sbmodel.PersistentDataKey) {
	if err := keyPrototype.Parse(kt.keyStr); err == nil {
		t.Errorf("key %q parse should have failed", kt.keyStr)
	}
}

func TestDeviceCfgKeys(t *testing.T) {
	tests := []keyTest{
		&validKeyTest{
			keyStr: keyutil.Join("foo"),
			keyParsed: &sbmodel.KDeviceCfg{
				DevId: "foo",
			},
		},
		&invalidKeyTest{
			keyStr: keyutil.Join("foo", "bar"),
		},
	}
	for _, kt := range tests {
		kt.Run(t, &sbmodel.KDeviceCfg{})
	}
}

func TestStreamDefKeys(t *testing.T) {
	tests := []keyTest{
		&validKeyTest{
			keyStr: keyutil.Join("pc", "cputemp"),
			keyParsed: &sbmodel.KStreamDef{
				DevId:    "pc",
				StreamId: "cputemp",
			},
		},
		&invalidKeyTest{
			keyStr: keyutil.Join("pc"),
		},
	}
	for _, kt := range tests {
		kt.Run(t, &sbmodel.KStreamDef{})
	}
}

func TestDataPointKeys(t *testing.T) {
	tests := []keyTest{
		&validKeyTest{
			keyStr: keyutil.Join("meter", "amps", "00000022fcde41b2"),
			keyParsed: &sbmodel.KDataPoint{
				DevId:     "meter",
				StreamId:  "amps",
				Timestamp: time.Unix(0, 0x22fcde41b2),
			},
		},
		&invalidKeyTest{
			keyStr: keyutil.Join("meter", "amps"),
		},
		&invalidKeyTest{
			keyStr: keyutil.Join("meter", "amps", "2.17"),
		},
	}
	for _, kt := range tests {
		kt.Run(t, &sbmodel.KDataPoint{})
	}
}