package client

import (
	"context"
	"testing"

	"queryorchestration/internal/database"
	"queryorchestration/internal/database/repository"
	"queryorchestration/internal/serviceconfig"

	"github.com/google/uuid"
	"github.com/pashagolub/pgxmock/v3"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestUpdate(t *testing.T) {
	ctx := context.Background()

	pool, err := pgxmock.NewPool()
	require.NoError(t, err)
	cfg := &serviceconfig.BaseConfig{}
	cfg.DBPool = pool
	cfg.DBQueries = repository.New(pool)

	svc := New(cfg)

	c := Client{
		ID:      uuid.New(),
		Name:    "example_name",
		CanSync: false,
	}
	update := Update{}

	pool.ExpectQuery("name: GetClient :one").WithArgs(database.MustToDBUUID(c.ID)).
		WillReturnRows(
			pgxmock.NewRows([]string{"id", "name", "canSync"}).
				AddRow(database.MustToDBUUID(c.ID), c.Name, c.CanSync),
		)

	err = svc.Update(ctx, c.ID, &update)
	assert.Error(t, err)

	c.CanSync = false
	update.CanSync = &c.CanSync

	pool.ExpectQuery("name: GetClient :one").WithArgs(database.MustToDBUUID(c.ID)).
		WillReturnRows(
			pgxmock.NewRows([]string{"id", "name", "canSync"}).
				AddRow(database.MustToDBUUID(c.ID), c.Name, c.CanSync),
		)

	err = svc.Update(ctx, c.ID, &update)
	assert.Error(t, err)

	c.Name = "updated_name"
	update.Name = &c.Name

	pool.ExpectQuery("name: GetClient :one").WithArgs(database.MustToDBUUID(c.ID)).
		WillReturnRows(
			pgxmock.NewRows([]string{"id", "name", "canSync"}).
				AddRow(database.MustToDBUUID(c.ID), c.Name, c.CanSync),
		)
	pool.ExpectExec("name: UpdateClient :exec").WithArgs(*update.Name, database.MustToDBUUID(c.ID)).
		WillReturnResult(pgxmock.NewResult("", 1))

	err = svc.Update(ctx, c.ID, &update)
	assert.Error(t, err)
}

func TestNormalizeUpdateParams(t *testing.T) {
	svc := Service{}

	err := svc.normalizeUpdateParams(uuid.Nil, nil, nil)
	assert.Error(t, err)

	current := &Client{
		ID:   uuid.New(),
		Name: "client",
	}
	update := &Update{}

	err = svc.normalizeUpdateParams(current.ID, current, update)
	assert.Error(t, err)

	n := "updated_client"
	cs := true
	update = &Update{
		Name:    &n,
		CanSync: &cs,
	}
	err = svc.normalizeUpdateParams(current.ID, current, update)
	require.NoError(t, err)
	n = "updated_client"
	cs = true
	assert.EqualExportedValues(t, Update{
		Name:    &n,
		CanSync: &cs,
	}, *update)

	update = &Update{
		Name:    &current.Name,
		CanSync: &current.CanSync,
	}
	err = svc.normalizeUpdateParams(current.ID, current, update)
	assert.Error(t, err)
}

func TestSubmitUpdate(t *testing.T) {
	ctx := context.Background()

	pool, err := pgxmock.NewPool()
	require.NoError(t, err)
	cfg := &serviceconfig.BaseConfig{}
	cfg.DBPool = pool
	cfg.DBQueries = repository.New(pool)

	svc := New(cfg)

	c := Client{
		ID:      uuid.New(),
		Name:    "example_name",
		CanSync: false,
	}
	update := Update{}

	pool.ExpectBegin()
	pool.ExpectCommit()

	err = svc.submitUpdate(ctx, c.ID, &update)
	require.NoError(t, err)

	c.CanSync = true
	update.CanSync = &c.CanSync

	pool.ExpectBegin()
	pool.ExpectExec("name: AddClientCanSync :exec").WithArgs(*update.CanSync, database.MustToDBUUID(c.ID)).
		WillReturnResult(pgxmock.NewResult("", 1))
	pool.ExpectCommit()

	err = svc.submitUpdate(ctx, c.ID, &update)
	require.NoError(t, err)

	c.Name = "updated_name"
	update.Name = &c.Name
	update.CanSync = nil

	pool.ExpectBegin()
	pool.ExpectExec("name: UpdateClient :exec").WithArgs(*update.Name, database.MustToDBUUID(c.ID)).
		WillReturnResult(pgxmock.NewResult("", 1))
	pool.ExpectCommit()

	err = svc.submitUpdate(ctx, c.ID, &update)
	require.NoError(t, err)
}

func TestUpdateByExternalId(t *testing.T) {
	ctx := context.Background()

	pool, err := pgxmock.NewPool()
	require.NoError(t, err)
	cfg := &serviceconfig.BaseConfig{}
	cfg.DBPool = pool
	cfg.DBQueries = repository.New(pool)

	svc := New(cfg)

	c := Client{
		ID:         uuid.New(),
		ExternalID: "extarnal_id",
		Name:       "example_name",
		CanSync:    false,
	}
	t.Run("no update", func(t *testing.T) {
		update := Update{}

		pool.ExpectQuery("name: GetClientByExternalId :one").WithArgs(c.ExternalID).
			WillReturnRows(
				pgxmock.NewRows([]string{"id", "externalId", "name", "canSync"}).
					AddRow(database.MustToDBUUID(c.ID), c.ExternalID, c.Name, c.CanSync),
			)

		pool.ExpectQuery("name: GetClient :one").WithArgs(database.MustToDBUUID(c.ID)).
			WillReturnRows(
				pgxmock.NewRows([]string{"id", "externalId", "name", "canSync"}).
					AddRow(database.MustToDBUUID(c.ID), c.ExternalID, c.Name, c.CanSync),
			)

		err = svc.UpdateByExternalId(ctx, c.ExternalID, &update)
		assert.Error(t, err)
	})
	t.Run("no update", func(t *testing.T) {
		update := Update{}
		c.CanSync = false
		update.CanSync = &c.CanSync

		pool.ExpectQuery("name: GetClient :one").WithArgs(database.MustToDBUUID(c.ID)).
			WillReturnRows(
				pgxmock.NewRows([]string{"id", "name", "canSync"}).
					AddRow(database.MustToDBUUID(c.ID), c.Name, c.CanSync),
			)

		err = svc.UpdateByExternalId(ctx, c.ExternalID, &update)
		assert.Error(t, err)
	})
	t.Run("no update", func(t *testing.T) {
		update := Update{}
		c.Name = "updated_name"
		update.Name = &c.Name

		pool.ExpectQuery("name: GetClient :one").WithArgs(database.MustToDBUUID(c.ID)).
			WillReturnRows(
				pgxmock.NewRows([]string{"id", "name", "canSync"}).
					AddRow(database.MustToDBUUID(c.ID), c.Name, c.CanSync),
			)
		pool.ExpectExec("name: UpdateClient :exec").WithArgs(*update.Name, database.MustToDBUUID(c.ID)).
			WillReturnResult(pgxmock.NewResult("", 1))

		err = svc.UpdateByExternalId(ctx, c.ExternalID, &update)
		assert.Error(t, err)
	})
}