package client

import (
	"context"
	"queryorchestration/internal/database"
	"queryorchestration/internal/database/repository"
	"queryorchestration/internal/serviceconfig"
	"testing"

	"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{
		ID: c.ID,
	}

	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, &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, &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(update.ID)).
		WillReturnResult(pgxmock.NewResult("", 1))

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

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

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

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

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

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

	update = &Update{
		ID:      current.ID,
		Name:    &current.Name,
		CanSync: &current.CanSync,
	}
	err = svc.normalizeUpdateParams(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{
		ID: c.ID,
	}

	pool.ExpectBegin()
	pool.ExpectCommit()

	err = svc.submitUpdate(ctx, &update)
	assert.NoError(t, err)

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

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

	err = svc.submitUpdate(ctx, &update)
	assert.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(update.ID)).
		WillReturnResult(pgxmock.NewResult("", 1))
	pool.ExpectCommit()

	err = svc.submitUpdate(ctx, &update)
	assert.NoError(t, err)
}