package service

import (
	"bytes"
	"context"
	"fmt"
	"io"
	"mime/multipart"
	"net/textproto"
	"strconv"
	"strings"
	"testing"
	"time"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"github.com/stretchr/testify/suite"
	"go.uber.org/mock/gomock"

	"tss-rocks-be/ent"
	"tss-rocks-be/ent/categorycontent"
	"tss-rocks-be/ent/dailycontent"
	"tss-rocks-be/internal/storage"
	"tss-rocks-be/internal/storage/mock"
	"tss-rocks-be/internal/testutil"
)

type ServiceImplTestSuite struct {
	suite.Suite
	ctx     context.Context
	client  *ent.Client
	storage *mock.MockStorage
	ctrl    *gomock.Controller
	svc     Service
}

func (s *ServiceImplTestSuite) SetupTest() {
	s.ctx = context.Background()
	s.client = testutil.NewTestClient()
	require.NotNil(s.T(), s.client)

	s.ctrl = gomock.NewController(s.T())
	s.storage = mock.NewMockStorage(s.ctrl)
	s.svc = NewService(s.client, s.storage)

	// 清理数据库
	_, err := s.client.Category.Delete().Exec(s.ctx)
	require.NoError(s.T(), err)
	_, err = s.client.CategoryContent.Delete().Exec(s.ctx)
	require.NoError(s.T(), err)
	_, err = s.client.User.Delete().Exec(s.ctx)
	require.NoError(s.T(), err)
	_, err = s.client.Role.Delete().Exec(s.ctx)
	require.NoError(s.T(), err)
	_, err = s.client.Permission.Delete().Exec(s.ctx)
	require.NoError(s.T(), err)
	_, err = s.client.Daily.Delete().Exec(s.ctx)
	require.NoError(s.T(), err)
	_, err = s.client.DailyContent.Delete().Exec(s.ctx)
	require.NoError(s.T(), err)

	// 初始化 RBAC 系统
	err = s.svc.InitializeRBAC(s.ctx)
	require.NoError(s.T(), err)

	// Set default openFile function
	openFile = func(fh *multipart.FileHeader) (multipart.File, error) {
		return fh.Open()
	}
}

func (s *ServiceImplTestSuite) TearDownTest() {
	s.ctrl.Finish()
	s.client.Close()
}

func TestServiceImplSuite(t *testing.T) {
	suite.Run(t, new(ServiceImplTestSuite))
}

// mockMultipartFile implements multipart.File interface
type mockMultipartFile struct {
	*bytes.Reader
}

func (m *mockMultipartFile) Close() error {
	return nil
}

func (m *mockMultipartFile) ReadAt(p []byte, off int64) (n int, err error) {
	return m.Reader.ReadAt(p, off)
}

func (m *mockMultipartFile) Seek(offset int64, whence int) (int64, error) {
	return m.Reader.Seek(offset, whence)
}

func newMockMultipartFile(data []byte) *mockMultipartFile {
	return &mockMultipartFile{
		Reader: bytes.NewReader(data),
	}
}

func (s *ServiceImplTestSuite) TestCreateUser() {
	testCases := []struct {
		name      string
		email     string
		password  string
		role      string
		wantError bool
	}{
		{
			name:      "Valid user creation",
			email:     "test@example.com",
			password:  "password123",
			role:      "admin",
			wantError: false,
		},
		{
			name:      "Empty email",
			email:     "",
			password:  "password123",
			role:      "user",
			wantError: true,
		},
		{
			name:      "Empty password",
			email:     "test@example.com",
			password:  "",
			role:      "user",
			wantError: true,
		},
		{
			name:      "Invalid role",
			email:     "test@example.com",
			password:  "password123",
			role:      "invalid_role",
			wantError: true,
		},
	}

	for _, tc := range testCases {
		s.Run(tc.name, func() {
			user, err := s.svc.CreateUser(s.ctx, tc.email, tc.password, tc.role)
			if tc.wantError {
				assert.Error(s.T(), err)
				assert.Nil(s.T(), user)
			} else {
				assert.NoError(s.T(), err)
				assert.NotNil(s.T(), user)
				assert.Equal(s.T(), tc.email, user.Email)
			}
		})
	}
}

func (s *ServiceImplTestSuite) TestGetUserByEmail() {
	// Create a test user first
	email := "test@example.com"
	password := "password123"
	role := "user"

	user, err := s.svc.CreateUser(s.ctx, email, password, role)
	require.NoError(s.T(), err)
	require.NotNil(s.T(), user)

	s.Run("Existing user", func() {
		found, err := s.svc.GetUserByEmail(s.ctx, email)
		assert.NoError(s.T(), err)
		assert.NotNil(s.T(), found)
		assert.Equal(s.T(), email, found.Email)
	})

	s.Run("Non-existing user", func() {
		found, err := s.svc.GetUserByEmail(s.ctx, "nonexistent@example.com")
		assert.Error(s.T(), err)
		assert.Nil(s.T(), found)
	})
}

func (s *ServiceImplTestSuite) TestValidatePassword() {
	// Create a test user first
	email := "test@example.com"
	password := "password123"
	role := "user"

	user, err := s.svc.CreateUser(s.ctx, email, password, role)
	require.NoError(s.T(), err)
	require.NotNil(s.T(), user)

	s.Run("Valid password", func() {
		valid := s.svc.ValidatePassword(s.ctx, user, password)
		assert.True(s.T(), valid)
	})

	s.Run("Invalid password", func() {
		valid := s.svc.ValidatePassword(s.ctx, user, "wrongpassword")
		assert.False(s.T(), valid)
	})
}

func (s *ServiceImplTestSuite) TestRBAC() {
	s.Run("AssignRole", func() {
		user, err := s.svc.CreateUser(s.ctx, "test@example.com", "password", "admin")
		require.NoError(s.T(), err)

		err = s.svc.AssignRole(s.ctx, user.ID, "user")
		assert.NoError(s.T(), err)
	})

	s.Run("RemoveRole", func() {
		user, err := s.svc.CreateUser(s.ctx, "test2@example.com", "password", "admin")
		require.NoError(s.T(), err)

		err = s.svc.RemoveRole(s.ctx, user.ID, "admin")
		assert.NoError(s.T(), err)
	})

	s.Run("HasPermission", func() {
		s.Run("Admin can create users", func() {
			user, err := s.svc.CreateUser(s.ctx, "admin@example.com", "password", "admin")
			require.NoError(s.T(), err)

			hasPermission, err := s.svc.HasPermission(s.ctx, user.ID, "users:create")
			require.NoError(s.T(), err)
			assert.True(s.T(), hasPermission)
		})

		s.Run("Editor cannot create users", func() {
			user, err := s.svc.CreateUser(s.ctx, "editor@example.com", "password", "editor")
			require.NoError(s.T(), err)

			hasPermission, err := s.svc.HasPermission(s.ctx, user.ID, "users:create")
			require.NoError(s.T(), err)
			assert.False(s.T(), hasPermission)
		})

		s.Run("User cannot create users", func() {
			user, err := s.svc.CreateUser(s.ctx, "user@example.com", "password", "user")
			require.NoError(s.T(), err)

			hasPermission, err := s.svc.HasPermission(s.ctx, user.ID, "users:create")
			require.NoError(s.T(), err)
			assert.False(s.T(), hasPermission)
		})

		s.Run("Editor can create posts", func() {
			user, err := s.svc.CreateUser(s.ctx, "editor2@example.com", "password", "editor")
			require.NoError(s.T(), err)

			hasPermission, err := s.svc.HasPermission(s.ctx, user.ID, "posts:create")
			require.NoError(s.T(), err)
			assert.True(s.T(), hasPermission)
		})

		s.Run("User can read posts", func() {
			user, err := s.svc.CreateUser(s.ctx, "user2@example.com", "password", "user")
			require.NoError(s.T(), err)

			hasPermission, err := s.svc.HasPermission(s.ctx, user.ID, "posts:read")
			require.NoError(s.T(), err)
			assert.True(s.T(), hasPermission)
		})

		s.Run("User cannot create posts", func() {
			user, err := s.svc.CreateUser(s.ctx, "user3@example.com", "password", "user")
			require.NoError(s.T(), err)

			hasPermission, err := s.svc.HasPermission(s.ctx, user.ID, "posts:create")
			require.NoError(s.T(), err)
			assert.False(s.T(), hasPermission)
		})

		s.Run("Invalid permission format", func() {
			user, err := s.svc.CreateUser(s.ctx, "user4@example.com", "password", "user")
			require.NoError(s.T(), err)

			_, err = s.svc.HasPermission(s.ctx, user.ID, "invalid_permission")
			require.Error(s.T(), err)
			assert.Contains(s.T(), err.Error(), "invalid permission format")
		})
	})
}

func (s *ServiceImplTestSuite) TestCategory() {
	// Create a test user with admin role for testing
	adminUser, err := s.svc.CreateUser(s.ctx, "admin@example.com", "password123", "admin")
	require.NoError(s.T(), err)
	require.NotNil(s.T(), adminUser)

	s.Run("CreateCategory", func() {
		// Test category creation
		category, err := s.svc.CreateCategory(s.ctx)
		assert.NoError(s.T(), err)
		assert.NotNil(s.T(), category)
		assert.NotZero(s.T(), category.ID)
	})

	s.Run("AddCategoryContent", func() {
		// Create a category first
		category, err := s.svc.CreateCategory(s.ctx)
		require.NoError(s.T(), err)
		require.NotNil(s.T(), category)

		testCases := []struct {
			name      string
			langCode  string
			catName   string
			desc      string
			slug      string
			wantError bool
		}{
			{
				name:      "Valid category content",
				langCode:  "en",
				catName:   "Test Category",
				desc:      "Test Description",
				slug:      "test-category",
				wantError: false,
			},
			{
				name:      "Empty language code",
				langCode:  "",
				catName:   "Test Category",
				desc:      "Test Description",
				slug:      "test-category-2",
				wantError: true,
			},
			{
				name:      "Empty name",
				langCode:  "en",
				catName:   "",
				desc:      "Test Description",
				slug:      "test-category-3",
				wantError: true,
			},
			{
				name:      "Empty slug",
				langCode:  "en",
				catName:   "Test Category",
				desc:      "Test Description",
				slug:      "",
				wantError: true,
			},
		}

		for _, tc := range testCases {
			s.Run(tc.name, func() {
				content, err := s.svc.AddCategoryContent(s.ctx, category.ID, tc.langCode, tc.catName, tc.desc, tc.slug)
				if tc.wantError {
					assert.Error(s.T(), err)
					assert.Nil(s.T(), content)
				} else {
					assert.NoError(s.T(), err)
					assert.NotNil(s.T(), content)
					assert.Equal(s.T(), categorycontent.LanguageCode(tc.langCode), content.LanguageCode)
					assert.Equal(s.T(), tc.catName, content.Name)
					assert.Equal(s.T(), tc.desc, content.Description)
					assert.Equal(s.T(), tc.slug, content.Slug)
				}
			})
		}
	})

	s.Run("GetCategoryBySlug", func() {
		// Create a category with content first
		category, err := s.svc.CreateCategory(s.ctx)
		require.NoError(s.T(), err)
		require.NotNil(s.T(), category)

		content, err := s.svc.AddCategoryContent(s.ctx, category.ID, "en", "Test Category", "Test Description", "test-category-get")
		require.NoError(s.T(), err)
		require.NotNil(s.T(), content)

		s.Run("Existing category", func() {
			found, err := s.svc.GetCategoryBySlug(s.ctx, "en", "test-category-get")
			assert.NoError(s.T(), err)
			assert.NotNil(s.T(), found)
			assert.Equal(s.T(), category.ID, found.ID)

			// Check if content is loaded
			require.NotEmpty(s.T(), found.Edges.Contents)
			assert.Equal(s.T(), "Test Category", found.Edges.Contents[0].Name)
		})

		s.Run("Non-existing category", func() {
			found, err := s.svc.GetCategoryBySlug(s.ctx, "en", "non-existent")
			assert.Error(s.T(), err)
			assert.Nil(s.T(), found)
		})

		s.Run("Wrong language code", func() {
			found, err := s.svc.GetCategoryBySlug(s.ctx, "fr", "test-category-get")
			assert.Error(s.T(), err)
			assert.Nil(s.T(), found)
		})
	})

	s.Run("ListCategories", func() {
		s.Run("List English categories", func() {
			// 创建多个分类，但只有 3 个有英文内容
			var createdCategories []*ent.Category
			for i := 0; i < 5; i++ {
				category, err := s.svc.CreateCategory(s.ctx)
				require.NoError(s.T(), err)
				require.NotNil(s.T(), category)
				createdCategories = append(createdCategories, category)

				// 只给前 3 个分类添加英文内容
				if i < 3 {
					_, err = s.svc.AddCategoryContent(s.ctx, category.ID, "en",
						fmt.Sprintf("Category %d", i),
						fmt.Sprintf("Description %d", i),
						fmt.Sprintf("category-list-%d", i))
					require.NoError(s.T(), err)
				}
			}

			categories, err := s.svc.ListCategories(s.ctx, "en")
			assert.NoError(s.T(), err)
			assert.NotNil(s.T(), categories)
			assert.Len(s.T(), categories, 3)

			// 检查所有返回的分类都有英文内容
			for _, cat := range categories {
				assert.NotEmpty(s.T(), cat.Edges.Contents)
				for _, content := range cat.Edges.Contents {
					assert.Equal(s.T(), categorycontent.LanguageCodeEN, content.LanguageCode)
				}
			}
		})

		s.Run("List Chinese categories", func() {
			// 创建多个分类，但只有 2 个有中文内容
			for i := 0; i < 4; i++ {
				category, err := s.svc.CreateCategory(s.ctx)
				require.NoError(s.T(), err)
				require.NotNil(s.T(), category)

				// 只给前 2 个分类添加中文内容
				if i < 2 {
					_, err = s.svc.AddCategoryContent(s.ctx, category.ID, "zh-Hans",
						fmt.Sprintf("分类 %d", i),
						fmt.Sprintf("描述 %d", i),
						fmt.Sprintf("category-list-%d", i))
					require.NoError(s.T(), err)
				}
			}

			categories, err := s.svc.ListCategories(s.ctx, "zh-Hans")
			assert.NoError(s.T(), err)
			assert.NotNil(s.T(), categories)
			assert.Len(s.T(), categories, 2)

			// 检查所有返回的分类都有中文内容
			for _, cat := range categories {
				assert.NotEmpty(s.T(), cat.Edges.Contents)
				for _, content := range cat.Edges.Contents {
					assert.Equal(s.T(), categorycontent.LanguageCodeZH_HANS, content.LanguageCode)
				}
			}
		})

		s.Run("List non-existing language", func() {
			categories, err := s.svc.ListCategories(s.ctx, "fr")
			assert.NoError(s.T(), err)
			assert.Empty(s.T(), categories)
		})
	})
}

func (s *ServiceImplTestSuite) TestGetCategories() {
	ctx := context.Background()

	// 测试不支持的语言代码
	categories, err := s.svc.GetCategories(ctx, "invalid")
	s.Require().NoError(err)
	s.Empty(categories)

	// 创建测试数据
	cat1 := s.createTestCategory(ctx, "test-cat-1")
	cat2 := s.createTestCategory(ctx, "test-cat-2")

	// 为分类添加不同语言的内容
	_, err = s.svc.AddCategoryContent(ctx, cat1.ID, "en", "Test Category 1", "Test Description 1", "category-list-test-1")
	s.Require().NoError(err)

	_, err = s.svc.AddCategoryContent(ctx, cat2.ID, "zh-Hans", "测试分类2", "测试描述2", "category-list-test-2")
	s.Require().NoError(err)

	// 测试获取英文分类
	enCategories, err := s.svc.GetCategories(ctx, "en")
	s.Require().NoError(err)
	s.Len(enCategories, 1)
	s.Equal(cat1.ID, enCategories[0].ID)

	// 测试获取简体中文分类
	zhCategories, err := s.svc.GetCategories(ctx, "zh-Hans")
	s.Require().NoError(err)
	s.Len(zhCategories, 1)
	s.Equal(cat2.ID, zhCategories[0].ID)

	// 测试获取繁体中文分类（应该为空）
	zhHantCategories, err := s.svc.GetCategories(ctx, "zh-Hant")
	s.Require().NoError(err)
	s.Empty(zhHantCategories)
}

func (s *ServiceImplTestSuite) TestGetUserRoles() {
	ctx := context.Background()

	// 创建测试用户，默认会有 "user" 角色
	user, err := s.svc.CreateUser(ctx, "test@example.com", "password123", "user")
	s.Require().NoError(err)

	// 测试新用户有默认的 "user" 角色
	roles, err := s.svc.GetUserRoles(ctx, user.ID)
	s.Require().NoError(err)
	s.Len(roles, 1)
	s.Equal("user", roles[0].Name)

	// 分配角色给用户
	err = s.svc.AssignRole(ctx, user.ID, "admin")
	s.Require().NoError(err)

	// 测试用户现在有两个角色
	roles, err = s.svc.GetUserRoles(ctx, user.ID)
	s.Require().NoError(err)
	s.Len(roles, 2)
	roleNames := []string{roles[0].Name, roles[1].Name}
	s.Contains(roleNames, "user")
	s.Contains(roleNames, "admin")

	// 测试不存在的用户
	_, err = s.svc.GetUserRoles(ctx, -1)
	s.Require().Error(err)
}

func (s *ServiceImplTestSuite) TestDaily() {
	// 创建一个测试分类
	category, err := s.svc.CreateCategory(s.ctx)
	require.NoError(s.T(), err)
	require.NotNil(s.T(), category)

	// 添加分类内容
	categoryContent, err := s.svc.AddCategoryContent(s.ctx, category.ID, "en", "Test Category", "Test Description", "test-category")
	require.NoError(s.T(), err)
	require.NotNil(s.T(), categoryContent)

	dailyID := "250212" // 使用符合验证规则的 ID 格式：YYMMDD

	// 测试创建 Daily
	s.Run("Create Daily", func() {
		daily, err := s.svc.CreateDaily(s.ctx, dailyID, category.ID, "http://example.com/image.jpg")
		require.NoError(s.T(), err)
		require.NotNil(s.T(), daily)
		assert.Equal(s.T(), dailyID, daily.ID)
		assert.Equal(s.T(), category.ID, daily.Edges.Category.ID)
		assert.Equal(s.T(), "http://example.com/image.jpg", daily.ImageURL)
	})

	// 测试添加 Daily 内容
	s.Run("Add Daily Content", func() {
		content, err := s.svc.AddDailyContent(s.ctx, dailyID, "en", "Test quote for the day")
		require.NoError(s.T(), err)
		require.NotNil(s.T(), content)
		assert.Equal(s.T(), dailycontent.LanguageCodeEN, content.LanguageCode)
		assert.Equal(s.T(), "Test quote for the day", content.Quote)
	})

	// 测试获取 Daily
	s.Run("Get Daily By ID", func() {
		daily, err := s.svc.GetDailyByID(s.ctx, dailyID)
		require.NoError(s.T(), err)
		require.NotNil(s.T(), daily)
		assert.Equal(s.T(), dailyID, daily.ID)
		assert.Equal(s.T(), category.ID, daily.Edges.Category.ID)
	})

	// 测试列出 Daily
	s.Run("List Dailies", func() {
		// 创建另一个 Daily 用于测试列表
		anotherDailyID := "250213"
		_, err := s.svc.CreateDaily(s.ctx, anotherDailyID, category.ID, "http://example.com/image2.jpg")
		assert.NoError(s.T(), err)
		_, err = s.svc.AddDailyContent(s.ctx, anotherDailyID, "en", "Another test quote")
		assert.NoError(s.T(), err)

		// 测试列表功能
		dailies, err := s.svc.ListDailies(s.ctx, "en", &category.ID, 10, 0)
		assert.NoError(s.T(), err)
		assert.NotNil(s.T(), dailies)
		assert.Len(s.T(), dailies, 2)

		// 测试分页
		dailies, err = s.svc.ListDailies(s.ctx, "en", &category.ID, 1, 0)
		assert.NoError(s.T(), err)
		assert.NotNil(s.T(), dailies)
		assert.Len(s.T(), dailies, 1)

		// 测试无分类过滤
		dailies, err = s.svc.ListDailies(s.ctx, "en", nil, 10, 0)
		assert.NoError(s.T(), err)
		assert.NotNil(s.T(), dailies)
		assert.Len(s.T(), dailies, 2)
	})
}

func (s *ServiceImplTestSuite) TestPost() {
    s.Run("Create Post", func() {
        s.Run("Draft", func() {
            post, err := s.svc.CreatePost(s.ctx, "draft")
            require.NoError(s.T(), err)
            require.NotNil(s.T(), post)
            assert.Equal(s.T(), "draft", post.Status.String())
        })

        s.Run("Published", func() {
            post, err := s.svc.CreatePost(s.ctx, "published")
            require.NoError(s.T(), err)
            require.NotNil(s.T(), post)
            assert.Equal(s.T(), "published", post.Status.String())
        })

        s.Run("Archived", func() {
            post, err := s.svc.CreatePost(s.ctx, "archived")
            require.NoError(s.T(), err)
            require.NotNil(s.T(), post)
            assert.Equal(s.T(), "archived", post.Status.String())
        })

        s.Run("Invalid Status", func() {
            post, err := s.svc.CreatePost(s.ctx, "invalid")
            assert.Error(s.T(), err)
            assert.Nil(s.T(), post)
        })
    })

    s.Run("Add Post Content", func() {
        // Create a post first
        post, err := s.svc.CreatePost(s.ctx, "draft")
        require.NoError(s.T(), err)

        s.Run("English Content", func() {
            content, err := s.svc.AddPostContent(s.ctx, post.ID, "en", "Test Post", "# Test Content", "Test Summary", "test,post", "Test Description")
            require.NoError(s.T(), err)
            require.NotNil(s.T(), content)
            assert.Equal(s.T(), "en", content.LanguageCode.String())
            assert.Equal(s.T(), "Test Post", content.Title)
            assert.Equal(s.T(), "# Test Content", content.ContentMarkdown)
            assert.Equal(s.T(), "Test Summary", content.Summary)
            assert.Equal(s.T(), "test,post", content.MetaKeywords)
            assert.Equal(s.T(), "Test Description", content.MetaDescription)
            assert.Equal(s.T(), "test-post", content.Slug)
        })

        s.Run("Simplified Chinese Content", func() {
            content, err := s.svc.AddPostContent(s.ctx, post.ID, "zh-Hans", "测试帖子", "# 测试内容", "测试摘要", "测试,帖子", "测试描述")
            require.NoError(s.T(), err)
            require.NotNil(s.T(), content)
            assert.Equal(s.T(), "zh-Hans", content.LanguageCode.String())
            assert.Equal(s.T(), "测试帖子", content.Title)
            assert.Equal(s.T(), "# 测试内容", content.ContentMarkdown)
            assert.Equal(s.T(), "测试摘要", content.Summary)
            assert.Equal(s.T(), "测试,帖子", content.MetaKeywords)
            assert.Equal(s.T(), "测试描述", content.MetaDescription)
            assert.Equal(s.T(), "测试帖子", content.Slug)
        })

        s.Run("Traditional Chinese Content", func() {
            content, err := s.svc.AddPostContent(s.ctx, post.ID, "zh-Hant", "測試貼文", "# 測試內容", "測試摘要", "測試,貼文", "測試描述")
            require.NoError(s.T(), err)
            require.NotNil(s.T(), content)
            assert.Equal(s.T(), "zh-Hant", content.LanguageCode.String())
            assert.Equal(s.T(), "測試貼文", content.Title)
            assert.Equal(s.T(), "# 測試內容", content.ContentMarkdown)
            assert.Equal(s.T(), "測試摘要", content.Summary)
            assert.Equal(s.T(), "測試,貼文", content.MetaKeywords)
            assert.Equal(s.T(), "測試描述", content.MetaDescription)
            assert.Equal(s.T(), "測試貼文", content.Slug)
        })

        s.Run("Invalid Language Code", func() {
            content, err := s.svc.AddPostContent(s.ctx, post.ID, "fr", "Test Post", "# Test Content", "Test Summary", "test,post", "Test Description")
            assert.Error(s.T(), err)
            assert.Nil(s.T(), content)
        })

        s.Run("Non-existent Post", func() {
            content, err := s.svc.AddPostContent(s.ctx, 999999, "en", "Test Post", "# Test Content", "Test Summary", "test,post", "Test Description")
            assert.Error(s.T(), err)
            assert.Nil(s.T(), content)
        })
    })

    s.Run("Get Post By Slug", func() {
        // Create a post first
        post, err := s.svc.CreatePost(s.ctx, "published")
        require.NoError(s.T(), err)

        // Add content in different languages
        _, err = s.svc.AddPostContent(s.ctx, post.ID, "en", "Test Post", "# Test Content", "Test Summary", "test,post", "Test Description")
        require.NoError(s.T(), err)
        _, err = s.svc.AddPostContent(s.ctx, post.ID, "zh-Hans", "测试帖子", "# 测试内容", "测试摘要", "测试,帖子", "测试描述")
        require.NoError(s.T(), err)

        s.Run("Get Post By Slug - English", func() {
            result, err := s.svc.GetPostBySlug(s.ctx, "en", "test-post")
            require.NoError(s.T(), err)
            require.NotNil(s.T(), result)
            assert.Equal(s.T(), post.ID, result.ID)
            assert.Equal(s.T(), "published", result.Status.String())

            contents := result.Edges.Contents
            require.Len(s.T(), contents, 1)
            assert.Equal(s.T(), "en", contents[0].LanguageCode.String())
            assert.Equal(s.T(), "Test Post", contents[0].Title)
        })

        s.Run("Get Post By Slug - Chinese", func() {
            result, err := s.svc.GetPostBySlug(s.ctx, "zh-Hans", "测试帖子")
            require.NoError(s.T(), err)
            require.NotNil(s.T(), result)
            assert.Equal(s.T(), post.ID, result.ID)
            assert.Equal(s.T(), "published", result.Status.String())

            contents := result.Edges.Contents
            require.Len(s.T(), contents, 1)
            assert.Equal(s.T(), "zh-Hans", contents[0].LanguageCode.String())
            assert.Equal(s.T(), "测试帖子", contents[0].Title)
        })

        s.Run("Non-existent Post", func() {
            result, err := s.svc.GetPostBySlug(s.ctx, "en", "non-existent")
            assert.Error(s.T(), err)
            assert.Nil(s.T(), result)
        })

        s.Run("Invalid Language Code", func() {
            result, err := s.svc.GetPostBySlug(s.ctx, "fr", "test-post")
            assert.Error(s.T(), err)
            assert.Nil(s.T(), result)
        })
    })

    s.Run("List Posts", func() {
        // Create some posts with content
        for i := 0; i < 5; i++ {
            post, err := s.svc.CreatePost(s.ctx, "published")
            require.NoError(s.T(), err)

            // Add content in different languages
            _, err = s.svc.AddPostContent(s.ctx, post.ID, "en", fmt.Sprintf("Post %d", i), "# Content", "Summary", "test", "Description")
            require.NoError(s.T(), err)
            _, err = s.svc.AddPostContent(s.ctx, post.ID, "zh-Hans", fmt.Sprintf("帖子 %d", i), "# 内容", "摘要", "测试", "描述")
            require.NoError(s.T(), err)
        }

        s.Run("List All Posts - English", func() {
            posts, err := s.svc.ListPosts(s.ctx, "en", nil, 10, 0)
            require.NoError(s.T(), err)
            require.Len(s.T(), posts, 5)

            // Check that all posts have English content
            for _, post := range posts {
                contents := post.Edges.Contents
                require.Len(s.T(), contents, 1)
                assert.Equal(s.T(), "en", contents[0].LanguageCode.String())
            }
        })

        s.Run("List All Posts - Chinese", func() {
            posts, err := s.svc.ListPosts(s.ctx, "zh-Hans", nil, 10, 0)
            require.NoError(s.T(), err)
            require.Len(s.T(), posts, 5)

            // Check that all posts have Chinese content
            for _, post := range posts {
                contents := post.Edges.Contents
                require.Len(s.T(), contents, 1)
                assert.Equal(s.T(), "zh-Hans", contents[0].LanguageCode.String())
            }
        })

        s.Run("List Posts with Pagination", func() {
            // Get first page
            posts, err := s.svc.ListPosts(s.ctx, "en", nil, 2, 0)
            require.NoError(s.T(), err)
            require.Len(s.T(), posts, 2)

            // Get second page
            posts, err = s.svc.ListPosts(s.ctx, "en", nil, 2, 2)
            require.NoError(s.T(), err)
            require.Len(s.T(), posts, 2)

            // Get last page
            posts, err = s.svc.ListPosts(s.ctx, "en", nil, 2, 4)
            require.NoError(s.T(), err)
            require.Len(s.T(), posts, 1)
        })

        s.Run("List Posts by Category", func() {
            // Create a category
            category, err := s.svc.CreateCategory(s.ctx)
            require.NoError(s.T(), err)

            // Create posts in this category
            for i := 0; i < 3; i++ {
                post, err := s.svc.CreatePost(s.ctx, "published")
                require.NoError(s.T(), err)

                // Set category
                _, err = s.client.Post.UpdateOne(post).SetCategoryID(category.ID).Save(s.ctx)
                require.NoError(s.T(), err)

                // Add content
                _, err = s.svc.AddPostContent(s.ctx, post.ID, "en", fmt.Sprintf("Category Post %d", i), "# Content", "Summary", "test", "Description")
                require.NoError(s.T(), err)
            }

            // List posts in this category
            posts, err := s.svc.ListPosts(s.ctx, "en", &category.ID, 10, 0)
            require.NoError(s.T(), err)
            require.Len(s.T(), posts, 3)

            // Check that all posts belong to the category
            for _, post := range posts {
                assert.Equal(s.T(), category.ID, post.Edges.Category.ID)
            }
        })

        s.Run("Invalid Language Code", func() {
            posts, err := s.svc.ListPosts(s.ctx, "fr", nil, 10, 0)
            assert.Error(s.T(), err)
            assert.Nil(s.T(), posts)
        })
    })
}

func (s *ServiceImplTestSuite) TestMedia() {
	s.Run("Upload Media", func() {
		// Create a user first
		user, err := s.svc.CreateUser(s.ctx, "test@example.com", "password123", "")
		require.NoError(s.T(), err)
		require.NotNil(s.T(), user)

		// Mock file content
		fileContent := []byte("test file content")

		// Mock the file header
		fileHeader := &multipart.FileHeader{
			Filename: "test.jpg",
			Size:    int64(len(fileContent)),
			Header: textproto.MIMEHeader{
				"Content-Type": []string{"image/jpeg"},
			},
		}

		// Mock the storage behavior
		s.storage.EXPECT().
			Save(gomock.Any(), fileHeader.Filename, "image/jpeg", gomock.Any()).
			DoAndReturn(func(ctx context.Context, name, contentType string, reader io.Reader) (*storage.FileInfo, error) {
				// Verify the reader content
				data, err := io.ReadAll(reader)
				if err != nil {
					return nil, err
				}
				if !bytes.Equal(data, fileContent) {
					return nil, fmt.Errorf("unexpected file content")
				}
				return &storage.FileInfo{
					ID:          "test123",
					Name:        name,
					Size:        int64(len(fileContent)),
					ContentType: contentType,
					URL:         "http://example.com/test.jpg",
					CreatedAt:   time.Now(),
					UpdatedAt:   time.Now(),
				}, nil
			}).Times(1)

		// Replace the Open method
		openFile = func(fh *multipart.FileHeader) (multipart.File, error) {
			return &mockMultipartFile{bytes.NewReader(fileContent)}, nil
		}

		// Test upload
		media, err := s.svc.Upload(s.ctx, fileHeader, user.ID)
		require.NoError(s.T(), err)
		require.NotNil(s.T(), media)
		assert.Equal(s.T(), "test123", media.StorageID)
		assert.Equal(s.T(), "test.jpg", media.OriginalName)
		assert.Equal(s.T(), int64(len(fileContent)), media.Size)
		assert.Equal(s.T(), "image/jpeg", media.MimeType)
		assert.Equal(s.T(), "http://example.com/test.jpg", media.URL)
		assert.Equal(s.T(), strconv.Itoa(user.ID), media.CreatedBy)

		// Now we can test other operations since we have a media record
		s.Run("Get Media", func() {
			result, err := s.svc.GetMedia(s.ctx, media.ID)
			require.NoError(s.T(), err)
			require.NotNil(s.T(), result)
			assert.Equal(s.T(), media.ID, result.ID)
			assert.Equal(s.T(), media.StorageID, result.StorageID)
			assert.Equal(s.T(), media.URL, result.URL)
		})

		s.Run("Get File", func() {
			// Mock the storage behavior
			mockReader := io.NopCloser(strings.NewReader("test content"))
			mockFileInfo := &storage.FileInfo{
				ID:          media.StorageID,
				Name:        media.OriginalName,
				Size:        media.Size,
				ContentType: media.MimeType,
				URL:         media.URL,
				CreatedAt:   media.CreatedAt,
				UpdatedAt:   media.UpdatedAt,
			}
			s.storage.EXPECT().
				Get(gomock.Any(), media.StorageID).
				Return(mockReader, mockFileInfo, nil)

			// Test get file
			reader, fileInfo, err := s.svc.GetFile(s.ctx, media.ID)
			require.NoError(s.T(), err)
			require.NotNil(s.T(), reader)
			require.NotNil(s.T(), fileInfo)
			assert.Equal(s.T(), media.OriginalName, fileInfo.Name)
			assert.Equal(s.T(), media.Size, fileInfo.Size)
			assert.Equal(s.T(), media.MimeType, fileInfo.ContentType)
			assert.Equal(s.T(), media.URL, fileInfo.URL)

			// Clean up
			reader.Close()
		})

		s.Run("List Media", func() {
			// Test list media
			list, err := s.svc.ListMedia(s.ctx, 10, 0)
			require.NoError(s.T(), err)
			require.NotNil(s.T(), list)
			require.Len(s.T(), list, 1)
			assert.Equal(s.T(), "test.jpg", list[0].OriginalName)
		})

		s.Run("Delete Media", func() {
			// Mock the storage behavior
			s.storage.EXPECT().
				Delete(gomock.Any(), media.StorageID).
				Return(nil)

			// Test delete media
			err = s.svc.DeleteMedia(s.ctx, media.ID, user.ID)
			require.NoError(s.T(), err)

			// Verify media is deleted
			count, err := s.client.Media.Query().Count(s.ctx)
			require.NoError(s.T(), err)
			assert.Equal(s.T(), 0, count)
		})
	})

	s.Run("Delete Media - Unauthorized", func() {
		// Create a user
		user, err := s.svc.CreateUser(s.ctx, "another@example.com", "password123", "")
		require.NoError(s.T(), err)

		// Mock file content
		fileContent := []byte("test file content")

		// Mock the file header
		fileHeader := &multipart.FileHeader{
			Filename: "test2.jpg",
			Size:    int64(len(fileContent)),
			Header: textproto.MIMEHeader{
				"Content-Type": []string{"image/jpeg"},
			},
		}

		// Mock the storage behavior
		s.storage.EXPECT().
			Save(gomock.Any(), fileHeader.Filename, "image/jpeg", gomock.Any()).
			DoAndReturn(func(ctx context.Context, name, contentType string, reader io.Reader) (*storage.FileInfo, error) {
				// Verify the reader content
				data, err := io.ReadAll(reader)
				if err != nil {
					return nil, err
				}
				if !bytes.Equal(data, fileContent) {
					return nil, fmt.Errorf("unexpected file content")
				}
				return &storage.FileInfo{
					ID:          "test456",
					Name:        name,
					Size:        int64(len(fileContent)),
					ContentType: contentType,
					URL:         "http://example.com/test2.jpg",
					CreatedAt:   time.Now(),
					UpdatedAt:   time.Now(),
				}, nil
			}).Times(1)

		// Replace the Open method
		openFile = func(fh *multipart.FileHeader) (multipart.File, error) {
			return &mockMultipartFile{bytes.NewReader(fileContent)}, nil
		}

		media, err := s.svc.Upload(s.ctx, fileHeader, user.ID)
		require.NoError(s.T(), err)

		// Try to delete with different user
		anotherUser, err := s.svc.CreateUser(s.ctx, "third@example.com", "password123", "")
		require.NoError(s.T(), err)

		err = s.svc.DeleteMedia(s.ctx, media.ID, anotherUser.ID)
		assert.Equal(s.T(), ErrUnauthorized, err)

		// Verify media is not deleted
		count, err := s.client.Media.Query().Count(s.ctx)
		require.NoError(s.T(), err)
		assert.Equal(s.T(), 1, count)
	})
}

func (s *ServiceImplTestSuite) TestContributor() {
	// 测试创建贡献者
	avatarURL := "https://example.com/avatar.jpg"
	bio := "Test bio"
	contributor, err := s.svc.CreateContributor(s.ctx, "Test Contributor", &avatarURL, &bio)
	require.NoError(s.T(), err)
	require.NotNil(s.T(), contributor)
	assert.Equal(s.T(), "Test Contributor", contributor.Name)
	assert.Equal(s.T(), avatarURL, contributor.AvatarURL)
	assert.Equal(s.T(), bio, contributor.Bio)

	// 测试添加社交链接
	link, err := s.svc.AddContributorSocialLink(s.ctx, contributor.ID, "github", "GitHub", "https://github.com/test")
	require.NoError(s.T(), err)
	require.NotNil(s.T(), link)
	assert.Equal(s.T(), "github", link.Type.String())
	assert.Equal(s.T(), "GitHub", link.Name)
	assert.Equal(s.T(), "https://github.com/test", link.Value)

	// 测试获取贡献者
	fetchedContributor, err := s.svc.GetContributorByID(s.ctx, contributor.ID)
	require.NoError(s.T(), err)
	require.NotNil(s.T(), fetchedContributor)
	assert.Equal(s.T(), contributor.ID, fetchedContributor.ID)
	assert.Equal(s.T(), contributor.Name, fetchedContributor.Name)
	assert.Equal(s.T(), contributor.AvatarURL, fetchedContributor.AvatarURL)
	assert.Equal(s.T(), contributor.Bio, fetchedContributor.Bio)
	require.Len(s.T(), fetchedContributor.Edges.SocialLinks, 1)
	assert.Equal(s.T(), link.ID, fetchedContributor.Edges.SocialLinks[0].ID)

	// 测试列出贡献者
	contributors, err := s.svc.ListContributors(s.ctx)
	require.NoError(s.T(), err)
	require.NotEmpty(s.T(), contributors)
	assert.Equal(s.T(), contributor.ID, contributors[0].ID)
	require.Len(s.T(), contributors[0].Edges.SocialLinks, 1)

	// 测试错误情况
	_, err = s.svc.GetContributorByID(s.ctx, -1)
	assert.Error(s.T(), err)

	_, err = s.svc.AddContributorSocialLink(s.ctx, -1, "github", "GitHub", "https://github.com/test")
	assert.Error(s.T(), err)

	// 测试无效的社交链接类型
	_, err = s.svc.AddContributorSocialLink(s.ctx, contributor.ID, "invalid_type", "Invalid", "https://example.com")
	assert.Error(s.T(), err)
}

func TestServiceSuite(t *testing.T) {
	suite.Run(t, new(ServiceSuite))
}

type ServiceSuite struct {
	suite.Suite
}

func TestServiceInterface(t *testing.T) {
	var _ Service = (*serviceImpl)(nil)
}

// 创建测试分类的辅助函数
func (s *ServiceImplTestSuite) createTestCategory(ctx context.Context, slug string) *ent.Category {
	category, err := s.svc.CreateCategory(ctx)
	s.Require().NoError(err)
	return category
}