package repository

import (
	"baron-sso-backend/internal/domain"
	"context"
	"testing"

	"github.com/stretchr/testify/assert"
)

func TestTenantRepository(t *testing.T) {
	repo := NewTenantRepository(testDB)
	ctx := context.Background()

	t.Run("Create and FindByID", func(t *testing.T) {
		tenant := &domain.Tenant{
			Name: "Test Tenant",
			Slug: "test-tenant",
			Type: domain.TenantTypeCompany,
		}

		err := repo.Create(ctx, tenant)
		assert.NoError(t, err)
		assert.NotEmpty(t, tenant.ID)

		found, err := repo.FindByID(ctx, tenant.ID)
		assert.NoError(t, err)
		assert.Equal(t, tenant.Name, found.Name)
		assert.Equal(t, tenant.Slug, found.Slug)
	})

	t.Run("FindBySlug", func(t *testing.T) {
		tenant := &domain.Tenant{
			Name: "Slug Test",
			Slug: "slug-test",
			Type: domain.TenantTypeCompany,
		}
		_ = repo.Create(ctx, tenant)

		found, err := repo.FindBySlug(ctx, "slug-test")
		assert.NoError(t, err)
		assert.Equal(t, tenant.ID, found.ID)
	})

	t.Run("AddDomain and FindByDomain", func(t *testing.T) {
		tenant := &domain.Tenant{
			Name: "Domain Test",
			Slug: "domain-test",
			Type: domain.TenantTypeCompany,
		}
		_ = repo.Create(ctx, tenant)

		err := repo.AddDomain(ctx, tenant.ID, "test-domain.com", true)
		assert.NoError(t, err)

		found, err := repo.FindByDomain(ctx, "test-domain.com")
		assert.NoError(t, err)
		assert.Equal(t, tenant.ID, found.ID)
		assert.Len(t, found.Domains, 1)
		assert.Equal(t, "test-domain.com", found.Domains[0].Domain)
	})

	t.Run("Update", func(t *testing.T) {
		tenant := &domain.Tenant{
			Name: "Before Update",
			Slug: "before-update",
			Type: domain.TenantTypeCompany,
		}
		_ = repo.Create(ctx, tenant)

		tenant.Name = "After Update"
		err := repo.Update(ctx, tenant)
		assert.NoError(t, err)

		found, err := repo.FindByID(ctx, tenant.ID)
		assert.NoError(t, err)
		assert.Equal(t, "After Update", found.Name)
	})

	t.Run("Hierarchy", func(t *testing.T) {
		parent := &domain.Tenant{
			Name: "Parent Tenant",
			Slug: "parent-hierarchy",
			Type: domain.TenantTypeCompanyGroup,
		}
		err := repo.Create(ctx, parent)
		assert.NoError(t, err)

		child := &domain.Tenant{
			Name:     "Child Tenant",
			Slug:     "child-hierarchy",
			Type:     domain.TenantTypeCompany,
			ParentID: &parent.ID,
		}
		err = repo.Create(ctx, child)
		assert.NoError(t, err)

		foundChild, err := repo.FindByID(ctx, child.ID)
		assert.NoError(t, err)
		assert.Equal(t, parent.ID, *foundChild.ParentID)
	})

	t.Run("Unique Constraint on Slug", func(t *testing.T) {
		slug := "unique-slug-test"
		tenant1 := &domain.Tenant{
			Name: "First",
			Slug: slug,
			Type: domain.TenantTypeCompany,
		}
		err := repo.Create(ctx, tenant1)
		assert.NoError(t, err)

		tenant2 := &domain.Tenant{
			Name: "Second",
			Slug: slug,
			Type: domain.TenantTypeCompany,
		}
		err = repo.Create(ctx, tenant2)
		assert.Error(t, err) // Should fail due to UNIQUE constraint
	})
}