package sq

import (
	"git.blackforestbytes.com/BlackForestBytes/goext/rfctime"
	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
	"testing"
	"time"
)

func TestConverterBoolToBit(t *testing.T) {
	v, err := ConverterBoolToBit.ModelToDB(true)
	tst.AssertNoErr(t, err)
	tst.AssertEqual(t, int64(1), v.(int64))

	v, err = ConverterBoolToBit.ModelToDB(false)
	tst.AssertNoErr(t, err)
	tst.AssertEqual(t, int64(0), v.(int64))

	v, err = ConverterBoolToBit.DBToModel(int64(1))
	tst.AssertNoErr(t, err)
	tst.AssertEqual(t, true, v.(bool))

	v, err = ConverterBoolToBit.DBToModel(int64(0))
	tst.AssertNoErr(t, err)
	tst.AssertEqual(t, false, v.(bool))

	_, err = ConverterBoolToBit.DBToModel(int64(2))
	if err == nil {
		t.Fatal("expected error for value not in {0,1}")
	}
}

func TestConverterTimeToUnixMillis(t *testing.T) {
	t0 := time.Date(2024, 6, 15, 12, 34, 56, int(789*time.Millisecond), time.UTC)
	expected := t0.UnixMilli()

	v, err := ConverterTimeToUnixMillis.ModelToDB(t0)
	tst.AssertNoErr(t, err)
	tst.AssertEqual(t, expected, v.(int64))

	v, err = ConverterTimeToUnixMillis.DBToModel(expected)
	tst.AssertNoErr(t, err)
	tst.AssertEqual(t, expected, v.(time.Time).UnixMilli())
}

func TestConverterRFCUnixMilliTime(t *testing.T) {
	t0 := rfctime.NewUnixMilli(time.Date(2020, 1, 2, 3, 4, 5, 0, time.UTC))
	expected := t0.UnixMilli()

	v, err := ConverterRFCUnixMilliTimeToUnixMillis.ModelToDB(t0)
	tst.AssertNoErr(t, err)
	tst.AssertEqual(t, expected, v.(int64))

	v, err = ConverterRFCUnixMilliTimeToUnixMillis.DBToModel(expected)
	tst.AssertNoErr(t, err)
	tst.AssertEqual(t, expected, v.(rfctime.UnixMilliTime).UnixMilli())
}

func TestConverterRFCUnixNanoTime(t *testing.T) {
	t0 := rfctime.NewUnixNano(time.Date(2020, 1, 2, 3, 4, 5, 123456789, time.UTC))
	expected := t0.UnixNano()

	v, err := ConverterRFCUnixNanoTimeToUnixNanos.ModelToDB(t0)
	tst.AssertNoErr(t, err)
	tst.AssertEqual(t, expected, v.(int64))

	v, err = ConverterRFCUnixNanoTimeToUnixNanos.DBToModel(expected)
	tst.AssertNoErr(t, err)
	tst.AssertEqual(t, expected, v.(rfctime.UnixNanoTime).UnixNano())
}

func TestConverterRFCUnixTime(t *testing.T) {
	t0 := rfctime.NewUnix(time.Date(2020, 1, 2, 3, 4, 5, 0, time.UTC))
	expected := t0.Unix()

	v, err := ConverterRFCUnixTimeToUnixSeconds.ModelToDB(t0)
	tst.AssertNoErr(t, err)
	tst.AssertEqual(t, expected, v.(int64))

	v, err = ConverterRFCUnixTimeToUnixSeconds.DBToModel(expected)
	tst.AssertNoErr(t, err)
	tst.AssertEqual(t, expected, v.(rfctime.UnixTime).Unix())
}

func TestConverterRFC339Time(t *testing.T) {
	t0 := rfctime.NewRFC3339(time.Date(2020, 6, 15, 9, 30, 45, 0, time.UTC))

	v, err := ConverterRFC339TimeToString.ModelToDB(t0)
	tst.AssertNoErr(t, err)
	tst.AssertEqual(t, "2020-06-15 09:30:45", v.(string))

	v, err = ConverterRFC339TimeToString.DBToModel("2020-06-15 09:30:45")
	tst.AssertNoErr(t, err)
	tt := v.(rfctime.RFC3339Time).Time().UTC()
	tst.AssertEqual(t, 2020, tt.Year())
	tst.AssertEqual(t, time.June, tt.Month())
	tst.AssertEqual(t, 15, tt.Day())
	tst.AssertEqual(t, 9, tt.Hour())
	tst.AssertEqual(t, 30, tt.Minute())
	tst.AssertEqual(t, 45, tt.Second())

	_, err = ConverterRFC339TimeToString.DBToModel("garbage")
	if err == nil {
		t.Fatal("expected parse error")
	}
}

func TestConverterRFC339NanoTime(t *testing.T) {
	t0 := rfctime.NewRFC3339Nano(time.Date(2020, 6, 15, 9, 30, 45, 123456789, time.UTC))

	v, err := ConverterRFC339NanoTimeToString.ModelToDB(t0)
	tst.AssertNoErr(t, err)
	tst.AssertEqual(t, "2020-06-15 09:30:45.123456789", v.(string))

	v, err = ConverterRFC339NanoTimeToString.DBToModel("2020-06-15 09:30:45.123456789")
	tst.AssertNoErr(t, err)
	tt := v.(rfctime.RFC3339NanoTime).Time().UTC()
	tst.AssertEqual(t, 123456789, tt.Nanosecond())

	_, err = ConverterRFC339NanoTimeToString.DBToModel("not a date")
	if err == nil {
		t.Fatal("expected parse error")
	}
}

func TestConverterRFCDate(t *testing.T) {
	d := rfctime.Date{Year: 2024, Month: 3, Day: 9}
	v, err := ConverterRFCDateToString.ModelToDB(d)
	tst.AssertNoErr(t, err)
	tst.AssertEqual(t, "2024-03-09", v.(string))

	v, err = ConverterRFCDateToString.DBToModel("2024-03-09")
	tst.AssertNoErr(t, err)
	d2 := v.(rfctime.Date)
	tst.AssertEqual(t, 2024, d2.Year)
	tst.AssertEqual(t, 3, d2.Month)
	tst.AssertEqual(t, 9, d2.Day)

	_, err = ConverterRFCDateToString.DBToModel("invalid")
	if err == nil {
		t.Fatal("expected parse error")
	}
}

func TestConverterRFCTime(t *testing.T) {
	tm := rfctime.NewTime(13, 30, 45, 0)
	v, err := ConverterRFCTimeToString.ModelToDB(tm)
	tst.AssertNoErr(t, err)
	roundtrip, err := ConverterRFCTimeToString.DBToModel(v.(string))
	tst.AssertNoErr(t, err)
	tm2 := roundtrip.(rfctime.Time)
	tst.AssertEqual(t, 13, tm2.Hour)
	tst.AssertEqual(t, 30, tm2.Minute)
	tst.AssertEqual(t, 45, tm2.Second)

	_, err = ConverterRFCTimeToString.DBToModel("xx:xx:xx")
	if err == nil {
		t.Fatal("expected parse error")
	}
}

func TestConverterRFCSecondsF64(t *testing.T) {
	d := 12*time.Second + 500*time.Millisecond
	s := rfctime.NewSecondsF64(d)
	v, err := ConverterRFCSecondsF64ToString.ModelToDB(s)
	tst.AssertNoErr(t, err)
	tst.AssertEqual(t, 12.5, v.(float64))

	v, err = ConverterRFCSecondsF64ToString.DBToModel(12.5)
	tst.AssertNoErr(t, err)
	tst.AssertEqual(t, 12.5, v.(rfctime.SecondsF64).Seconds())
}

func TestConverterJsonObjToString(t *testing.T) {
	tst.AssertEqual(t, "sq.JsonObj", ConverterJsonObjToString.ModelTypeString())
	tst.AssertEqual(t, "string", ConverterJsonObjToString.DBTypeString())

	v, err := ConverterJsonObjToString.ModelToDB(JsonObj{"x": float64(1)})
	tst.AssertNoErr(t, err)
	tst.AssertEqual(t, `{"x":1}`, v.(string))

	r, err := ConverterJsonObjToString.DBToModel(`{"x":1}`)
	tst.AssertNoErr(t, err)
	tst.AssertStrRepEqual(t, r.(JsonObj)["x"], float64(1))
}

func TestConverterJsonArrToString(t *testing.T) {
	tst.AssertEqual(t, "sq.JsonArr", ConverterJsonArrToString.ModelTypeString())
	tst.AssertEqual(t, "string", ConverterJsonArrToString.DBTypeString())

	v, err := ConverterJsonArrToString.ModelToDB(JsonArr{float64(1), float64(2)})
	tst.AssertNoErr(t, err)
	tst.AssertEqual(t, `[1,2]`, v.(string))

	r, err := ConverterJsonArrToString.DBToModel(`[1,2]`)
	tst.AssertNoErr(t, err)
	arr := r.(JsonArr)
	tst.AssertEqual(t, 2, len(arr))
}