package simpleorm_test

import (
	"strconv"
	"testing"

	simpleorm "git.gdulai.com/gdulai/simpleorm"
	"git.gdulai.com/gdulai/simpleorm/exec"
	"git.gdulai.com/gdulai/simpleorm/schema"
	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 TestSelectSingle(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 TestSelectWithCompositePk(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 TestSelectWithParam(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)
	if err != nil {
		log.LogError("TestInsertMultipleAndSelectWithParam setup failed: %s", err)
		t.Fail()
		return
	}

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

	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 TestSelectWithLimitAndOffset(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

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

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

	// THEN

	if len(selectExec.Results()) != 100 {
		log.LogError("TestSelectWithLimitAndOffset expected result size 100, actual: %s", len(selectExec.Results()))
		t.Fail()
	}
}

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

	err := orderBySetup(conn, orm)
	if err != nil {
		log.LogError("TestSelectOrderByAsc setup failed: %s", err)
		t.Fail()
		return
	}

	// WHEN
	selectExec, err := exec.CreateSelect[Test](orm)
	if err != nil {
		log.LogError("TestSelectOrderByDesc failed: %s", err)
		t.Fail()
		return
	}
	selectExec.OrderBy(schema.OrderBy{Field: "StringField", Direction: "DESC"})

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

	// THEN
	var resultStr string
	for _, obj := range selectExec.Results() {
		resultStr += obj.StringField
	}

	if resultStr != "EDCBA" {
		log.LogError("TestSelectOrderByDesc failed, epxected: EDCBA actual: %s", resultStr)
		t.Fail()
	}
}

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

	err := orderBySetup(conn, orm)
	if err != nil {
		log.LogError("TestSelectOrderByAsc setup failed: %s", err)
		t.Fail()
		return
	}

	// WHEN
	selectExec, err := exec.CreateSelect[Test](orm)
	if err != nil {
		log.LogError("TestSelectOrderByAsc failed: %s", err)
		t.Fail()
		return
	}
	selectExec.OrderBy(schema.OrderBy{Field: "StringField", Direction: "ASC"})

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

	// THEN
	var resultStr string
	for _, obj := range selectExec.Results() {
		resultStr += obj.StringField
	}

	if resultStr != "ABCDE" {
		log.LogError("TestSelectOrderByAsc failed, epxected: ABCDE actual: %s", resultStr)
		t.Fail()
	}
}

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

	err := orderBySetup(conn, orm)
	if err != nil {
		log.LogError("TestSelectOrderByAsc setup failed: %s", err)
		t.Fail()
		return
	}

	// WHEN
	selectExec, err := exec.CreateSelect[Test](orm)
	if err != nil {
		log.LogError("TestSelectOrderByAsc failed: %s", err)
		t.Fail()
		return
	}
	selectExec.OrderBy(schema.OrderBy{Field: "StringField", Direction: "ASC"}).Limit(3).Offset(0)

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

	// THEN
	var resultStr string
	for _, obj := range selectExec.Results() {
		resultStr += obj.StringField
	}

	if resultStr != "ABC" {
		log.LogError("TestSelectOrderByAsc failed, epxected: ABC actual: %s", resultStr)
		t.Fail()
	}
}

func orderBySetup(conn *simpleorm.DBConnection, orm *simpleorm.ORM) error {
	insertExec, err := exec.NewInsert[Test](orm,
		Test{Int64Field: -1, IntField: 1, StringField: "C"},
		Test{Int64Field: -1, IntField: 1, StringField: "D"},
		Test{Int64Field: -1, IntField: 1, StringField: "E"},
		Test{Int64Field: -1, IntField: 1, StringField: "A"},
		Test{Int64Field: -1, IntField: 1, StringField: "B"},
	)
	if err != nil {
		return err
	}

	err = insertExec.Execute(conn)
	if err != nil {
		return err
	}

	return nil
}