package simpleorm_test

import (
	"testing"
	"time"

	"git.gdulai.com/gdulai/simpleorm/exec"
	log "gitlab.com/gdulai/simpleloglvl"
)

func TestSelectEmpty(t *testing.T) {
	// GIVEN
	orm, conn := testSetup()
	defer cleanUp("test.db", conn)

	// WHEN
	selectExec, err := exec.CreateSelect[Test](orm, "")

	// THEN
	if err != nil {
		log.LogError("Failed to create select. %s", err)
		t.Fail()
		return
	}

	err = selectExec.Execute(conn)
	if err != nil {
		log.LogError("Select failure. %s", err)
		t.Fail()
		return
	}

	res := selectExec.Results()
	if len(res) > 0 {
		log.LogError("Expected empty result.")
		t.Fail()
		return
	}
}

func TestInsert(t *testing.T) {
	// GIVEN
	orm, conn := testSetup()
	defer cleanUp("test.db", conn)

	testObj := Test{Int64Field: 54, IntField: 12, StringField: "asdf"}

	// WHEN
	insertExec, err := exec.NewInsert(orm, testObj)
	if err != nil {
		log.LogError("TestInsertAndSelectSingle setup failed: %s", err)
		t.Fail()
		return
	}

	insertErr := insertExec.Execute(conn)
	if err != nil {
		log.LogError("TestInsertAndSelectSingle insert failed: %s", err)
		t.Fail()
		return
	}
	insertRes := insertExec.Results()

	// THEN
	if insertErr != nil {
		log.LogError("TestInsertAndSelectSingle failure. %s", err)
		t.Fail()
		return
	}

	if len(insertRes) != 1 {
		log.LogError("TestInsertAndSelectSingle test failed. Expected: 1, Actual: %s", len(insertRes))
		t.Fail()
		return
	}

	singleRes := insertRes[0]
	if singleRes.ID != 1 || singleRes.Int64Field != 54 || singleRes.IntField != 12 || singleRes.StringField != "asdf" {
		log.LogError("TestInsertAndSelectSingle invalid result. Expected: %s, Actual: %s", testObj, singleRes)
		t.Fail()
	}
}

func TestInsertMultiple(t *testing.T) {
	// GIVEN
	orm, conn := testSetup()
	defer cleanUp("test.db", conn)

	testObj := Test{Int64Field: 54, IntField: 12, StringField: "asdf"}
	testObjSecond := Test{Int64Field: 12, IntField: 54, StringField: "fdsa"}

	// WHEN
	insertExec, err := exec.NewInsert[Test](orm, testObj, testObjSecond)
	if err != nil {
		log.LogError("TestInsertAndSelectSingle setup failed: %s", err)
		t.Fail()
		return
	}

	insertErr := insertExec.Execute(conn)
	if err != nil {
		log.LogError("TestInsertAndSelectSingle insert failed: %s", err)
		t.Fail()
		return
	}
	insertRes := insertExec.Results()

	// THEN
	if insertErr != nil {
		log.LogError("TestInsertAndSelectSingle failure. %s", err)
		t.Fail()
		return
	}

	if len(insertRes) != 2 {
		log.LogError("TestInsertAndSelectSingle test failed. Expected: 1, Actual: %s", len(insertRes))
		t.Fail()
		return
	}

	entity := insertRes[0]
	if entity.ID != 1 || entity.Int64Field != 54 || entity.IntField != 12 || entity.StringField != "asdf" {
		log.LogError("TestInsertAndSelectSingle invalid result. Expected: %s, Actual: %s", testObj, entity)
		t.Fail()
	}

	entity = insertRes[1]
	if entity.ID != 2 || entity.Int64Field != 12 || entity.IntField != 54 || entity.StringField != "fdsa" {
		log.LogError("TestInsertAndSelectSingle invalid result. Expected: %s, Actual: %s", testObjSecond, entity)
		t.Fail()
	}

}

func TestInsertAndSelectSingle(t *testing.T) {
	// GIVEN
	orm, conn := testSetup()
	defer cleanUp("test.db", conn)

	testObj := Test{Int64Field: 54, IntField: 12, StringField: "asdf"}

	// WHEN
	insertExec, err := exec.NewInsert(orm, testObj)
	if err != nil {
		log.LogError("TestInsertAndSelectSingle setup failed: %s", err)
		t.Fail()
		return
	}

	selectExec, err := exec.CreateSelect[Test](orm, "")
	if err != nil {
		log.LogError("TestInsertAndSelectSingle setup failed: %s", err)
		t.Fail()
		return
	}

	insertErr := insertExec.Execute(conn)
	selectErr := selectExec.Execute(conn)

	// THEN
	if insertErr != nil {
		log.LogError("TestInsertAndSelectSingle insert failed: %s", err)
		t.Fail()
		return
	}

	if selectErr != nil {
		log.LogError("TestInsertAndSelectSingle failure. %s", err)
		t.Fail()
		return
	}

	insertRes := insertExec.Results()
	if len(insertRes) != 1 {
		log.LogError("TestInsertAndSelectSingle test failed. Expected: 1, Actual: %s", len(insertRes))
		t.Fail()
		return
	}

	selectRes := selectExec.Results()
	if len(selectRes) != 1 {
		log.LogError("TestInsertAndSelectSingle test failed. Expected: 1, Actual: %s", len(selectRes))
		t.Fail()
		return
	}

	singleRes := insertRes[0]
	if singleRes.ID != 1 || singleRes.Int64Field != 54 || singleRes.IntField != 12 || singleRes.StringField != "asdf" {
		log.LogError("TestInsertAndSelectSingle invalid result. Expected: %s, Actual: %s", testObj, singleRes)
		t.Fail()
	}

	singleRes = selectRes[0]
	if singleRes.ID != 1 || singleRes.Int64Field != 54 || singleRes.IntField != 12 || singleRes.StringField != "asdf" {
		log.LogError("TestInsertAndSelectSingle invalid result. Expected: %s, Actual: %s", testObj, singleRes)
		t.Fail()
	}

}

func TestInsertSelectWithCompositePk(t *testing.T) {
	// GIVEN
	orm, conn := testSetup()
	defer cleanUp("test.db", conn)

	testObj := TestWithCompositePk{ID: 12, Name: "Test"}

	// WHEN
	insertExec, err := exec.NewInsert(orm, testObj)
	if err != nil {
		log.LogError("TestInsertSelectWithCompositePk setup failed: %s", err)
		t.Fail()
		return
	}

	selectExec, err := exec.CreateSelect[TestWithCompositePk](orm, "")
	if err != nil {
		log.LogError("TestInsertSelectWithCompositePk setup failed: %s", err)
		t.Fail()
		return
	}

	err = insertExec.Execute(conn)
	if err != nil {
		log.LogError("TestInsertSelectWithCompositePk insert failed: %s", err)
		t.Fail()
		return
	}

	err = selectExec.Execute(conn)

	// THEN
	if err != nil {
		log.LogError("TestInsertSelectWithCompositePk failure. %s", err)
		t.Fail()
		return
	}

	res := selectExec.Results()
	if len(res) != 1 {
		log.LogError("TestInsertSelectWithCompositePk test failed. Expected: 1, Actual: %s", len(res))
		t.Fail()
		return
	}

	singleRes := res[0]
	if singleRes.ID != 12 || singleRes.Name != "Test" {
		log.LogError("TestInsertSelectWithCompositePk invalid result. Expected: %s, Actual: %s", testObj, singleRes)
		t.Fail()
	}

}

func TestInsertMultipleAndSelectWithParam(t *testing.T) {
	// GIVEN
	orm, conn := testSetup()
	defer cleanUp("test.db", conn)

	// WHEN
	testObj := Test{Int64Field: 54, IntField: 12, StringField: "asdf"}
	testObjSecond := Test{Int64Field: 12, IntField: 54, StringField: "fdsa"}

	insertExec, err := exec.NewInsert(orm, testObj)
	if err != nil {
		log.LogError("TestInsertMultipleAndSelectWithParam setup failed: %s", err)
		t.Fail()
		return
	}

	insertSecond, err := exec.NewInsert(orm, testObjSecond)
	if err != nil {
		log.LogError("TestInsertMultipleAndSelectWithParam setup failed: %s", err)
		t.Fail()
		return
	}

	selectExec, err := exec.CreateSelect[Test](orm, "string_field = ?", "fdsa")
	if err != nil {
		log.LogError("TestInsertMultipleAndSelectWithParam setup failed: %s", err)
		t.Fail()
		return
	}

	err = insertExec.Execute(conn)
	if err != nil {
		log.LogError("TestInsertMultipleAndSelectWithParam first insert failed: %s", err)
		t.Fail()
		return
	}

	err = insertSecond.Execute(conn)
	if err != nil {
		log.LogError("TestInsertMultipleAndSelectWithParam second insert failed: %s", err)
		t.Fail()
		return
	}

	err = selectExec.Execute(conn)

	// THEN
	if err != nil {
		log.LogError("TestInsertMultipleAndSelectWithParam failure. %s", err)
		t.Fail()
		return
	}

	res := selectExec.Results()
	if len(res) != 1 {
		log.LogError(" TestInsertMultipleAndSelectWithParam test failed. Expected: 1, Actual: %s", len(res))
		t.Fail()
		return
	}

	singleRes := res[0]
	if singleRes.ID != 2 || singleRes.Int64Field != 12 || singleRes.IntField != 54 || singleRes.StringField != "fdsa" {
		log.LogError("TestInsertMultipleAndSelectWithParam invalid result. Expected: %s, Actual: %s", testObjSecond, singleRes)
		t.Fail()
		return
	}
}

func TestInsertAndUpdate(t *testing.T) {
	// GIVEN
	orm, conn := testSetup()
	defer cleanUp("test.db", conn)

	testObj := Test{Int64Field: 54, IntField: 12, StringField: "asdf"}

	// WHEN
	insertExec, err := exec.NewInsert(orm, testObj)
	if err != nil {
		log.LogError("TestInsertAndUpdate setup failed: %s", err)
		t.Fail()
		return
	}

	selectExec, err := exec.CreateSelect[Test](orm, "string_field = ?", "asdf")
	if err != nil {
		log.LogError("TestInsertMultipleAndSelectWithParam setup failed: %s", err)
		t.Fail()
		return
	}

	err = insertExec.Execute(conn)
	if err != nil {
		log.LogError("TestInsertAndUpdate insert failed: %s", err)
		t.Fail()
		return
	}

	err = selectExec.Execute(conn)
	if err != nil {
		log.LogError("TestInsertAndUpdate re-select failed: %s", err)
		t.Fail()
		return
	}

	res := selectExec.Results()
	testObj = res[0]

	testObj.IntField = 42069
	testObj.Int64Field = 69420

	updateExec, err := exec.NewUpdate(orm, testObj)
	if err != nil {
		log.LogError("TestInsertAndUpdate setup failed: %s", err)
		t.Fail()
		return
	}

	err = updateExec.Execute(conn)
	selectErr := selectExec.Execute(conn)

	// THEN
	if err != nil {
		log.LogError("TestInsertAndUpdate update failure. %s", err)
		t.Fail()
		return
	}

	if selectErr != nil {
		log.LogError("TestInsertAndUpdate select failure. %s", err)
		t.Fail()
		return
	}

	res = selectExec.Results()
	if len(res) != 1 {
		log.LogError("TestInsertAndUpdate test failed. Expected: 1, Actual: %s", len(res))
		t.Fail()
		return
	}

	singleRes := res[0]
	if singleRes.ID != 1 || singleRes.Int64Field != 69420 || singleRes.IntField != 42069 || singleRes.StringField != "asdf" {
		log.LogError("TestInsertAndUpdate invalid result. Expected: %s, Actual: %s", testObj, singleRes)
		t.Fail()
	}

}

func TestInsertAndDelete(t *testing.T) {
	// GIVEN
	orm, conn := testSetup()
	defer cleanUp("test.db", conn)

	testObj := Test{Int64Field: 54, IntField: 12, StringField: "asdf"}

	// WHEN
	insertExec, err := exec.NewInsert(orm, testObj)
	if err != nil {
		log.LogError("TestInsertAndDelete setup failed: %s", err)
		t.Fail()
		return
	}

	err = insertExec.Execute(conn)
	if err != nil {
		log.LogError("TestInsertAndDelete setup failed: %s", err)
		t.Fail()
		return
	}

	selectExec, err := exec.CreateSelect[Test](orm, "")
	if err != nil {
		log.LogError("TestInsertAndDelete setup failed: %s", err)
		t.Fail()
		return
	}

	err = selectExec.Execute(conn)
	if err != nil {
		log.LogError("TestInsertAndDelete setup failed. %s", err)
		t.Fail()
		return
	}

	deleteExec, err := exec.NewDelete(orm, selectExec.Results())
	err = deleteExec.Execute(conn)

	// THEN
	if err != nil {
		log.LogError("TestInsertAndDelete delete failure. %s", err)
		t.Fail()
		return
	}

	err = selectExec.Execute(conn)
	// THEN
	if err != nil {
		log.LogError("TestInsertAndDelete delete failure. %s", err)
		t.Fail()
		return
	}

	selectRes := selectExec.Results()
	if len(selectRes) != 0 {
		log.LogError("TestInsertAndDelete test failed. Expected: 0, Actual: %s", len(selectRes))
		t.Fail()
		return
	}

}

func TestBoolInsertAndSelectSingle(t *testing.T) {
	// GIVEN
	orm, conn := testSetup()
	defer cleanUp("test.db", conn)

	testObj := TestWithBool{BoolField: true}

	// WHEN
	insertExec, err := exec.NewInsert(orm, testObj)
	if err != nil {
		log.LogError("TestBoolInsertAndSelectSingle setup failed: %s", err)
		t.Fail()
		return
	}

	selectExec, err := exec.CreateSelect[TestWithBool](orm, "")
	if err != nil {
		log.LogError("TestBoolInsertAndSelectSingle setup failed: %s", err)
		t.Fail()
		return
	}

	err = insertExec.Execute(conn)
	if err != nil {
		log.LogError("TestBoolInsertAndSelectSingle insert failed: %s", err)
		t.Fail()
		return
	}

	err = selectExec.Execute(conn)

	// THEN
	if err != nil {
		log.LogError("TestBoolInsertAndSelectSingle failure. %s", err)
		t.Fail()
		return
	}

	res := selectExec.Results()
	if len(res) != 1 {
		log.LogError("TestBoolInsertAndSelectSingle test failed. Expected: 1, Actual: %s", len(res))
		t.Fail()
		return
	}

	singleRes := res[0]
	if singleRes.ID != 1 || !singleRes.BoolField {
		log.LogError("TestBoolInsertAndSelectSingle invalid result. Expected: %s, Actual: %s", testObj, singleRes)
		t.Fail()
	}

}

func TestTimeInsertAndSelectSingle(t *testing.T) {
	// GIVEN
	orm, conn := testSetup()
	defer cleanUp("test.db", conn)

	now := time.Now().UnixMilli()
	testObj := TestWithTime{TimeField: now}

	// WHEN
	insertExec, err := exec.NewInsert(orm, testObj)
	if err != nil {
		log.LogError("TestTimeInsertAndSelectSingle setup failed: %s", err)
		t.Fail()
		return
	}

	selectExec, err := exec.CreateSelect[TestWithTime](orm, "")
	if err != nil {
		log.LogError("TestTimeInsertAndSelectSingle setup failed: %s", err)
		t.Fail()
		return
	}

	err = insertExec.Execute(conn)
	if err != nil {
		log.LogError("TestTimeInsertAndSelectSingle insert failed: %s", err)
		t.Fail()
		return
	}

	err = selectExec.Execute(conn)

	// THEN
	if err != nil {
		log.LogError("TestTimeInsertAndSelectSingle failure. %s", err)
		t.Fail()
		return
	}

	res := selectExec.Results()
	if len(res) != 1 {
		log.LogError("TestTimeInsertAndSelectSingle test failed. Expected: 1, Actual: %s", len(res))
		t.Fail()
		return
	}

	singleRes := res[0]
	if singleRes.ID != 1 || singleRes.TimeField != now {
		log.LogError("TestTimeInsertAndSelectSingle invalid result. Expected: %s, Actual: %s", testObj, singleRes)
		t.Fail()
	}

}

func TestTransactionExecuteSimple(t *testing.T) {
	// GIVEN
	orm, conn := testSetup()
	defer cleanUp("test.db", conn)

	transaction := exec.NewTransaction(conn)

	testObj := Test{Int64Field: 54, IntField: 12, StringField: "asdf"}

	// WHEN
	insertExec, err := exec.NewInsert[Test](orm, testObj)
	if err != nil {
		log.LogError("TestTransactionExecuteSimple failed: %s", err)
		t.Fail()
		return
	}

	transErr := transaction.Execute(&insertExec)
	if transErr != nil {
		transErr = transaction.Finish()
	}

	// THEN
	if transErr != nil {
		log.LogError("TestTransactionExecuteSimple failed: %s", err)
		t.Fail()
		return
	}

	insertRes := insertExec.Results()

	if len(insertRes) != 1 {
		log.LogError("TestInsertAndSelectSingle test failed. Expected: 1, Actual: %s", len(insertRes))
		t.Fail()
		return
	}

	singleRes := insertRes[0]
	if singleRes.ID != 1 || singleRes.Int64Field != 54 || singleRes.IntField != 12 || singleRes.StringField != "asdf" {
		log.LogError("TestInsertAndSelectSingle invalid result. Expected: %s, Actual: %s", testObj, singleRes)
		t.Fail()
	}
}

func TestTransactionRollback(t *testing.T) {
	// GIVEN
	orm, conn := testSetup()
	defer cleanUp("test.db", conn)

	transaction := exec.NewTransaction(conn)

	testObj := Test{Int64Field: 54, IntField: 12, StringField: "asdf"}

	// WHEN
	insertExec, err := exec.NewInsert[Test](orm, testObj)
	if err != nil {
		log.LogError("TestTransactionRollback WHEN failed: %s", err)
		t.Fail()
		return
	}

	transErr := transaction.Execute(&insertExec)
	if transErr != nil {
		log.LogError("TestTransactionRollback WHEN failed: %s", err)
		t.Fail()
		return
	}

	selectExec, err := exec.CreateSelect[Test](orm, "id = ?", insertExec.Results()[0].ID)
	if err != nil {
		log.LogError("TestTransactionRollback WHEN failed: %s", err)
		t.Fail()
		return
	}

	transErr = transaction.Execute(&selectExec)
	if transErr != nil {
		log.LogError("TestTransactionRollback WHEN failed: %s", err)
		t.Fail()
		return
	}

	beforeRollbackSelectRes := selectExec.Results()
	rollbackErr := transaction.Rollback()
	afterRollbackErr := selectExec.Execute(conn)
	afterRollbackSelectRes := selectExec.Results()

	// THEN
	if len(beforeRollbackSelectRes) != 1 {
		log.LogError("TestTransactionExecuteSimple-THEN: Expected 1, Actual: %s", len(beforeRollbackSelectRes))
		t.Fail()
		return
	}

	if rollbackErr != nil {
		log.LogError("TestTransactionExecuteSimple-THEN: rollback error: %s", rollbackErr)
		t.Fail()
		return
	}

	if afterRollbackErr != nil {
		log.LogError("TestTransactionExecuteSimple-THEN: after rollback select error: %s", rollbackErr)
		t.Fail()
		return
	}

	if len(afterRollbackSelectRes) != 0 {
		log.LogError("TestTransactionExecuteSimple-THEN: Expected 0 after rollback select result")
		t.Fail()
		return
	}
}