package sq

import (
	"context"
	"database/sql"
	"errors"
	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
	"github.com/jmoiron/sqlx"
	"testing"
)

type fakeQueryable struct {
	converters []DBTypeConverter
}

func (f fakeQueryable) Exec(ctx context.Context, sqlstr string, prep PP) (sql.Result, error) {
	return nil, errors.New("not implemented")
}

func (f fakeQueryable) Query(ctx context.Context, sqlstr string, prep PP) (*sqlx.Rows, error) {
	return nil, errors.New("not implemented")
}

func (f fakeQueryable) ListConverter() []DBTypeConverter {
	return f.converters
}

func TestNewDBTypeConverterTypeStrings(t *testing.T) {
	conv := NewDBTypeConverter(func(v bool) (int64, error) { return 0, nil }, func(v int64) (bool, error) { return false, nil })
	tst.AssertEqual(t, "bool", conv.ModelTypeString())
	tst.AssertEqual(t, "int64", conv.DBTypeString())
}

func TestNewDBTypeConverterModelToDB(t *testing.T) {
	conv := NewDBTypeConverter(func(v bool) (int64, error) {
		if v {
			return 1, nil
		}
		return 0, nil
	}, func(v int64) (bool, error) {
		return v != 0, nil
	})

	r, err := conv.ModelToDB(true)
	tst.AssertNoErr(t, err)
	tst.AssertEqual(t, int64(1), r.(int64))

	r, err = conv.ModelToDB(false)
	tst.AssertNoErr(t, err)
	tst.AssertEqual(t, int64(0), r.(int64))
}

func TestNewDBTypeConverterDBToModel(t *testing.T) {
	conv := NewDBTypeConverter(func(v bool) (int64, error) { return 0, nil }, func(v int64) (bool, error) {
		return v != 0, nil
	})

	r, err := conv.DBToModel(int64(1))
	tst.AssertNoErr(t, err)
	tst.AssertEqual(t, true, r.(bool))

	r, err = conv.DBToModel(int64(0))
	tst.AssertNoErr(t, err)
	tst.AssertEqual(t, false, r.(bool))
}

func TestNewDBTypeConverterTypeMismatch(t *testing.T) {
	conv := NewDBTypeConverter(func(v bool) (int64, error) { return 0, nil }, func(v int64) (bool, error) { return false, nil })

	_, err := conv.ModelToDB("not a bool")
	if err == nil {
		t.Fatal("expected error on type mismatch in ModelToDB")
	}

	_, err = conv.DBToModel("not int64")
	if err == nil {
		t.Fatal("expected error on type mismatch in DBToModel")
	}
}

func TestNewAutoDBTypeConverter(t *testing.T) {
	conv := NewAutoDBTypeConverter(JsonObj{})

	tst.AssertEqual(t, "sq.JsonObj", conv.ModelTypeString())
	tst.AssertEqual(t, "string", conv.DBTypeString())

	r, err := conv.ModelToDB(JsonObj{"k": "v"})
	tst.AssertNoErr(t, err)
	tst.AssertEqual(t, `{"k":"v"}`, r.(string))

	r, err = conv.DBToModel(`{"k":"v"}`)
	tst.AssertNoErr(t, err)
	parsed, ok := r.(JsonObj)
	tst.AssertTrue(t, ok)
	tst.AssertStrRepEqual(t, parsed["k"], "v")
}

func TestConvertValueToDBNoConverter(t *testing.T) {
	q := fakeQueryable{}

	r, err := convertValueToDB(q, "hello")
	tst.AssertNoErr(t, err)
	tst.AssertEqual(t, "hello", r.(string))

	r, err = convertValueToDB(q, 42)
	tst.AssertNoErr(t, err)
	tst.AssertEqual(t, 42, r.(int))
}

func TestConvertValueToDBWithConverter(t *testing.T) {
	q := fakeQueryable{converters: []DBTypeConverter{ConverterBoolToBit}}

	r, err := convertValueToDB(q, true)
	tst.AssertNoErr(t, err)
	tst.AssertEqual(t, int64(1), r.(int64))

	r, err = convertValueToDB(q, false)
	tst.AssertNoErr(t, err)
	tst.AssertEqual(t, int64(0), r.(int64))
}

func TestConvertValueToDBNilPointer(t *testing.T) {
	q := fakeQueryable{}

	var s *string
	r, err := convertValueToDB(q, s)
	tst.AssertNoErr(t, err)
	tst.AssertEqual(t, true, r == nil)
}

func TestConvertValueToDBNonNilPointer(t *testing.T) {
	q := fakeQueryable{converters: []DBTypeConverter{ConverterBoolToBit}}

	v := true
	r, err := convertValueToDB(q, &v)
	tst.AssertNoErr(t, err)
	tst.AssertEqual(t, int64(1), r.(int64))
}

func TestConvertValueToModelNoConverter(t *testing.T) {
	q := fakeQueryable{}

	r, err := convertValueToModel(q, "hello", "string")
	tst.AssertNoErr(t, err)
	tst.AssertEqual(t, "hello", r.(string))
}

func TestConvertValueToModelWithConverter(t *testing.T) {
	q := fakeQueryable{converters: []DBTypeConverter{ConverterBoolToBit}}

	r, err := convertValueToModel(q, int64(1), "bool")
	tst.AssertNoErr(t, err)
	tst.AssertEqual(t, true, r.(bool))
}