package service

import (
	"context"
	"testing"

	"github.com/gochat/gochat/internal/config"
	"github.com/gochat/gochat/internal/model"
	"github.com/gochat/gochat/internal/repository"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"gorm.io/gorm"
)

// ============================================================
// AccountService tests
// ============================================================

func newAccountServiceDB(t *testing.T) *gorm.DB {
	return newSimpleServiceTestDB(t)
}

func TestAccountService_GetByID(t *testing.T) {
	db := newAccountServiceDB(t)
	repo := repository.NewAccountRepo(db)
	svc := NewAccountService(repo)

	acc := &model.Account{Name: "TestAcc"}
	require.NoError(t, db.Create(acc).Error)

	got, err := svc.GetByID(context.Background(), acc.ID)
	require.NoError(t, err)
	assert.Equal(t, "TestAcc", got.Name)
}

func TestAccountService_GetByID_NotFound(t *testing.T) {
	db := newAccountServiceDB(t)
	repo := repository.NewAccountRepo(db)
	svc := NewAccountService(repo)

	_, err := svc.GetByID(context.Background(), 99999)
	require.Error(t, err)
}

func TestAccountService_ListByUser(t *testing.T) {
	db := newAccountServiceDB(t)
	repo := repository.NewAccountRepo(db)
	svc := NewAccountService(repo)

	require.NoError(t, db.Create(&model.Account{Name: "A1"}).Error)
	require.NoError(t, db.Create(&model.User{Name: "U", Email: "u@e.com", Password: "x", Role: "admin", Active: true}).Error)
	require.NoError(t, db.Create(&model.AccountUser{UserID: 1, AccountID: 1, Role: "admin"}).Error)

	list, total, err := svc.ListByUser(context.Background(), 1, 0, 10)
	require.NoError(t, err)
	assert.GreaterOrEqual(t, total, int64(1))
	assert.GreaterOrEqual(t, len(list), 1)
}

func TestAccountService_Create(t *testing.T) {
	db := newAccountServiceDB(t)
	repo := repository.NewAccountRepo(db)
	svc := NewAccountService(repo)

	require.NoError(t, db.Create(&model.User{Name: "U", Email: "u@e.com", Password: "x", Role: "admin", Active: true}).Error)

	acc, err := svc.Create(context.Background(), 1, CreateAccountRequest{Name: "NewAcc"})
	require.NoError(t, err)
	assert.Equal(t, "NewAcc", acc.Name)
	assert.NotZero(t, acc.ID)
}

func TestAccountService_Update(t *testing.T) {
	db := newAccountServiceDB(t)
	repo := repository.NewAccountRepo(db)
	svc := NewAccountService(repo)

	acc := &model.Account{Name: "Orig"}
	require.NoError(t, db.Create(acc).Error)

	updated, err := svc.Update(context.Background(), acc.ID, UpdateAccountRequest{Name: "Updated"})
	require.NoError(t, err)
	assert.Equal(t, "Updated", updated.Name)
}

func TestAccountService_Delete(t *testing.T) {
	db := newAccountServiceDB(t)
	repo := repository.NewAccountRepo(db)
	svc := NewAccountService(repo)

	acc := &model.Account{Name: "Del"}
	require.NoError(t, db.Create(acc).Error)
	require.NoError(t, svc.Delete(context.Background(), acc.ID))
}

func TestAccountService_UpdateOnboarding(t *testing.T) {
	db := newAccountServiceDB(t)
	repo := repository.NewAccountRepo(db)
	svc := NewAccountService(repo)

	acc := &model.Account{Name: "OB"}
	require.NoError(t, db.Create(acc).Error)

	name := "Updated"
	updated, err := svc.UpdateOnboarding(context.Background(), acc.ID, UpdateAccountOnboardingRequest{
		Name: &name,
	})
	require.NoError(t, err)
	assert.Equal(t, "Updated", updated.Name)
}

func TestAccountService_UpdateSettings(t *testing.T) {
	db := newAccountServiceDB(t)
	repo := repository.NewAccountRepo(db)
	svc := NewAccountService(repo)

	acc := &model.Account{Name: "S"}
	require.NoError(t, db.Create(acc).Error)

	updated, err := svc.UpdateSettings(context.Background(), acc.ID, UpdateAccountSettingsRequest{
		AutoResolveDuration: 10,
		Locale:              "en",
	})
	require.NoError(t, err)
	assert.NotNil(t, updated)
}

func TestAccountService_DB(t *testing.T) {
	db := newAccountServiceDB(t)
	repo := repository.NewAccountRepo(db)
	svc := NewAccountService(repo)
	assert.NotNil(t, svc.DB())
}

func TestAccountService_GetByUserAndID(t *testing.T) {
	db := newAccountServiceDB(t)
	repo := repository.NewAccountRepo(db)
	svc := NewAccountService(repo)

	require.NoError(t, db.Create(&model.Account{Name: "A"}).Error)
	require.NoError(t, db.Create(&model.User{Name: "U", Email: "u@e.com", Password: "x", Role: "admin", Active: true}).Error)
	require.NoError(t, db.Create(&model.AccountUser{UserID: 1, AccountID: 1, Role: "admin"}).Error)

	acc, err := svc.GetByUserAndID(context.Background(), 1, 1)
	require.NoError(t, err)
	assert.Equal(t, "A", acc.Name)
}

// ============================================================
// ContactService tests
// ============================================================

func newContactServiceDB(t *testing.T) *gorm.DB {
	return newSimpleServiceTestDB(t)
}

func TestContactService_GetByID(t *testing.T) {
	db := newContactServiceDB(t)
	contactRepo := repository.NewContactRepo(db)
	contactInboxRepo := repository.NewContactInboxRepo(db)
	noteRepo := repository.NewNoteRepo(db)
	contactInboxSvc := NewContactInboxService(contactInboxRepo)
	svc := NewContactService(contactRepo, contactInboxSvc, noteRepo)

	c := &model.Contact{AccountID: 1, Name: "C1"}
	require.NoError(t, db.Create(c).Error)

	got, err := svc.GetByID(context.Background(), c.ID)
	require.NoError(t, err)
	assert.Equal(t, "C1", got.Name)
}

func TestContactService_GetByID_NotFound(t *testing.T) {
	db := newContactServiceDB(t)
	contactRepo := repository.NewContactRepo(db)
	contactInboxRepo := repository.NewContactInboxRepo(db)
	noteRepo := repository.NewNoteRepo(db)
	contactInboxSvc := NewContactInboxService(contactInboxRepo)
	svc := NewContactService(contactRepo, contactInboxSvc, noteRepo)

	_, err := svc.GetByID(context.Background(), 99999)
	require.Error(t, err)
}

func TestContactService_GetByAccountAndID(t *testing.T) {
	db := newContactServiceDB(t)
	contactRepo := repository.NewContactRepo(db)
	contactInboxRepo := repository.NewContactInboxRepo(db)
	noteRepo := repository.NewNoteRepo(db)
	contactInboxSvc := NewContactInboxService(contactInboxRepo)
	svc := NewContactService(contactRepo, contactInboxSvc, noteRepo)

	c := &model.Contact{AccountID: 1, Name: "C1"}
	require.NoError(t, db.Create(c).Error)

	got, err := svc.GetByAccountAndID(context.Background(), 1, c.ID)
	require.NoError(t, err)
	assert.Equal(t, "C1", got.Name)
}

func TestContactService_ListByAccount(t *testing.T) {
	db := newContactServiceDB(t)
	contactRepo := repository.NewContactRepo(db)
	contactInboxRepo := repository.NewContactInboxRepo(db)
	noteRepo := repository.NewNoteRepo(db)
	contactInboxSvc := NewContactInboxService(contactInboxRepo)
	svc := NewContactService(contactRepo, contactInboxSvc, noteRepo)

	require.NoError(t, db.Create(&model.Contact{AccountID: 1, Name: "C1", Email: "c1@test.com"}).Error)
	require.NoError(t, db.Create(&model.Contact{AccountID: 1, Name: "C2", Email: "c2@test.com"}).Error)

	list, total, err := svc.ListByAccount(context.Background(), 1, 0, 10, "")
	require.NoError(t, err)
	assert.Equal(t, int64(2), total)
	assert.Len(t, list, 2)
}

func TestContactService_Create(t *testing.T) {
	db := newContactServiceDB(t)
	contactRepo := repository.NewContactRepo(db)
	contactInboxRepo := repository.NewContactInboxRepo(db)
	noteRepo := repository.NewNoteRepo(db)
	contactInboxSvc := NewContactInboxService(contactInboxRepo)
	svc := NewContactService(contactRepo, contactInboxSvc, noteRepo)

	created, err := svc.Create(context.Background(), 1, CreateContactRequest{
		Name: "NewContact",
	})
	require.NoError(t, err)
	assert.Equal(t, "NewContact", created.Name)
	assert.NotZero(t, created.ID)
}

func TestContactService_ListContactInboxes(t *testing.T) {
	db := newContactServiceDB(t)
	contactRepo := repository.NewContactRepo(db)
	contactInboxRepo := repository.NewContactInboxRepo(db)
	noteRepo := repository.NewNoteRepo(db)
	contactInboxSvc := NewContactInboxService(contactInboxRepo)
	svc := NewContactService(contactRepo, contactInboxSvc, noteRepo)

	c := &model.Contact{AccountID: 1, Name: "C"}
	require.NoError(t, db.Create(c).Error)
	require.NoError(t, db.Create(&model.ContactInbox{ContactID: c.ID, InboxID: 1, SourceID: "src1"}).Error)

	inboxes, err := svc.ListContactInboxes(context.Background(), c.ID)
	require.NoError(t, err)
	assert.Len(t, inboxes, 1)
}

func TestContactService_DB(t *testing.T) {
	db := newContactServiceDB(t)
	contactRepo := repository.NewContactRepo(db)
	contactInboxRepo := repository.NewContactInboxRepo(db)
	noteRepo := repository.NewNoteRepo(db)
	contactInboxSvc := NewContactInboxService(contactInboxRepo)
	svc := NewContactService(contactRepo, contactInboxSvc, noteRepo)
	assert.NotNil(t, svc.DB())
}

func TestContactService_Ready(t *testing.T) {
	db := newContactServiceDB(t)
	contactRepo := repository.NewContactRepo(db)
	contactInboxRepo := repository.NewContactInboxRepo(db)
	noteRepo := repository.NewNoteRepo(db)
	contactInboxSvc := NewContactInboxService(contactInboxRepo)
	svc := NewContactService(contactRepo, contactInboxSvc, noteRepo)
	assert.True(t, svc.Ready())
}

// ============================================================
// ArticleService tests
// ============================================================

func newArticleServiceDB(t *testing.T) *gorm.DB {
	db := newSimpleServiceTestDB(t)
	db.AutoMigrate(&model.Article{})
	return db
}

func TestArticleService_Create(t *testing.T) {
	db := newArticleServiceDB(t)
	repo := repository.NewArticleRepo(db)
	svc := NewArticleService(repo)

	article, err := svc.Create(context.Background(), 1, 1, &CreateArticleRequest{
		Title:   "Test Article",
		Content: "Content here",
		Status:  model.ArticleStatus("published"),
	})
	require.NoError(t, err)
	assert.Equal(t, "Test Article", article.Title)
}

func TestArticleService_GetByID(t *testing.T) {
	db := newArticleServiceDB(t)
	repo := repository.NewArticleRepo(db)
	svc := NewArticleService(repo)

	a := &model.Article{PortalID: 1, AuthorID: uintPtr(1), Title: "A", Content: "C", Status: "draft"}
	require.NoError(t, db.Create(a).Error)

	got, err := svc.GetByID(context.Background(), a.ID)
	require.NoError(t, err)
	assert.Equal(t, "A", got.Title)
}

func TestArticleService_GetByID_NotFound(t *testing.T) {
	db := newArticleServiceDB(t)
	repo := repository.NewArticleRepo(db)
	svc := NewArticleService(repo)

	_, err := svc.GetByID(context.Background(), 99999)
	require.Error(t, err)
}

func TestArticleService_GetByPortalAndID(t *testing.T) {
	db := newArticleServiceDB(t)
	repo := repository.NewArticleRepo(db)
	svc := NewArticleService(repo)

	a := &model.Article{PortalID: 1, AuthorID: uintPtr(1), Title: "A", Content: "C", Status: "draft"}
	require.NoError(t, db.Create(a).Error)

	got, err := svc.GetByPortalAndID(context.Background(), 1, a.ID)
	require.NoError(t, err)
	assert.Equal(t, "A", got.Title)
}

func TestArticleService_Update(t *testing.T) {
	db := newArticleServiceDB(t)
	repo := repository.NewArticleRepo(db)
	svc := NewArticleService(repo)

	a := &model.Article{PortalID: 1, AuthorID: uintPtr(1), Title: "Orig", Content: "C", Status: "draft"}
	require.NoError(t, db.Create(a).Error)

	newTitle := "Updated"
	newContent := "New content"
	updated, err := svc.Update(context.Background(), a.ID, &UpdateArticleRequest{
		Title:   &newTitle,
		Content: &newContent,
	})
	require.NoError(t, err)
	assert.Equal(t, "Updated", updated.Title)
}

func TestArticleService_Delete(t *testing.T) {
	db := newArticleServiceDB(t)
	repo := repository.NewArticleRepo(db)
	svc := NewArticleService(repo)

	a := &model.Article{PortalID: 1, AuthorID: uintPtr(1), Title: "Del", Content: "C", Status: "draft"}
	require.NoError(t, db.Create(a).Error)

	require.NoError(t, svc.Delete(context.Background(), a.ID))
}

func TestArticleService_DeleteScoped(t *testing.T) {
	db := newArticleServiceDB(t)
	repo := repository.NewArticleRepo(db)
	svc := NewArticleService(repo)

	a := &model.Article{PortalID: 1, AuthorID: uintPtr(1), Title: "Del", Content: "C", Status: "draft"}
	require.NoError(t, db.Create(a).Error)

	require.NoError(t, svc.DeleteScoped(context.Background(), 1, a.ID))
}

func TestArticleService_ListByPortalID(t *testing.T) {
	db := newArticleServiceDB(t)
	repo := repository.NewArticleRepo(db)
	svc := NewArticleService(repo)

	require.NoError(t, db.Create(&model.Article{PortalID: 1, AuthorID: uintPtr(1), Title: "A1", Slug: "a1", Content: "C", Status: "published"}).Error)
	require.NoError(t, db.Create(&model.Article{PortalID: 1, AuthorID: uintPtr(1), Title: "A2", Slug: "a2", Content: "C", Status: "draft"}).Error)

	list, total, err := svc.ListByPortalID(context.Background(), 1, 1, 10)
	require.NoError(t, err)
	assert.Equal(t, int64(2), total)
	assert.Len(t, list, 2)
}

// ============================================================
// RBACService tests
// ============================================================

func newRBACServiceDB(t *testing.T) *gorm.DB {
	db := newSimpleServiceTestDB(t)
	db.AutoMigrate(&model.CustomRole{}, &model.PlatformApp{}, &model.AccessToken{})
	return db
}

func TestRBACService_GetAccountUser(t *testing.T) {
	db := newRBACServiceDB(t)
	svc := NewRBACService(db)

	require.NoError(t, db.Create(&model.AccountUser{UserID: 1, AccountID: 1, Role: "agent"}).Error)

	au, err := svc.GetAccountUser(1, 1)
	require.NoError(t, err)
	assert.Equal(t, "agent", au.Role)
}

func TestRBACService_GetAccountUser_NotFound(t *testing.T) {
	db := newRBACServiceDB(t)
	svc := NewRBACService(db)

	_, err := svc.GetAccountUser(999, 999)
	require.Error(t, err)
}

func TestRBACService_AddAccountUser(t *testing.T) {
	db := newRBACServiceDB(t)
	svc := NewRBACService(db)

	au, err := svc.AddAccountUser(1, 1, "agent", 0, 1)
	require.NoError(t, err)
	assert.Equal(t, "agent", au.Role)
}

func TestRBACService_UpdateAccountUserRole(t *testing.T) {
	db := newRBACServiceDB(t)
	svc := NewRBACService(db)

	require.NoError(t, db.Create(&model.AccountUser{UserID: 1, AccountID: 1, Role: "agent"}).Error)

	au, err := svc.UpdateAccountUserRole(1, 1, "administrator", 0)
	require.NoError(t, err)
	assert.Equal(t, "administrator", au.Role)
}

func TestRBACService_RemoveAccountUser(t *testing.T) {
	db := newRBACServiceDB(t)
	svc := NewRBACService(db)

	require.NoError(t, db.Create(&model.AccountUser{UserID: 1, AccountID: 1, Role: "agent"}).Error)

	require.NoError(t, svc.RemoveAccountUser(1, 1))
}

func TestRBACService_ListAccountUsers(t *testing.T) {
	db := newRBACServiceDB(t)
	svc := NewRBACService(db)

	require.NoError(t, db.Create(&model.AccountUser{UserID: 1, AccountID: 1, Role: "agent"}).Error)
	require.NoError(t, db.Create(&model.AccountUser{UserID: 2, AccountID: 1, Role: "admin"}).Error)

	users, err := svc.ListAccountUsers(1)
	require.NoError(t, err)
	assert.Len(t, users, 2)
}

func TestRBACService_ListUserAccounts(t *testing.T) {
	db := newRBACServiceDB(t)
	svc := NewRBACService(db)

	require.NoError(t, db.Create(&model.AccountUser{UserID: 1, AccountID: 1, Role: "agent"}).Error)
	require.NoError(t, db.Create(&model.AccountUser{UserID: 1, AccountID: 2, Role: "admin"}).Error)

	accounts, err := svc.ListUserAccounts(1)
	require.NoError(t, err)
	assert.Len(t, accounts, 2)
}

func TestRBACService_UpdateAvailability(t *testing.T) {
	db := newRBACServiceDB(t)
	svc := NewRBACService(db)

	require.NoError(t, db.Create(&model.AccountUser{UserID: 1, AccountID: 1, Role: "agent"}).Error)

	require.NoError(t, svc.UpdateAvailability(1, 1, "online"))
}

func TestRBACService_CreateCustomRole(t *testing.T) {
	db := newRBACServiceDB(t)
	svc := NewRBACService(db)

	role, err := svc.CreateCustomRole(1, "CustomRole", nil, "Test role")
	require.NoError(t, err)
	assert.Equal(t, "CustomRole", role.Name)
}

func TestRBACService_GetCustomRole(t *testing.T) {
	db := newRBACServiceDB(t)
	svc := NewRBACService(db)

	r := &model.CustomRole{AccountID: 1, Name: "CR", Description: "desc"}
	require.NoError(t, db.Create(r).Error)

	got, err := svc.GetCustomRole(r.ID)
	require.NoError(t, err)
	assert.Equal(t, "CR", got.Name)
}

func TestRBACService_ListCustomRoles(t *testing.T) {
	db := newRBACServiceDB(t)
	svc := NewRBACService(db)

	require.NoError(t, db.Create(&model.CustomRole{AccountID: 1, Name: "R1"}).Error)
	require.NoError(t, db.Create(&model.CustomRole{AccountID: 1, Name: "R2"}).Error)

	roles, err := svc.ListCustomRoles(1)
	require.NoError(t, err)
	assert.Len(t, roles, 2)
}

func TestRBACService_UpdateCustomRole(t *testing.T) {
	db := newRBACServiceDB(t)
	svc := NewRBACService(db)

	r := &model.CustomRole{AccountID: 1, Name: "Orig", Description: "d"}
	require.NoError(t, db.Create(r).Error)

	updated, err := svc.UpdateCustomRole(r.ID, "Updated", nil, "new desc")
	require.NoError(t, err)
	assert.Equal(t, "Updated", updated.Name)
}

func TestRBACService_DeleteCustomRole(t *testing.T) {
	db := newRBACServiceDB(t)
	svc := NewRBACService(db)

	r := &model.CustomRole{AccountID: 1, Name: "Del"}
	require.NoError(t, db.Create(r).Error)

	require.NoError(t, svc.DeleteCustomRole(r.ID))
}

func TestRBACService_BuildPolicyContext(t *testing.T) {
	db := newRBACServiceDB(t)
	svc := NewRBACService(db)

	require.NoError(t, db.Create(&model.AccountUser{UserID: 1, AccountID: 1, Role: "admin"}).Error)

	ctx, err := svc.BuildPolicyContext(1, 1)
	require.NoError(t, err)
	assert.NotNil(t, ctx)
}

func TestRBACService_CanPerform(t *testing.T) {
	db := newRBACServiceDB(t)
	svc := NewRBACService(db)

	require.NoError(t, db.Create(&model.AccountUser{UserID: 1, AccountID: 1, Role: "admin"}).Error)

	can, err := svc.CanPerform(1, 1, "read", "conversation")
	require.NoError(t, err)
	_ = can
}

// ============================================================
// PlatformAppService tests
// ============================================================

func newPlatformAppServiceDB(t *testing.T) *gorm.DB {
	db := newSimpleServiceTestDB(t)
	db.AutoMigrate(&model.PlatformApp{}, &model.AccessToken{}, &model.Permissible{})
	return db
}

func TestPlatformAppService_Create(t *testing.T) {
	db := newPlatformAppServiceDB(t)
	repo := repository.NewPlatformAppRepo(db)
	tokenRepo := repository.NewAccessTokenRepo(db)
	permRepo := repository.NewPermissibleRepo(db)
	svc := NewPlatformAppService(repo, tokenRepo, permRepo)

	app, token, err := svc.Create(context.Background(), CreatePlatformAppRequest{
		Name:        "TestApp",
		AccountID:   1,
		Type:        "api",
		Description: "Test app",
	})
	require.NoError(t, err)
	assert.Equal(t, "TestApp", app.Name)
	assert.NotEmpty(t, token)
}

func TestPlatformAppService_GetByID(t *testing.T) {
	db := newPlatformAppServiceDB(t)
	repo := repository.NewPlatformAppRepo(db)
	tokenRepo := repository.NewAccessTokenRepo(db)
	permRepo := repository.NewPermissibleRepo(db)
	svc := NewPlatformAppService(repo, tokenRepo, permRepo)

	app, _, err := svc.Create(context.Background(), CreatePlatformAppRequest{Name: "App", AccountID: 1, Type: "api"})
	require.NoError(t, err)

	got, err := svc.GetByID(context.Background(), app.ID)
	require.NoError(t, err)
	assert.Equal(t, "App", got.Name)
}

func TestPlatformAppService_GetByID_NotFound(t *testing.T) {
	db := newPlatformAppServiceDB(t)
	repo := repository.NewPlatformAppRepo(db)
	tokenRepo := repository.NewAccessTokenRepo(db)
	permRepo := repository.NewPermissibleRepo(db)
	svc := NewPlatformAppService(repo, tokenRepo, permRepo)

	_, err := svc.GetByID(context.Background(), 99999)
	require.Error(t, err)
}

func TestPlatformAppService_ListAll(t *testing.T) {
	db := newPlatformAppServiceDB(t)
	repo := repository.NewPlatformAppRepo(db)
	tokenRepo := repository.NewAccessTokenRepo(db)
	permRepo := repository.NewPermissibleRepo(db)
	svc := NewPlatformAppService(repo, tokenRepo, permRepo)

	_, _, err := svc.Create(context.Background(), CreatePlatformAppRequest{Name: "A1", AccountID: 1, Type: "api"})
	require.NoError(t, err)
	_, _, err = svc.Create(context.Background(), CreatePlatformAppRequest{Name: "A2", AccountID: 1, Type: "api"})
	require.NoError(t, err)

	apps, total, err := svc.ListAll(context.Background(), 0, 10)
	require.NoError(t, err)
	assert.Equal(t, int64(2), total)
	assert.Len(t, apps, 2)
}

func TestPlatformAppService_ListByAccount(t *testing.T) {
	db := newPlatformAppServiceDB(t)
	repo := repository.NewPlatformAppRepo(db)
	tokenRepo := repository.NewAccessTokenRepo(db)
	permRepo := repository.NewPermissibleRepo(db)
	svc := NewPlatformAppService(repo, tokenRepo, permRepo)

	_, _, err := svc.Create(context.Background(), CreatePlatformAppRequest{Name: "A1", AccountID: 1, Type: "api"})
	require.NoError(t, err)

	apps, total, err := svc.ListByAccount(context.Background(), 1, 0, 10)
	require.NoError(t, err)
	assert.Equal(t, int64(1), total)
	assert.Len(t, apps, 1)
}

func TestPlatformAppService_Search(t *testing.T) {
	db := newPlatformAppServiceDB(t)
	repo := repository.NewPlatformAppRepo(db)
	tokenRepo := repository.NewAccessTokenRepo(db)
	permRepo := repository.NewPermissibleRepo(db)
	svc := NewPlatformAppService(repo, tokenRepo, permRepo)

	_, _, err := svc.Create(context.Background(), CreatePlatformAppRequest{Name: "Searchable", AccountID: 1, Type: "api"})
	require.NoError(t, err)

	apps, total, err := svc.Search(context.Background(), "Search", 0, 10)
	require.NoError(t, err)
	assert.Equal(t, int64(1), total)
	assert.Len(t, apps, 1)
}

func TestPlatformAppService_Update(t *testing.T) {
	db := newPlatformAppServiceDB(t)
	repo := repository.NewPlatformAppRepo(db)
	tokenRepo := repository.NewAccessTokenRepo(db)
	permRepo := repository.NewPermissibleRepo(db)
	svc := NewPlatformAppService(repo, tokenRepo, permRepo)

	app, _, err := svc.Create(context.Background(), CreatePlatformAppRequest{Name: "Orig", AccountID: 1, Type: "api"})
	require.NoError(t, err)

	updated, err := svc.Update(context.Background(), app.ID, UpdatePlatformAppRequest{
		Name:        "Updated",
		Description: "New desc",
		Type:        "api",
	})
	require.NoError(t, err)
	assert.Equal(t, "Updated", updated.Name)
}

func TestPlatformAppService_Delete(t *testing.T) {
	db := newPlatformAppServiceDB(t)
	repo := repository.NewPlatformAppRepo(db)
	tokenRepo := repository.NewAccessTokenRepo(db)
	permRepo := repository.NewPermissibleRepo(db)
	svc := NewPlatformAppService(repo, tokenRepo, permRepo)

	app, _, err := svc.Create(context.Background(), CreatePlatformAppRequest{Name: "Del", AccountID: 1, Type: "api"})
	require.NoError(t, err)

	require.NoError(t, svc.Delete(context.Background(), app.ID))
}

func TestPlatformAppService_RegenerateAccessToken(t *testing.T) {
	db := newPlatformAppServiceDB(t)
	repo := repository.NewPlatformAppRepo(db)
	tokenRepo := repository.NewAccessTokenRepo(db)
	permRepo := repository.NewPermissibleRepo(db)
	svc := NewPlatformAppService(repo, tokenRepo, permRepo)

	app, _, err := svc.Create(context.Background(), CreatePlatformAppRequest{Name: "App", AccountID: 1, Type: "api"})
	require.NoError(t, err)

	newToken, err := svc.RegenerateAccessToken(context.Background(), app.ID)
	require.NoError(t, err)
	assert.NotEmpty(t, newToken)
}

func TestPlatformAppService_ListAccessTokens(t *testing.T) {
	db := newPlatformAppServiceDB(t)
	repo := repository.NewPlatformAppRepo(db)
	tokenRepo := repository.NewAccessTokenRepo(db)
	permRepo := repository.NewPermissibleRepo(db)
	svc := NewPlatformAppService(repo, tokenRepo, permRepo)

	app, _, err := svc.Create(context.Background(), CreatePlatformAppRequest{Name: "App", AccountID: 1, Type: "api"})
	require.NoError(t, err)

	tokens, err := svc.ListAccessTokens(context.Background(), app.ID)
	require.NoError(t, err)
	assert.Len(t, tokens, 1)
}

func TestPlatformAppService_AddPermissible(t *testing.T) {
	db := newPlatformAppServiceDB(t)
	repo := repository.NewPlatformAppRepo(db)
	tokenRepo := repository.NewAccessTokenRepo(db)
	permRepo := repository.NewPermissibleRepo(db)
	svc := NewPlatformAppService(repo, tokenRepo, permRepo)

	app, _, err := svc.Create(context.Background(), CreatePlatformAppRequest{Name: "App", AccountID: 1, Type: "api"})
	require.NoError(t, err)

	perm, err := svc.AddPermissible(context.Background(), app.ID, "Account", 1)
	require.NoError(t, err)
	assert.NotZero(t, perm.ID)
}

func TestPlatformAppService_ListPermissibles(t *testing.T) {
	db := newPlatformAppServiceDB(t)
	repo := repository.NewPlatformAppRepo(db)
	tokenRepo := repository.NewAccessTokenRepo(db)
	permRepo := repository.NewPermissibleRepo(db)
	svc := NewPlatformAppService(repo, tokenRepo, permRepo)

	app, _, err := svc.Create(context.Background(), CreatePlatformAppRequest{Name: "App", AccountID: 1, Type: "api"})
	require.NoError(t, err)

	_, err = svc.AddPermissible(context.Background(), app.ID, "Account", 1)
	require.NoError(t, err)

	perms, err := svc.ListPermissibles(context.Background(), app.ID)
	require.NoError(t, err)
	assert.Len(t, perms, 1)
}

func TestPlatformAppService_RemovePermissible(t *testing.T) {
	db := newPlatformAppServiceDB(t)
	repo := repository.NewPlatformAppRepo(db)
	tokenRepo := repository.NewAccessTokenRepo(db)
	permRepo := repository.NewPermissibleRepo(db)
	svc := NewPlatformAppService(repo, tokenRepo, permRepo)

	app, _, err := svc.Create(context.Background(), CreatePlatformAppRequest{Name: "App", AccountID: 1, Type: "api"})
	require.NoError(t, err)

	_, err = svc.AddPermissible(context.Background(), app.ID, "Account", 1)
	require.NoError(t, err)

	require.NoError(t, svc.RemovePermissible(context.Background(), app.ID, "Account", 1))
}

// ============================================================
// UploadService tests (minimal - needs config)
// ============================================================

func TestUploadService_UploadDir(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	cfg := &config.Config{}
	repo := repository.NewDirectUploadRepo(db)
	svc := NewUploadService(repo, cfg)
	assert.NotNil(t, svc)
}