package orm

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

func storyBaseLoop(t assert.TestingT, e *Engine, u user, count int, additionalPopulateFields ...string) {
	if !isTestBench(t) {
		for range count {
			storyBase(e, t, u, additionalPopulateFields...)
		}
	} else {
		storyBase(e, t, u, additionalPopulateFields...)
	}
}

func storyBase(e *Engine, t assert.TestingT, u user, additionalPopulateFields ...string) *story {
	s := iti_multi(u)
	err := e.Model(&story{}).Save(s)
	assert.Nil(t, err)
	assert.NotZero(t, s.ID)
	checkChapters(t, s)
	var ns story
	fields := []string{
		PopulateAll,
	}
	fields = append(fields, additionalPopulateFields...)
	err = e.Model(&story{}).Where("ID = ?", s.ID).Populate(fields...).Find(&ns)
	assert.Nil(t, err)
	assert.NotZero(t, ns.ID)
	assert.NotZero(t, ns.Author.ID)
	assert.NotZero(t, ns.Author.Username)
	assert.Equal(t, len(s.Chapters), len(ns.Chapters))
	checkChapters(t, &ns)
	return &ns
}

func testFind1(t assert.TestingT, e *Engine) {
	u := author(t)
	err := e.Model(&user{}).Save(&u)
	assert.Nil(t, err)
	var nu user
	err = e.Model(&user{}).Where("ID = ?", u.ID).Find(&nu)
	assert.Nil(t, err)
	assert.NotZero(t, nu.ID)
	assert.NotZero(t, nu.Username)
}

func testJoin1(t assert.TestingT, e *Engine) {
	u := author(t)
	err := e.Model(&user{}).Save(&u)
	assert.Nil(t, err)
	insertBands(t, e)
	storyBaseLoop(t, e, u, 7)
	var withBodom []story
	err = e.Model(&story{}).
		Join("Chapters.Bands").
		In("Chapters.Bands.ID", bodom.ID).
		Find(&withBodom)
	assert.Nil(t, err)
	assert.NotEmpty(t, withBodom)
}

func testIn(t assert.TestingT, e *Engine) {
	u := author(t)
	err := e.Model(&user{}).Save(&u)
	assert.Nil(t, err)
	insertBands(t, e)
	storyBaseLoop(t, e, u, 10)
	var threes []story
	err = e.Model(&story{}).
		In("ID", 1, 2, 3).
		Find(&threes)
	assert.Nil(t, err)
	assert.GreaterOrEqual(t, len(threes), 1)
}

func testPopulateAll(t assert.TestingT, e *Engine) {
	insertBands(t, e)
	u := author(t)
	err := e.Model(&user{}).Create(&u)
	assert.Nil(t, err)
	storyBase(e, t, u)
}

func testPopulateNested1(t assert.TestingT, e *Engine) {
	u := author(t)
	f := friend(t)

	err := e.Model(&user{}).Create(&f)
	assert.Nil(t, err)
	assert.NotZero(t, f.ID)

	err = e.Model(&user{}).Create(&u)
	assert.NotZero(t, u.Favs.ID)
	assert.Nil(t, err)

	u.Favs.Authors = append(u.Favs.Authors, f)
	err = e.Model(&user{}).Save(&u)
	assert.Nil(t, err)

	var nu user
	err = e.Model(&user{}).
		Populate(PopulateAll, "Favs.Authors").
		Where("ID = ?", u.ID).
		Find(&nu)
	assert.Nil(t, err)
	assert.NotZero(t, nu.Favs.ID)
	assert.NotEmpty(t, nu.Favs.Authors)
}

func testPopulateNested2(t assert.TestingT, e *Engine) {
	u := author(t)
	err := e.Model(&user{}).Create(&u)
	assert.Nil(t, err)
	insertBands(t, e)
	ns := storyBase(e, t, u, "Chapters.Bands")
	for _, c := range ns.Chapters {
		assert.NotEmpty(t, c.Bands)
		for _, b := range c.Bands {
			assert.NotZero(t, b.Name)
			assert.NotEmpty(t, b.Characters)
		}
	}
}

func TestFind(t *testing.T) {
	e := initTest(t)
	testFind1(t, e)
}

func TestJoin1(t *testing.T) {
	e := initTest(t)
	testJoin1(t, e)
}

func TestIn(t *testing.T) {
	e := initTest(t)
	testIn(t, e)
}

func TestPopulateAll(t *testing.T) {
	e := initTest(t)
	testPopulateAll(t, e)
}

func TestPopulateNested1(t *testing.T) {
	e := initTest(t)
	testPopulateNested1(t, e)
}

func TestPopulateNested2(t *testing.T) {
	e := initTest(t)
	testPopulateNested2(t, e)
}

func BenchmarkFind(b *testing.B) {
	b.Run("Plain-1", bench(testFind1))
	b.Run("Join-1", bench(testJoin1))
	b.Run("In-1", bench(testIn))
}

func BenchmarkPopulate(b *testing.B) {
	b.Run("Populate", func(b *testing.B) {

		b.Run("Simple-1", bench(testPopulateAll))
		b.Run("Populate-Nested-1", bench(testPopulateNested1))
		b.Run("Populate-Nested-2", bench(testPopulateNested2))
	})
}