package folder_test

import (
	"testing"

	"queryorchestration/internal/database/repository"
	"queryorchestration/internal/folder"
	"queryorchestration/internal/serviceconfig"
	"queryorchestration/internal/test"

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

type TestConfig struct {
	serviceconfig.BaseConfig
}

func TestCreateFolder(t *testing.T) {
	ctx := t.Context()
	cfg := &TestConfig{}
	test.CreateDB(t, cfg)
	svc := folder.New(cfg)

	// Create test client first
	clientID := "test-client-folders"
	err := cfg.GetDBQueries().CreateClient(ctx, &repository.CreateClientParams{
		Clientid: clientID,
		Name:     "Test Client Folders",
	})
	require.NoError(t, err)

	t.Run("create root folder successfully", func(t *testing.T) {
		path := "/documents"
		createdBy := "user123"

		result, err := svc.CreateFolder(ctx, path, nil, clientID, createdBy)
		require.NoError(t, err)
		require.NotNil(t, result)
		assert.Equal(t, path, result.Path)
		assert.Nil(t, result.Parentid)
		assert.Equal(t, clientID, result.Clientid)
		assert.Equal(t, createdBy, result.Createdby)
	})

	t.Run("create subfolder with valid parent", func(t *testing.T) {
		// Create parent folder
		parentPath := "/contracts"
		parentResult, err := svc.CreateFolder(ctx, parentPath, nil, clientID, "user123")
		require.NoError(t, err)
		parentID := parentResult.ID

		// Create subfolder
		subPath := "/contracts/2025"
		result, err := svc.CreateFolder(ctx, subPath, &parentID, clientID, "user123")
		require.NoError(t, err)
		require.NotNil(t, result)
		assert.Equal(t, subPath, result.Path)
		require.NotNil(t, result.Parentid)
		assert.Equal(t, parentID, *result.Parentid)
	})

	t.Run("reject empty path", func(t *testing.T) {
		_, err := svc.CreateFolder(ctx, "", nil, clientID, "user123")
		require.Error(t, err)
		assert.Contains(t, err.Error(), "path cannot be empty")
	})

	t.Run("reject empty clientID", func(t *testing.T) {
		_, err := svc.CreateFolder(ctx, "/test", nil, "", "user123")
		require.Error(t, err)
		assert.Contains(t, err.Error(), "clientID cannot be empty")
	})

	t.Run("reject empty createdBy", func(t *testing.T) {
		_, err := svc.CreateFolder(ctx, "/test", nil, clientID, "")
		require.Error(t, err)
		assert.Contains(t, err.Error(), "createdBy cannot be empty")
	})

	t.Run("reject parent from different client", func(t *testing.T) {
		// Create another client
		otherClientID := "other-client"
		err := cfg.GetDBQueries().CreateClient(ctx, &repository.CreateClientParams{
			Clientid: otherClientID,
			Name:     "Other Client",
		})
		require.NoError(t, err)

		// Create parent folder for other client
		parentResult, err := svc.CreateFolder(ctx, "/other", nil, otherClientID, "user123")
		require.NoError(t, err)
		parentID := parentResult.ID

		// Try to create subfolder with parent from different client
		_, err = svc.CreateFolder(ctx, "/test", &parentID, clientID, "user123")
		require.Error(t, err)
		assert.Contains(t, err.Error(), "different client")
	})
}

func TestGetFolder(t *testing.T) {
	ctx := t.Context()
	cfg := &TestConfig{}
	test.CreateDB(t, cfg)
	svc := folder.New(cfg)

	clientID := "test-client-get"
	err := cfg.GetDBQueries().CreateClient(ctx, &repository.CreateClientParams{
		Clientid: clientID,
		Name:     "Test Client Get",
	})
	require.NoError(t, err)

	// Create a folder
	path := "/documents"
	created, err := svc.CreateFolder(ctx, path, nil, clientID, "user123")
	require.NoError(t, err)

	// Get the folder
	result, err := svc.GetFolder(ctx, created.ID)
	require.NoError(t, err)
	assert.Equal(t, created.ID, result.ID)
	assert.Equal(t, path, result.Path)
}

func TestGetFolderByPath(t *testing.T) {
	ctx := t.Context()
	cfg := &TestConfig{}
	test.CreateDB(t, cfg)
	svc := folder.New(cfg)

	clientID := "test-client-path"
	err := cfg.GetDBQueries().CreateClient(ctx, &repository.CreateClientParams{
		Clientid: clientID,
		Name:     "Test Client Path",
	})
	require.NoError(t, err)

	// Create a folder
	path := "/documents/2025"
	created, err := svc.CreateFolder(ctx, path, nil, clientID, "user123")
	require.NoError(t, err)

	// Get by path
	result, err := svc.GetFolderByPath(ctx, clientID, path)
	require.NoError(t, err)
	assert.Equal(t, created.ID, result.ID)
	assert.Equal(t, path, result.Path)
	assert.Equal(t, clientID, result.Clientid)
}

func TestRenameFolder(t *testing.T) {
	ctx := t.Context()
	cfg := &TestConfig{}
	test.CreateDB(t, cfg)
	svc := folder.New(cfg)

	clientID := "test-client-rename"
	err := cfg.GetDBQueries().CreateClient(ctx, &repository.CreateClientParams{
		Clientid: clientID,
		Name:     "Test Client Rename",
	})
	require.NoError(t, err)

	t.Run("rename successfully", func(t *testing.T) {
		oldPath := "/old-path"
		created, err := svc.CreateFolder(ctx, oldPath, nil, clientID, "user123")
		require.NoError(t, err)

		newPath := "/new-path"
		err = svc.RenameFolder(ctx, created.ID, newPath)
		require.NoError(t, err)

		// Verify rename
		result, err := svc.GetFolder(ctx, created.ID)
		require.NoError(t, err)
		assert.Equal(t, newPath, result.Path)
	})

	t.Run("reject empty path", func(t *testing.T) {
		err := svc.RenameFolder(ctx, uuid.New(), "")
		require.Error(t, err)
		assert.Contains(t, err.Error(), "path cannot be empty")
	})
}

func TestGetFolderTree(t *testing.T) {
	ctx := t.Context()
	cfg := &TestConfig{}
	test.CreateDB(t, cfg)
	svc := folder.New(cfg)

	clientID := "test-client-tree"
	err := cfg.GetDBQueries().CreateClient(ctx, &repository.CreateClientParams{
		Clientid: clientID,
		Name:     "Test Client Tree",
	})
	require.NoError(t, err)

	// Create folder hierarchy
	root, err := svc.CreateFolder(ctx, "/documents", nil, clientID, "user123")
	require.NoError(t, err)

	child1, err := svc.CreateFolder(ctx, "/documents/2025", &root.ID, clientID, "user123")
	require.NoError(t, err)

	_, err = svc.CreateFolder(ctx, "/documents/2025/january", &child1.ID, clientID, "user123")
	require.NoError(t, err)

	// Get tree
	result, err := svc.GetFolderTree(ctx, root.ID)
	require.NoError(t, err)
	assert.Len(t, result, 3) // root + 2 descendants
	assert.Equal(t, root.ID, result[0].ID)
}

func TestGetFoldersByClient(t *testing.T) {
	ctx := t.Context()
	cfg := &TestConfig{}
	test.CreateDB(t, cfg)
	svc := folder.New(cfg)

	clientID := "test-client-list"
	err := cfg.GetDBQueries().CreateClient(ctx, &repository.CreateClientParams{
		Clientid: clientID,
		Name:     "Test Client List",
	})
	require.NoError(t, err)

	// Create multiple folders
	_, err = svc.CreateFolder(ctx, "/documents", nil, clientID, "user123")
	require.NoError(t, err)
	_, err = svc.CreateFolder(ctx, "/contracts", nil, clientID, "user123")
	require.NoError(t, err)

	result, err := svc.GetFoldersByClient(ctx, clientID)
	require.NoError(t, err)
	assert.GreaterOrEqual(t, len(result), 2)
}

func TestGetRootFolders(t *testing.T) {
	ctx := t.Context()
	cfg := &TestConfig{}
	test.CreateDB(t, cfg)
	svc := folder.New(cfg)

	clientID := "test-client-roots"
	err := cfg.GetDBQueries().CreateClient(ctx, &repository.CreateClientParams{
		Clientid: clientID,
		Name:     "Test Client Roots",
	})
	require.NoError(t, err)

	// Create root folder
	root, err := svc.CreateFolder(ctx, "/documents", nil, clientID, "user123")
	require.NoError(t, err)

	// Create child folder
	_, err = svc.CreateFolder(ctx, "/documents/sub", &root.ID, clientID, "user123")
	require.NoError(t, err)

	// Get only root folders
	result, err := svc.GetRootFolders(ctx, clientID)
	require.NoError(t, err)

	// Filter to only this test's root
	var foundRoot *repository.Folder
	for _, f := range result {
		if f.ID == root.ID {
			foundRoot = f
			break
		}
	}
	require.NotNil(t, foundRoot)
	assert.Nil(t, foundRoot.Parentid)
}

func TestGetSubfolders(t *testing.T) {
	ctx := t.Context()
	cfg := &TestConfig{}
	test.CreateDB(t, cfg)
	svc := folder.New(cfg)

	clientID := "test-client-subs"
	err := cfg.GetDBQueries().CreateClient(ctx, &repository.CreateClientParams{
		Clientid: clientID,
		Name:     "Test Client Subs",
	})
	require.NoError(t, err)

	// Create parent
	parent, err := svc.CreateFolder(ctx, "/documents", nil, clientID, "user123")
	require.NoError(t, err)

	// Create child
	child, err := svc.CreateFolder(ctx, "/documents/2025", &parent.ID, clientID, "user123")
	require.NoError(t, err)

	// Get subfolders
	result, err := svc.GetSubfolders(ctx, parent.ID)
	require.NoError(t, err)
	assert.Len(t, result, 1)
	assert.Equal(t, child.ID, result[0].ID)
	assert.Equal(t, parent.ID, *result[0].Parentid)
}