package mysqlite

import (
	"github.com/stretchr/testify/require"
	"testing"
)

func openTestDb(t *testing.T) *Db {
	db := openEmptyTestDb(t)
	db.Query("create table mytable (key text, value text)").MustExec()
	db.Query("insert into mytable(key, value) values ('foo', 'bar')").MustExec()
	return db
}

func TestSimpleQuery(t *testing.T) {
	db := openTestDb(t)
	var count int
	db.Query("select count(*) from mytable").MustScanSingle(&count)
	require.Equal(t, 1, count, "expected empty count")
}

func TestSimpleQueryWithArgs(t *testing.T) {
	db := openTestDb(t)
	var value string
	db.Query("select value from mytable where key = ?").Bind("foo").MustScanSingle(&value)
	require.Equal(t, "bar", value, "bad value returned")
}

func TestQueryWithTwoRows(t *testing.T) {
	db := openTestDb(t)
	db.Query("insert into mytable(key, value) values ('lorem', 'ipsum')").MustExec()

	rows, err := db.Query("select value from mytable").ScanMulti()
	require.NoError(t, err)
	defer rows.MustFinish()

	require.True(t, rows.MustNext(), "expected first row")
	var value string
	rows.MustScan(&value)
	require.Equal(t, "bar", value, "bad value returned")

	require.True(t, rows.MustNext(), "expected second row")
	rows.MustScan(&value)
	require.Equal(t, "ipsum", value, "bad value returned")

	require.False(t, rows.MustNext(), "expected no more rows")
}

func TestQueryWithRange(t *testing.T) {
	db := openTestDb(t)
	db.Query("insert into mytable(key, value) values ('lorem', 'ipsum')").MustExec()

	var err error
	index := 0
	for row := range db.Query("select value from mytable").Range(&err) {
		var value string
		row.MustScan(&value)
		if index == 0 {
			require.Equal(t, "bar", value)
		} else if index == 1 {
			require.Equal(t, "ipsum", value)
		} else {
			require.FailNow(t, "more rows than expected")
		}
		index++
	}
	require.NoError(t, err)
}

func TestUpdateQuery(t *testing.T) {
	db := openTestDb(t)
	func() {
		tx := db.MustBegin()
		defer tx.MustRollback()
		tx.Query("insert into mytable(key, value) values ('lorem', 'bar')").MustExec()
		value := "ipsum"
		key := "lorem"
		tx.Query("update mytable set value = ? where key = ?").Bind(value, key).MustExec()
		tx.MustCommit()
	}()

	var value string
	db.Query("select value from mytable where key = 'lorem'").MustScanSingle(&value)
	require.Equal(t, "ipsum", value)
}

func TestUpdateQueryWithWrongArguments(t *testing.T) {
	db := openTestDb(t)
	value := "ipsum"
	err := db.Query("insert into mytable(key, value) values ('lorem', ?)").Bind(&value).Exec()
	require.Error(t, err)
}

func TestQueryWithPointerStringArguments(t *testing.T) {
	db := openTestDb(t)
	var result *string
	err := db.Query("select value from mytable where key = 'foo'").ScanSingle(&result)
	require.NoError(t, err)
	require.NotNil(t, result)
	require.Equal(t, "bar", *result)
}

func TestQueryWithPointerStringArgumentsCanSetToNull(t *testing.T) {
	db := openTestDb(t)
	db.Query("update mytable set value=NULL where key = 'foo'").MustExec()
	myString := "some string"
	var result *string
	result = &myString
	err := db.Query("select value from mytable where key = 'foo'").ScanSingle(&result)
	require.NoError(t, err)
	require.Nil(t, result)
}

func TestDeleteQuery(t *testing.T) {
	db := openTestDb(t)
	db.Query("delete from mytable where key = 'foo'").MustExec()

	var count int
	db.Query("select count(*) from mytable where key = 'foo'").MustScanSingle(&count)
	require.Equal(t, 0, count, "expected row to be deleted")
}

func TestTransactionRollback(t *testing.T) {
	db := openTestDb(t)
	func() {
		tx := db.MustBegin()
		defer tx.MustRollback()
		tx.Query("update mytable set value = 'ipsum' where key = 'foo'").MustExec()
		// Intentionally not committing the transaction
	}()

	var value string
	db.Query("select value from mytable where key = 'foo'").MustScanSingle(&value)
	require.Equal(t, "bar", value, "expected original value after rollback")
}