//go:build unit

package service

import (
	"context"
	"fmt"
	"testing"
	"time"

	"github.com/Wei-Shaw/sub2api/internal/pkg/pagination"
	"github.com/aws/aws-sdk-go-v2/service/s3"
	"github.com/stretchr/testify/require"
)

// ==================== Stub: SoraGenerationRepository ====================

var _ SoraGenerationRepository = (*stubGenRepo)(nil)

type stubGenRepo struct {
	gens       map[int64]*SoraGeneration
	nextID     int64
	createErr  error
	getErr     error
	updateErr  error
	deleteErr  error
	listErr    error
	countErr   error
	countValue int64
}

func newStubGenRepo() *stubGenRepo {
	return &stubGenRepo{gens: make(map[int64]*SoraGeneration), nextID: 1}
}

func (r *stubGenRepo) Create(_ context.Context, gen *SoraGeneration) error {
	if r.createErr != nil {
		return r.createErr
	}
	gen.ID = r.nextID
	gen.CreatedAt = time.Now()
	r.nextID++
	r.gens[gen.ID] = gen
	return nil
}

func (r *stubGenRepo) GetByID(_ context.Context, id int64) (*SoraGeneration, error) {
	if r.getErr != nil {
		return nil, r.getErr
	}
	if gen, ok := r.gens[id]; ok {
		return gen, nil
	}
	return nil, fmt.Errorf("not found")
}

func (r *stubGenRepo) Update(_ context.Context, gen *SoraGeneration) error {
	if r.updateErr != nil {
		return r.updateErr
	}
	r.gens[gen.ID] = gen
	return nil
}

func (r *stubGenRepo) Delete(_ context.Context, id int64) error {
	if r.deleteErr != nil {
		return r.deleteErr
	}
	delete(r.gens, id)
	return nil
}

func (r *stubGenRepo) List(_ context.Context, params SoraGenerationListParams) ([]*SoraGeneration, int64, error) {
	if r.listErr != nil {
		return nil, 0, r.listErr
	}
	var result []*SoraGeneration
	for _, gen := range r.gens {
		if gen.UserID != params.UserID {
			continue
		}
		if params.Status != "" && gen.Status != params.Status {
			continue
		}
		if params.StorageType != "" && gen.StorageType != params.StorageType {
			continue
		}
		if params.MediaType != "" && gen.MediaType != params.MediaType {
			continue
		}
		result = append(result, gen)
	}
	return result, int64(len(result)), nil
}

func (r *stubGenRepo) CountByUserAndStatus(_ context.Context, userID int64, statuses []string) (int64, error) {
	if r.countErr != nil {
		return 0, r.countErr
	}
	if r.countValue > 0 {
		return r.countValue, nil
	}
	var count int64
	statusSet := make(map[string]struct{})
	for _, s := range statuses {
		statusSet[s] = struct{}{}
	}
	for _, gen := range r.gens {
		if gen.UserID == userID {
			if _, ok := statusSet[gen.Status]; ok {
				count++
			}
		}
	}
	return count, nil
}

// ==================== Stub: UserRepository (用于 SoraQuotaService) ====================

var _ UserRepository = (*stubUserRepoForQuota)(nil)

type stubUserRepoForQuota struct {
	users     map[int64]*User
	updateErr error
}

func newStubUserRepoForQuota() *stubUserRepoForQuota {
	return &stubUserRepoForQuota{users: make(map[int64]*User)}
}

func (r *stubUserRepoForQuota) GetByID(_ context.Context, id int64) (*User, error) {
	if u, ok := r.users[id]; ok {
		return u, nil
	}
	return nil, fmt.Errorf("user not found")
}
func (r *stubUserRepoForQuota) Update(_ context.Context, user *User) error {
	if r.updateErr != nil {
		return r.updateErr
	}
	r.users[user.ID] = user
	return nil
}
func (r *stubUserRepoForQuota) Create(context.Context, *User) error { return nil }
func (r *stubUserRepoForQuota) GetByEmail(context.Context, string) (*User, error) {
	return nil, nil
}
func (r *stubUserRepoForQuota) GetFirstAdmin(context.Context) (*User, error) { return nil, nil }
func (r *stubUserRepoForQuota) Delete(context.Context, int64) error          { return nil }
func (r *stubUserRepoForQuota) List(context.Context, pagination.PaginationParams) ([]User, *pagination.PaginationResult, error) {
	return nil, nil, nil
}
func (r *stubUserRepoForQuota) ListWithFilters(context.Context, pagination.PaginationParams, UserListFilters) ([]User, *pagination.PaginationResult, error) {
	return nil, nil, nil
}
func (r *stubUserRepoForQuota) UpdateBalance(context.Context, int64, float64) error { return nil }
func (r *stubUserRepoForQuota) DeductBalance(context.Context, int64, float64) error { return nil }
func (r *stubUserRepoForQuota) UpdateConcurrency(context.Context, int64, int) error { return nil }
func (r *stubUserRepoForQuota) ExistsByEmail(context.Context, string) (bool, error) {
	return false, nil
}
func (r *stubUserRepoForQuota) RemoveGroupFromAllowedGroups(context.Context, int64) (int64, error) {
	return 0, nil
}
func (r *stubUserRepoForQuota) RemoveGroupFromUserAllowedGroups(context.Context, int64, int64) error {
	return nil
}
func (r *stubUserRepoForQuota) UpdateTotpSecret(context.Context, int64, *string) error { return nil }
func (r *stubUserRepoForQuota) EnableTotp(context.Context, int64) error                { return nil }
func (r *stubUserRepoForQuota) DisableTotp(context.Context, int64) error               { return nil }
func (r *stubUserRepoForQuota) AddGroupToAllowedGroups(context.Context, int64, int64) error {
	return nil
}

// ==================== 辅助函数：构造带 CDN 缓存的 SoraS3Storage ====================

// newS3StorageWithCDN 创建一个预缓存了 CDN 配置的 SoraS3Storage，
// 避免实际初始化 AWS 客户端。用于测试 GetAccessURL 的 CDN 路径。
func newS3StorageWithCDN(cdnURL string) *SoraS3Storage {
	storage := &SoraS3Storage{}
	storage.cfg = &SoraS3Settings{
		Enabled: true,
		Bucket:  "test-bucket",
		CDNURL:  cdnURL,
	}
	// 需要 non-nil client 使 getClient 命中缓存
	storage.client = s3.New(s3.Options{})
	return storage
}

// newS3StorageFailingDelete 创建一个 settingService=nil 的 SoraS3Storage，
// 使 DeleteObjects 返回错误（无法获取配置）。用于测试 Delete 方法 S3 清理失败但仍继续的场景。
func newS3StorageFailingDelete() *SoraS3Storage {
	return &SoraS3Storage{} // settingService 为 nil → getConfig 返回 error
}

// ==================== CreatePending ====================

func TestCreatePending_Success(t *testing.T) {
	repo := newStubGenRepo()
	svc := NewSoraGenerationService(repo, nil, nil)

	gen, err := svc.CreatePending(context.Background(), 1, nil, "sora2-landscape-10s", "一只猫跳舞", "video")
	require.NoError(t, err)
	require.Equal(t, int64(1), gen.ID)
	require.Equal(t, int64(1), gen.UserID)
	require.Equal(t, "sora2-landscape-10s", gen.Model)
	require.Equal(t, "一只猫跳舞", gen.Prompt)
	require.Equal(t, "video", gen.MediaType)
	require.Equal(t, SoraGenStatusPending, gen.Status)
	require.Equal(t, SoraStorageTypeNone, gen.StorageType)
	require.Nil(t, gen.APIKeyID)
}

func TestCreatePending_WithAPIKeyID(t *testing.T) {
	repo := newStubGenRepo()
	svc := NewSoraGenerationService(repo, nil, nil)

	apiKeyID := int64(42)
	gen, err := svc.CreatePending(context.Background(), 1, &apiKeyID, "gpt-image", "画一朵花", "image")
	require.NoError(t, err)
	require.NotNil(t, gen.APIKeyID)
	require.Equal(t, int64(42), *gen.APIKeyID)
}

func TestCreatePending_RepoError(t *testing.T) {
	repo := newStubGenRepo()
	repo.createErr = fmt.Errorf("db write error")
	svc := NewSoraGenerationService(repo, nil, nil)

	gen, err := svc.CreatePending(context.Background(), 1, nil, "sora2-landscape-10s", "test", "video")
	require.Error(t, err)
	require.Nil(t, gen)
	require.Contains(t, err.Error(), "create generation")
}

// ==================== MarkGenerating ====================

func TestMarkGenerating_Success(t *testing.T) {
	repo := newStubGenRepo()
	repo.gens[1] = &SoraGeneration{ID: 1, UserID: 1, Status: SoraGenStatusPending}
	svc := NewSoraGenerationService(repo, nil, nil)

	err := svc.MarkGenerating(context.Background(), 1, "upstream-task-123")
	require.NoError(t, err)
	require.Equal(t, SoraGenStatusGenerating, repo.gens[1].Status)
	require.Equal(t, "upstream-task-123", repo.gens[1].UpstreamTaskID)
}

func TestMarkGenerating_NotFound(t *testing.T) {
	repo := newStubGenRepo()
	svc := NewSoraGenerationService(repo, nil, nil)

	err := svc.MarkGenerating(context.Background(), 999, "")
	require.Error(t, err)
}

func TestMarkGenerating_UpdateError(t *testing.T) {
	repo := newStubGenRepo()
	repo.gens[1] = &SoraGeneration{ID: 1, UserID: 1, Status: SoraGenStatusPending}
	repo.updateErr = fmt.Errorf("update failed")
	svc := NewSoraGenerationService(repo, nil, nil)

	err := svc.MarkGenerating(context.Background(), 1, "")
	require.Error(t, err)
}

// ==================== MarkCompleted ====================

func TestMarkCompleted_Success(t *testing.T) {
	repo := newStubGenRepo()
	repo.gens[1] = &SoraGeneration{ID: 1, UserID: 1, Status: SoraGenStatusGenerating}
	svc := NewSoraGenerationService(repo, nil, nil)

	err := svc.MarkCompleted(context.Background(), 1,
		"https://cdn.example.com/video.mp4",
		[]string{"https://cdn.example.com/video.mp4"},
		SoraStorageTypeS3,
		[]string{"sora/1/2024/01/01/uuid.mp4"},
		1048576,
	)
	require.NoError(t, err)
	gen := repo.gens[1]
	require.Equal(t, SoraGenStatusCompleted, gen.Status)
	require.Equal(t, "https://cdn.example.com/video.mp4", gen.MediaURL)
	require.Equal(t, []string{"https://cdn.example.com/video.mp4"}, gen.MediaURLs)
	require.Equal(t, SoraStorageTypeS3, gen.StorageType)
	require.Equal(t, []string{"sora/1/2024/01/01/uuid.mp4"}, gen.S3ObjectKeys)
	require.Equal(t, int64(1048576), gen.FileSizeBytes)
	require.NotNil(t, gen.CompletedAt)
}

func TestMarkCompleted_NotFound(t *testing.T) {
	repo := newStubGenRepo()
	svc := NewSoraGenerationService(repo, nil, nil)

	err := svc.MarkCompleted(context.Background(), 999, "", nil, "", nil, 0)
	require.Error(t, err)
}

func TestMarkCompleted_UpdateError(t *testing.T) {
	repo := newStubGenRepo()
	repo.gens[1] = &SoraGeneration{ID: 1, UserID: 1, Status: SoraGenStatusGenerating}
	repo.updateErr = fmt.Errorf("update failed")
	svc := NewSoraGenerationService(repo, nil, nil)

	err := svc.MarkCompleted(context.Background(), 1, "url", nil, SoraStorageTypeUpstream, nil, 0)
	require.Error(t, err)
}

// ==================== MarkFailed ====================

func TestMarkFailed_Success(t *testing.T) {
	repo := newStubGenRepo()
	repo.gens[1] = &SoraGeneration{ID: 1, UserID: 1, Status: SoraGenStatusGenerating}
	svc := NewSoraGenerationService(repo, nil, nil)

	err := svc.MarkFailed(context.Background(), 1, "上游返回 500 错误")
	require.NoError(t, err)
	gen := repo.gens[1]
	require.Equal(t, SoraGenStatusFailed, gen.Status)
	require.Equal(t, "上游返回 500 错误", gen.ErrorMessage)
	require.NotNil(t, gen.CompletedAt)
}

func TestMarkFailed_NotFound(t *testing.T) {
	repo := newStubGenRepo()
	svc := NewSoraGenerationService(repo, nil, nil)

	err := svc.MarkFailed(context.Background(), 999, "error")
	require.Error(t, err)
}

func TestMarkFailed_UpdateError(t *testing.T) {
	repo := newStubGenRepo()
	repo.gens[1] = &SoraGeneration{ID: 1, UserID: 1, Status: SoraGenStatusGenerating}
	repo.updateErr = fmt.Errorf("update failed")
	svc := NewSoraGenerationService(repo, nil, nil)

	err := svc.MarkFailed(context.Background(), 1, "err")
	require.Error(t, err)
}

// ==================== MarkCancelled ====================

func TestMarkCancelled_Pending(t *testing.T) {
	repo := newStubGenRepo()
	repo.gens[1] = &SoraGeneration{ID: 1, UserID: 1, Status: SoraGenStatusPending}
	svc := NewSoraGenerationService(repo, nil, nil)

	err := svc.MarkCancelled(context.Background(), 1)
	require.NoError(t, err)
	require.Equal(t, SoraGenStatusCancelled, repo.gens[1].Status)
	require.NotNil(t, repo.gens[1].CompletedAt)
}

func TestMarkCancelled_Generating(t *testing.T) {
	repo := newStubGenRepo()
	repo.gens[1] = &SoraGeneration{ID: 1, UserID: 1, Status: SoraGenStatusGenerating}
	svc := NewSoraGenerationService(repo, nil, nil)

	err := svc.MarkCancelled(context.Background(), 1)
	require.NoError(t, err)
	require.Equal(t, SoraGenStatusCancelled, repo.gens[1].Status)
}

func TestMarkCancelled_Completed(t *testing.T) {
	repo := newStubGenRepo()
	repo.gens[1] = &SoraGeneration{ID: 1, UserID: 1, Status: SoraGenStatusCompleted}
	svc := NewSoraGenerationService(repo, nil, nil)

	err := svc.MarkCancelled(context.Background(), 1)
	require.Error(t, err)
	require.ErrorIs(t, err, ErrSoraGenerationNotActive)
}

func TestMarkCancelled_Failed(t *testing.T) {
	repo := newStubGenRepo()
	repo.gens[1] = &SoraGeneration{ID: 1, UserID: 1, Status: SoraGenStatusFailed}
	svc := NewSoraGenerationService(repo, nil, nil)

	err := svc.MarkCancelled(context.Background(), 1)
	require.Error(t, err)
}

func TestMarkCancelled_AlreadyCancelled(t *testing.T) {
	repo := newStubGenRepo()
	repo.gens[1] = &SoraGeneration{ID: 1, UserID: 1, Status: SoraGenStatusCancelled}
	svc := NewSoraGenerationService(repo, nil, nil)

	err := svc.MarkCancelled(context.Background(), 1)
	require.Error(t, err)
}

func TestMarkCancelled_NotFound(t *testing.T) {
	repo := newStubGenRepo()
	svc := NewSoraGenerationService(repo, nil, nil)

	err := svc.MarkCancelled(context.Background(), 999)
	require.Error(t, err)
}

func TestMarkCancelled_UpdateError(t *testing.T) {
	repo := newStubGenRepo()
	repo.gens[1] = &SoraGeneration{ID: 1, UserID: 1, Status: SoraGenStatusPending}
	repo.updateErr = fmt.Errorf("update failed")
	svc := NewSoraGenerationService(repo, nil, nil)

	err := svc.MarkCancelled(context.Background(), 1)
	require.Error(t, err)
}

// ==================== GetByID ====================

func TestGetByID_Success(t *testing.T) {
	repo := newStubGenRepo()
	repo.gens[1] = &SoraGeneration{ID: 1, UserID: 1, Status: SoraGenStatusCompleted, Model: "sora2-landscape-10s"}
	svc := NewSoraGenerationService(repo, nil, nil)

	gen, err := svc.GetByID(context.Background(), 1, 1)
	require.NoError(t, err)
	require.Equal(t, int64(1), gen.ID)
	require.Equal(t, "sora2-landscape-10s", gen.Model)
}

func TestGetByID_WrongUser(t *testing.T) {
	repo := newStubGenRepo()
	repo.gens[1] = &SoraGeneration{ID: 1, UserID: 2, Status: SoraGenStatusCompleted}
	svc := NewSoraGenerationService(repo, nil, nil)

	gen, err := svc.GetByID(context.Background(), 1, 1)
	require.Error(t, err)
	require.Nil(t, gen)
	require.Contains(t, err.Error(), "无权访问")
}

func TestGetByID_NotFound(t *testing.T) {
	repo := newStubGenRepo()
	svc := NewSoraGenerationService(repo, nil, nil)

	gen, err := svc.GetByID(context.Background(), 999, 1)
	require.Error(t, err)
	require.Nil(t, gen)
}

// ==================== List ====================

func TestList_Success(t *testing.T) {
	repo := newStubGenRepo()
	repo.gens[1] = &SoraGeneration{ID: 1, UserID: 1, Status: SoraGenStatusCompleted, MediaType: "video"}
	repo.gens[2] = &SoraGeneration{ID: 2, UserID: 1, Status: SoraGenStatusPending, MediaType: "image"}
	repo.gens[3] = &SoraGeneration{ID: 3, UserID: 2, Status: SoraGenStatusCompleted, MediaType: "video"}
	svc := NewSoraGenerationService(repo, nil, nil)

	gens, total, err := svc.List(context.Background(), SoraGenerationListParams{UserID: 1, Page: 1, PageSize: 20})
	require.NoError(t, err)
	require.Len(t, gens, 2) // 只有 userID=1 的
	require.Equal(t, int64(2), total)
}

func TestList_DefaultPagination(t *testing.T) {
	repo := newStubGenRepo()
	svc := NewSoraGenerationService(repo, nil, nil)

	// page=0, pageSize=0 → 应修正为 page=1, pageSize=20
	_, _, err := svc.List(context.Background(), SoraGenerationListParams{UserID: 1})
	require.NoError(t, err)
}

func TestList_MaxPageSize(t *testing.T) {
	repo := newStubGenRepo()
	svc := NewSoraGenerationService(repo, nil, nil)

	// pageSize > 100 → 应限制为 100
	_, _, err := svc.List(context.Background(), SoraGenerationListParams{UserID: 1, Page: 1, PageSize: 200})
	require.NoError(t, err)
}

func TestList_Error(t *testing.T) {
	repo := newStubGenRepo()
	repo.listErr = fmt.Errorf("db error")
	svc := NewSoraGenerationService(repo, nil, nil)

	_, _, err := svc.List(context.Background(), SoraGenerationListParams{UserID: 1})
	require.Error(t, err)
}

// ==================== Delete ====================

func TestDelete_Success(t *testing.T) {
	repo := newStubGenRepo()
	repo.gens[1] = &SoraGeneration{ID: 1, UserID: 1, Status: SoraGenStatusCompleted, StorageType: SoraStorageTypeUpstream}
	svc := NewSoraGenerationService(repo, nil, nil)

	err := svc.Delete(context.Background(), 1, 1)
	require.NoError(t, err)
	_, exists := repo.gens[1]
	require.False(t, exists)
}

func TestDelete_WrongUser(t *testing.T) {
	repo := newStubGenRepo()
	repo.gens[1] = &SoraGeneration{ID: 1, UserID: 2, Status: SoraGenStatusCompleted}
	svc := NewSoraGenerationService(repo, nil, nil)

	err := svc.Delete(context.Background(), 1, 1)
	require.Error(t, err)
	require.Contains(t, err.Error(), "无权删除")
}

func TestDelete_NotFound(t *testing.T) {
	repo := newStubGenRepo()
	svc := NewSoraGenerationService(repo, nil, nil)

	err := svc.Delete(context.Background(), 999, 1)
	require.Error(t, err)
}

func TestDelete_S3Cleanup_NilS3(t *testing.T) {
	repo := newStubGenRepo()
	repo.gens[1] = &SoraGeneration{ID: 1, UserID: 1, StorageType: SoraStorageTypeS3, S3ObjectKeys: []string{"key1"}}
	svc := NewSoraGenerationService(repo, nil, nil)

	err := svc.Delete(context.Background(), 1, 1)
	require.NoError(t, err) // s3Storage 为 nil，跳过清理
}

func TestDelete_QuotaRelease_NilQuota(t *testing.T) {
	repo := newStubGenRepo()
	repo.gens[1] = &SoraGeneration{ID: 1, UserID: 1, StorageType: SoraStorageTypeS3, FileSizeBytes: 1024}
	svc := NewSoraGenerationService(repo, nil, nil)

	err := svc.Delete(context.Background(), 1, 1)
	require.NoError(t, err) // quotaService 为 nil，跳过释放
}

func TestDelete_NonS3NoCleanup(t *testing.T) {
	repo := newStubGenRepo()
	repo.gens[1] = &SoraGeneration{ID: 1, UserID: 1, StorageType: SoraStorageTypeLocal, FileSizeBytes: 1024}
	svc := NewSoraGenerationService(repo, nil, nil)

	err := svc.Delete(context.Background(), 1, 1)
	require.NoError(t, err)
}

func TestDelete_DeleteRepoError(t *testing.T) {
	repo := newStubGenRepo()
	repo.gens[1] = &SoraGeneration{ID: 1, UserID: 1, StorageType: SoraStorageTypeUpstream}
	repo.deleteErr = fmt.Errorf("delete failed")
	svc := NewSoraGenerationService(repo, nil, nil)

	err := svc.Delete(context.Background(), 1, 1)
	require.Error(t, err)
}

// ==================== CountActiveByUser ====================

func TestCountActiveByUser_Success(t *testing.T) {
	repo := newStubGenRepo()
	repo.gens[1] = &SoraGeneration{ID: 1, UserID: 1, Status: SoraGenStatusPending}
	repo.gens[2] = &SoraGeneration{ID: 2, UserID: 1, Status: SoraGenStatusGenerating}
	repo.gens[3] = &SoraGeneration{ID: 3, UserID: 1, Status: SoraGenStatusCompleted} // 不算
	svc := NewSoraGenerationService(repo, nil, nil)

	count, err := svc.CountActiveByUser(context.Background(), 1)
	require.NoError(t, err)
	require.Equal(t, int64(2), count)
}

func TestCountActiveByUser_NoActive(t *testing.T) {
	repo := newStubGenRepo()
	repo.gens[1] = &SoraGeneration{ID: 1, UserID: 1, Status: SoraGenStatusCompleted}
	svc := NewSoraGenerationService(repo, nil, nil)

	count, err := svc.CountActiveByUser(context.Background(), 1)
	require.NoError(t, err)
	require.Equal(t, int64(0), count)
}

func TestCountActiveByUser_Error(t *testing.T) {
	repo := newStubGenRepo()
	repo.countErr = fmt.Errorf("db error")
	svc := NewSoraGenerationService(repo, nil, nil)

	_, err := svc.CountActiveByUser(context.Background(), 1)
	require.Error(t, err)
}

// ==================== ResolveMediaURLs ====================

func TestResolveMediaURLs_NilGen(t *testing.T) {
	svc := NewSoraGenerationService(newStubGenRepo(), nil, nil)
	require.NoError(t, svc.ResolveMediaURLs(context.Background(), nil))
}

func TestResolveMediaURLs_NonS3(t *testing.T) {
	svc := NewSoraGenerationService(newStubGenRepo(), nil, nil)
	gen := &SoraGeneration{StorageType: SoraStorageTypeUpstream, MediaURL: "https://original.com/v.mp4"}
	require.NoError(t, svc.ResolveMediaURLs(context.Background(), gen))
	require.Equal(t, "https://original.com/v.mp4", gen.MediaURL) // 不变
}

func TestResolveMediaURLs_S3NilStorage(t *testing.T) {
	svc := NewSoraGenerationService(newStubGenRepo(), nil, nil)
	gen := &SoraGeneration{StorageType: SoraStorageTypeS3, S3ObjectKeys: []string{"key1"}}
	require.NoError(t, svc.ResolveMediaURLs(context.Background(), gen))
}

func TestResolveMediaURLs_Local(t *testing.T) {
	svc := NewSoraGenerationService(newStubGenRepo(), nil, nil)
	gen := &SoraGeneration{StorageType: SoraStorageTypeLocal, MediaURL: "/video/2024/01/01/file.mp4"}
	require.NoError(t, svc.ResolveMediaURLs(context.Background(), gen))
	require.Equal(t, "/video/2024/01/01/file.mp4", gen.MediaURL) // 不变
}

// ==================== 状态流转完整测试 ====================

func TestStatusTransition_PendingToCompletedFlow(t *testing.T) {
	repo := newStubGenRepo()
	svc := NewSoraGenerationService(repo, nil, nil)

	// 1. 创建 pending
	gen, err := svc.CreatePending(context.Background(), 1, nil, "sora2-landscape-10s", "test", "video")
	require.NoError(t, err)
	require.Equal(t, SoraGenStatusPending, gen.Status)

	// 2. 标记 generating
	err = svc.MarkGenerating(context.Background(), gen.ID, "task-123")
	require.NoError(t, err)
	require.Equal(t, SoraGenStatusGenerating, repo.gens[gen.ID].Status)

	// 3. 标记 completed
	err = svc.MarkCompleted(context.Background(), gen.ID, "https://s3.com/video.mp4", nil, SoraStorageTypeS3, []string{"key"}, 1024)
	require.NoError(t, err)
	require.Equal(t, SoraGenStatusCompleted, repo.gens[gen.ID].Status)
}

func TestStatusTransition_PendingToFailedFlow(t *testing.T) {
	repo := newStubGenRepo()
	svc := NewSoraGenerationService(repo, nil, nil)

	gen, _ := svc.CreatePending(context.Background(), 1, nil, "sora2-landscape-10s", "test", "video")
	_ = svc.MarkGenerating(context.Background(), gen.ID, "")

	err := svc.MarkFailed(context.Background(), gen.ID, "上游超时")
	require.NoError(t, err)
	require.Equal(t, SoraGenStatusFailed, repo.gens[gen.ID].Status)
	require.Equal(t, "上游超时", repo.gens[gen.ID].ErrorMessage)
}

func TestStatusTransition_PendingToCancelledFlow(t *testing.T) {
	repo := newStubGenRepo()
	svc := NewSoraGenerationService(repo, nil, nil)

	gen, _ := svc.CreatePending(context.Background(), 1, nil, "sora2-landscape-10s", "test", "video")
	err := svc.MarkCancelled(context.Background(), gen.ID)
	require.NoError(t, err)
	require.Equal(t, SoraGenStatusCancelled, repo.gens[gen.ID].Status)
}

func TestStatusTransition_GeneratingToCancelledFlow(t *testing.T) {
	repo := newStubGenRepo()
	svc := NewSoraGenerationService(repo, nil, nil)

	gen, _ := svc.CreatePending(context.Background(), 1, nil, "sora2-landscape-10s", "test", "video")
	_ = svc.MarkGenerating(context.Background(), gen.ID, "")
	err := svc.MarkCancelled(context.Background(), gen.ID)
	require.NoError(t, err)
	require.Equal(t, SoraGenStatusCancelled, repo.gens[gen.ID].Status)
}

// ==================== 权限隔离测试 ====================

func TestUserIsolation_CannotAccessOthersRecord(t *testing.T) {
	repo := newStubGenRepo()
	svc := NewSoraGenerationService(repo, nil, nil)

	gen, _ := svc.CreatePending(context.Background(), 1, nil, "sora2-landscape-10s", "test", "video")

	// 用户 2 尝试访问用户 1 的记录
	_, err := svc.GetByID(context.Background(), gen.ID, 2)
	require.Error(t, err)
	require.Contains(t, err.Error(), "无权访问")
}

func TestUserIsolation_CannotDeleteOthersRecord(t *testing.T) {
	repo := newStubGenRepo()
	svc := NewSoraGenerationService(repo, nil, nil)

	gen, _ := svc.CreatePending(context.Background(), 1, nil, "sora2-landscape-10s", "test", "video")

	err := svc.Delete(context.Background(), gen.ID, 2)
	require.Error(t, err)
	require.Contains(t, err.Error(), "无权删除")
}

// ==================== Delete: S3 清理 + 配额释放路径 ====================

func TestDelete_S3Cleanup_WithS3Storage(t *testing.T) {
	// S3 存储存在但 deleteObjects 会失败（settingService=nil），
	// 验证 Delete 仍然成功（S3 错误只是记录日志）
	repo := newStubGenRepo()
	repo.gens[1] = &SoraGeneration{
		ID: 1, UserID: 1,
		StorageType:  SoraStorageTypeS3,
		S3ObjectKeys: []string{"sora/1/2024/01/01/abc.mp4"},
	}
	s3Storage := newS3StorageFailingDelete()
	svc := NewSoraGenerationService(repo, s3Storage, nil)

	err := svc.Delete(context.Background(), 1, 1)
	require.NoError(t, err) // S3 清理失败不影响删除
	_, exists := repo.gens[1]
	require.False(t, exists)
}

func TestDelete_QuotaRelease_WithQuotaService(t *testing.T) {
	// 有配额服务时，删除 S3 类型记录会释放配额
	repo := newStubGenRepo()
	repo.gens[1] = &SoraGeneration{
		ID: 1, UserID: 1,
		StorageType:   SoraStorageTypeS3,
		FileSizeBytes: 1048576, // 1MB
	}

	userRepo := newStubUserRepoForQuota()
	userRepo.users[1] = &User{ID: 1, SoraStorageUsedBytes: 2097152} // 2MB
	quotaService := NewSoraQuotaService(userRepo, nil, nil)

	svc := NewSoraGenerationService(repo, nil, quotaService)
	err := svc.Delete(context.Background(), 1, 1)
	require.NoError(t, err)
	// 配额应被释放: 2MB - 1MB = 1MB
	require.Equal(t, int64(1048576), userRepo.users[1].SoraStorageUsedBytes)
}

func TestDelete_S3Cleanup_And_QuotaRelease(t *testing.T) {
	// S3 清理 + 配额释放同时触发
	repo := newStubGenRepo()
	repo.gens[1] = &SoraGeneration{
		ID: 1, UserID: 1,
		StorageType:   SoraStorageTypeS3,
		S3ObjectKeys:  []string{"key1"},
		FileSizeBytes: 512,
	}

	userRepo := newStubUserRepoForQuota()
	userRepo.users[1] = &User{ID: 1, SoraStorageUsedBytes: 1024}
	quotaService := NewSoraQuotaService(userRepo, nil, nil)
	s3Storage := newS3StorageFailingDelete()

	svc := NewSoraGenerationService(repo, s3Storage, quotaService)
	err := svc.Delete(context.Background(), 1, 1)
	require.NoError(t, err)
	_, exists := repo.gens[1]
	require.False(t, exists)
	require.Equal(t, int64(512), userRepo.users[1].SoraStorageUsedBytes)
}

func TestDelete_QuotaRelease_LocalStorage(t *testing.T) {
	// 本地存储同样需要释放配额
	repo := newStubGenRepo()
	repo.gens[1] = &SoraGeneration{
		ID: 1, UserID: 1,
		StorageType:   SoraStorageTypeLocal,
		FileSizeBytes: 1024,
	}

	userRepo := newStubUserRepoForQuota()
	userRepo.users[1] = &User{ID: 1, SoraStorageUsedBytes: 2048}
	quotaService := NewSoraQuotaService(userRepo, nil, nil)

	svc := NewSoraGenerationService(repo, nil, quotaService)
	err := svc.Delete(context.Background(), 1, 1)
	require.NoError(t, err)
	require.Equal(t, int64(1024), userRepo.users[1].SoraStorageUsedBytes)
}

func TestDelete_QuotaRelease_ZeroFileSize(t *testing.T) {
	// FileSizeBytes=0 跳过配额释放
	repo := newStubGenRepo()
	repo.gens[1] = &SoraGeneration{
		ID: 1, UserID: 1,
		StorageType:   SoraStorageTypeS3,
		FileSizeBytes: 0,
	}

	userRepo := newStubUserRepoForQuota()
	userRepo.users[1] = &User{ID: 1, SoraStorageUsedBytes: 1024}
	quotaService := NewSoraQuotaService(userRepo, nil, nil)

	svc := NewSoraGenerationService(repo, nil, quotaService)
	err := svc.Delete(context.Background(), 1, 1)
	require.NoError(t, err)
	require.Equal(t, int64(1024), userRepo.users[1].SoraStorageUsedBytes)
}

// ==================== ResolveMediaURLs: S3 + CDN 路径 ====================

func TestResolveMediaURLs_S3_CDN_SingleKey(t *testing.T) {
	s3Storage := newS3StorageWithCDN("https://cdn.example.com")
	svc := NewSoraGenerationService(newStubGenRepo(), s3Storage, nil)

	gen := &SoraGeneration{
		StorageType:  SoraStorageTypeS3,
		S3ObjectKeys: []string{"sora/1/2024/01/01/video.mp4"},
		MediaURL:     "original",
	}
	err := svc.ResolveMediaURLs(context.Background(), gen)
	require.NoError(t, err)
	require.Equal(t, "https://cdn.example.com/sora/1/2024/01/01/video.mp4", gen.MediaURL)
}

func TestResolveMediaURLs_S3_CDN_MultipleKeys(t *testing.T) {
	s3Storage := newS3StorageWithCDN("https://cdn.example.com/")
	svc := NewSoraGenerationService(newStubGenRepo(), s3Storage, nil)

	gen := &SoraGeneration{
		StorageType: SoraStorageTypeS3,
		S3ObjectKeys: []string{
			"sora/1/2024/01/01/img1.png",
			"sora/1/2024/01/01/img2.png",
			"sora/1/2024/01/01/img3.png",
		},
		MediaURL: "original",
	}
	err := svc.ResolveMediaURLs(context.Background(), gen)
	require.NoError(t, err)
	// 主 URL 更新为第一个 key 的 CDN URL
	require.Equal(t, "https://cdn.example.com/sora/1/2024/01/01/img1.png", gen.MediaURL)
	// 多图 URLs 全部更新
	require.Len(t, gen.MediaURLs, 3)
	require.Equal(t, "https://cdn.example.com/sora/1/2024/01/01/img1.png", gen.MediaURLs[0])
	require.Equal(t, "https://cdn.example.com/sora/1/2024/01/01/img2.png", gen.MediaURLs[1])
	require.Equal(t, "https://cdn.example.com/sora/1/2024/01/01/img3.png", gen.MediaURLs[2])
}

func TestResolveMediaURLs_S3_EmptyKeys(t *testing.T) {
	s3Storage := newS3StorageWithCDN("https://cdn.example.com")
	svc := NewSoraGenerationService(newStubGenRepo(), s3Storage, nil)

	gen := &SoraGeneration{
		StorageType:  SoraStorageTypeS3,
		S3ObjectKeys: []string{},
		MediaURL:     "original",
	}
	err := svc.ResolveMediaURLs(context.Background(), gen)
	require.NoError(t, err)
	require.Equal(t, "original", gen.MediaURL) // 不变
}

func TestResolveMediaURLs_S3_GetAccessURL_Error(t *testing.T) {
	// 使用无 settingService 的 S3 Storage，getClient 会失败
	s3Storage := newS3StorageFailingDelete() // 同样 GetAccessURL 也会失败
	svc := NewSoraGenerationService(newStubGenRepo(), s3Storage, nil)

	gen := &SoraGeneration{
		StorageType:  SoraStorageTypeS3,
		S3ObjectKeys: []string{"sora/1/2024/01/01/video.mp4"},
		MediaURL:     "original",
	}
	err := svc.ResolveMediaURLs(context.Background(), gen)
	require.Error(t, err) // GetAccessURL 失败应传播错误
}

func TestResolveMediaURLs_S3_MultiKey_ErrorOnSecond(t *testing.T) {
	// 只有一个 key 时走主 URL 路径成功，但多 key 路径的错误也需覆盖
	s3Storage := newS3StorageFailingDelete()
	svc := NewSoraGenerationService(newStubGenRepo(), s3Storage, nil)

	gen := &SoraGeneration{
		StorageType: SoraStorageTypeS3,
		S3ObjectKeys: []string{
			"sora/1/2024/01/01/img1.png",
			"sora/1/2024/01/01/img2.png",
		},
		MediaURL: "original",
	}
	err := svc.ResolveMediaURLs(context.Background(), gen)
	require.Error(t, err) // 第一个 key 的 GetAccessURL 就会失败
}
