package simpleorm_test

import (
	"strconv"
	"testing"
	"time"

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

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 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.NewSelect[Test](orm)
	if err != nil {
		log.LogError("TestInsertMultipleAndSelectWithParam setup failed: %s", err)
		t.Fail()
		return
	}

	selectExec.Where("string_field = ?", "asdf")

	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.NewSelect[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.NewSelect[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.NewSelect[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.NewSelect[Test](orm)
	if err != nil {
		log.LogError("TestTransactionRollback WHEN failed: %s", err)
		t.Fail()
		return
	}

	selectExec.Where("id = ?", insertExec.Results()[0].ID)

	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
	}
}

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

	testEntites := []Test{}

	for i := 0; i < 1000; i++ {
		testEntites = append(testEntites, Test{Int64Field: -1, IntField: i, StringField: "Entity " + strconv.Itoa(i)})
	}

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

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

	countExec, err := exec.CreateCount[Test](orm, "")
	if err != nil {
		log.LogError("TestSelectWithLimitAndOffset failed: %s", err)
		t.Fail()
		return
	}
	err = countExec.Execute(conn)
	if err != nil {
		log.LogError("TestSelectWithLimitAndOffset failed: %s", err)
		t.Fail()
		return
	}

	// THEN

	if countExec.Result() != 1000 {
		log.LogError("TestSelectWithLimitAndOffset expected result size 1000, actual: %s", countExec.Result())
		t.Fail()
	}
}

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

	testEntites := []Test{}

	for i := 0; i < 1000; i++ {
		testEntites = append(testEntites, Test{Int64Field: -1, IntField: i, StringField: "Entity " + strconv.Itoa(i)})
	}

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

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

	countExec, err := exec.CreateCount[Test](orm, "id % 2 = 0")
	if err != nil {
		log.LogError("TestSelectWithLimitAndOffset failed: %s", err)
		t.Fail()
		return
	}
	err = countExec.Execute(conn)
	if err != nil {
		log.LogError("TestSelectWithLimitAndOffset failed: %s", err)
		t.Fail()
		return
	}

	// THEN

	if countExec.Result() != 500 {
		log.LogError("TestSelectWithLimitAndOffset expected result size 500, actual: %s", countExec.Result())
		t.Fail()
	}
}