package usecase

import (
	"context"
	"errors"
	"testing"
	"time"

	"code.30cm.net/digimon/app-cloudep-product-service/pkg/domain/entity"
	"code.30cm.net/digimon/app-cloudep-product-service/pkg/domain/repository"
	"code.30cm.net/digimon/app-cloudep-product-service/pkg/domain/usecase"
	mockRepository "code.30cm.net/digimon/app-cloudep-product-service/pkg/mock/repository"
	repo "code.30cm.net/digimon/app-cloudep-product-service/pkg/repository"
	"github.com/stretchr/testify/assert"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"go.uber.org/mock/gomock"
)

func TestProductUseCase_Create(t *testing.T) {
	mockCtrl := gomock.NewController(t)
	defer mockCtrl.Finish()

	mockProductRepo := mockRepository.NewMockProductRepository(mockCtrl)
	mockStatsRepo := mockRepository.NewMockProductStatisticsRepo(mockCtrl)
	mockTagBinding := mockRepository.NewMockTagBindingRepo(mockCtrl)

	useCase := MustProductUseCase(ProductUseCaseParam{
		ProductRepo:           mockProductRepo,
		ProductStatisticsRepo: mockStatsRepo,
		TagBinding:            mockTagBinding,
	})

	ctx := context.Background()

	input := &usecase.Product{
		UID:              ptr("user-1"),
		Title:            ptr("Test Product"),
		ShortTitle:       ptr("Short"),
		Details:          ptr("Details here"),
		ShortDescription: ptr("Desc"),
		Media:            []usecase.Media{{Sort: 1, Type: "image", URL: "http://image"}},
		Slug:             ptr("test-product"),
		IsPublished:      ptr(true),
		Amount:           1000,
		StartTime:        ptr("2025-04-04T00:00:00Z"),
		EndTime:          ptr("2025-04-10T00:00:00Z"),
		Category:         ptr("education"),
		CustomFields:     []usecase.CustomFields{{Key: "Level", Value: "Beginner"}},
		Tags:             []string{"t1", "t2"},
	}

	tests := []struct {
		name          string
		mockSetup     func()
		expectedError string
	}{
		{
			name: "建立成功",
			mockSetup: func() {
				mockProductRepo.EXPECT().Transaction(gomock.Any(), gomock.Any(), gomock.Any()).
					DoAndReturn(func(ctx context.Context, fn func(sessCtx mongo.SessionContext) (any, error), opts ...*options.TransactionOptions) error {
						// ✅ 這邊用 gomock.Any() 模擬 sessCtx
						mockProductRepo.EXPECT().Insert(gomock.Any(), gomock.Any()).Return(nil)
						mockStatsRepo.EXPECT().Create(gomock.Any(), gomock.Any()).Return(nil)
						mockTagBinding.EXPECT().BindTags(gomock.Any(), gomock.Any()).Return(nil)
						_, err := fn(nil)
						return err
					})
			},
		},
		{
			name: "插入失敗",
			mockSetup: func() {
				mockProductRepo.EXPECT().Transaction(gomock.Any(), gomock.Any(), gomock.Any()).
					DoAndReturn(func(ctx context.Context, fn func(sessCtx mongo.SessionContext) (any, error), opts ...*options.TransactionOptions) error {
						mockProductRepo.EXPECT().Insert(gomock.Any(), gomock.Any()).Return(errors.New("failed to create product"))
						_, err := fn(nil)
						return err
					})
			},
			expectedError: "failed to create product",
		},
		{
			name: "統計建立失敗",
			mockSetup: func() {
				mockProductRepo.EXPECT().Transaction(gomock.Any(), gomock.Any(), gomock.Any()).
					DoAndReturn(func(ctx context.Context, fn func(sessCtx mongo.SessionContext) (any, error), opts ...*options.TransactionOptions) error {
						mockProductRepo.EXPECT().Insert(gomock.Any(), gomock.Any()).Return(nil)
						mockStatsRepo.EXPECT().Create(gomock.Any(), gomock.Any()).Return(errors.New("failed to create product statistics"))
						_, err := fn(nil)
						return err
					})
			},
			expectedError: "failed to create product statistics",
		},
		{
			name: "綁定標籤失敗",
			mockSetup: func() {
				mockProductRepo.EXPECT().Transaction(gomock.Any(), gomock.Any(), gomock.Any()).
					DoAndReturn(func(ctx context.Context, fn func(sessCtx mongo.SessionContext) (any, error), opts ...*options.TransactionOptions) error {
						mockProductRepo.EXPECT().Insert(gomock.Any(), gomock.Any()).Return(nil)
						mockStatsRepo.EXPECT().Create(gomock.Any(), gomock.Any()).Return(nil)
						mockTagBinding.EXPECT().BindTags(gomock.Any(), gomock.Any()).Return(errors.New("failed to bind product tags"))
						_, err := fn(nil)
						return err
					})
			},
			expectedError: "failed to bind product tags",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			tt.mockSetup()
			err := useCase.Create(ctx, input)
			if tt.expectedError == "" {
				assert.NoError(t, err)
			} else {
				assert.Error(t, err)
				assert.Contains(t, err.Error(), tt.expectedError)
			}
		})
	}
}

func TestProductUseCase_IncOrders(t *testing.T) {
	mockCtrl := gomock.NewController(t)
	defer mockCtrl.Finish()

	mockStatsRepo := mockRepository.NewMockProductStatisticsRepo(mockCtrl)
	useCase := MustProductUseCase(ProductUseCaseParam{
		ProductStatisticsRepo: mockStatsRepo,
	})

	ctx := context.Background()
	productID := primitive.NewObjectID().Hex()

	t.Run("成功增加訂單", func(t *testing.T) {
		mockStatsRepo.EXPECT().IncOrders(ctx, productID, int64(2)).Return(nil)
		err := useCase.IncOrders(ctx, productID, 2)
		assert.NoError(t, err)
	})

	t.Run("資料庫錯誤", func(t *testing.T) {
		mockStatsRepo.EXPECT().IncOrders(ctx, productID, int64(1)).Return(errors.New("db error"))
		err := useCase.IncOrders(ctx, productID, 1)
		assert.Error(t, err)
		assert.Contains(t, err.Error(), "failed to inc order")
	})
}

func TestProductUseCase_DecOrders(t *testing.T) {
	mockCtrl := gomock.NewController(t)
	defer mockCtrl.Finish()

	mockStatsRepo := mockRepository.NewMockProductStatisticsRepo(mockCtrl)
	useCase := MustProductUseCase(ProductUseCaseParam{
		ProductStatisticsRepo: mockStatsRepo,
	})

	ctx := context.Background()
	productID := primitive.NewObjectID().Hex()

	t.Run("成功減少訂單", func(t *testing.T) {
		mockStatsRepo.EXPECT().DecOrders(ctx, productID, int64(3)).Return(nil)
		err := useCase.DecOrders(ctx, productID, 3)
		assert.NoError(t, err)
	})

	t.Run("資料庫錯誤", func(t *testing.T) {
		mockStatsRepo.EXPECT().DecOrders(ctx, productID, int64(1)).Return(errors.New("db error"))
		err := useCase.DecOrders(ctx, productID, 1)
		assert.Error(t, err)
		assert.Contains(t, err.Error(), "failed to dec order")
	})
}

func TestProductUseCase_UpdateAverageRating(t *testing.T) {
	mockCtrl := gomock.NewController(t)
	defer mockCtrl.Finish()

	mockStatsRepo := mockRepository.NewMockProductStatisticsRepo(mockCtrl)
	useCase := MustProductUseCase(ProductUseCaseParam{
		ProductStatisticsRepo: mockStatsRepo,
	})

	ctx := context.Background()
	productID := primitive.NewObjectID().Hex()

	t.Run("成功更新評價", func(t *testing.T) {
		mockStatsRepo.EXPECT().UpdateAverageRating(ctx, productID, 4.5).Return(nil)
		err := useCase.UpdateAverageRating(ctx, productID, 4.5)
		assert.NoError(t, err)
	})

	t.Run("資料庫錯誤", func(t *testing.T) {
		mockStatsRepo.EXPECT().UpdateAverageRating(ctx, productID, 3.0).Return(errors.New("db error"))
		err := useCase.UpdateAverageRating(ctx, productID, 3.0)
		assert.Error(t, err)
		assert.Contains(t, err.Error(), "failed to update average rating")
	})
}

func TestProductUseCase_IncFansCount(t *testing.T) {
	mockCtrl := gomock.NewController(t)
	defer mockCtrl.Finish()

	mockStatsRepo := mockRepository.NewMockProductStatisticsRepo(mockCtrl)
	useCase := MustProductUseCase(ProductUseCaseParam{
		ProductStatisticsRepo: mockStatsRepo,
	})

	ctx := context.Background()
	productID := primitive.NewObjectID().Hex()

	t.Run("成功增加追蹤人數", func(t *testing.T) {
		mockStatsRepo.EXPECT().IncFansCount(ctx, productID, uint64(10)).Return(nil)
		err := useCase.IncFansCount(ctx, productID, 10)
		assert.NoError(t, err)
	})

	t.Run("資料庫錯誤", func(t *testing.T) {
		mockStatsRepo.EXPECT().IncFansCount(ctx, productID, uint64(5)).Return(errors.New("db error"))
		err := useCase.IncFansCount(ctx, productID, 5)
		assert.Error(t, err)
		assert.Contains(t, err.Error(), "failed to inc fans count")
	})
}

func TestProductUseCase_DecFansCount(t *testing.T) {
	mockCtrl := gomock.NewController(t)
	defer mockCtrl.Finish()

	mockStatsRepo := mockRepository.NewMockProductStatisticsRepo(mockCtrl)
	useCase := MustProductUseCase(ProductUseCaseParam{
		ProductStatisticsRepo: mockStatsRepo,
	})

	ctx := context.Background()
	productID := primitive.NewObjectID().Hex()

	t.Run("成功減少追蹤人數", func(t *testing.T) {
		mockStatsRepo.EXPECT().DecFansCount(ctx, productID, uint64(7)).Return(nil)
		err := useCase.DecFansCount(ctx, productID, 7)
		assert.NoError(t, err)
	})

	t.Run("資料庫錯誤", func(t *testing.T) {
		mockStatsRepo.EXPECT().DecFansCount(ctx, productID, uint64(2)).Return(errors.New("db error"))
		err := useCase.DecFansCount(ctx, productID, 2)
		assert.Error(t, err)
		assert.Contains(t, err.Error(), "failed to dec fans count")
	})
}

func TestProductUseCase_Update(t *testing.T) {
	mockCtrl := gomock.NewController(t)
	defer mockCtrl.Finish()

	mockProductRepo := mockRepository.NewMockProductRepository(mockCtrl)
	mockTagBinding := mockRepository.NewMockTagBindingRepo(mockCtrl)

	useCase := MustProductUseCase(ProductUseCaseParam{
		ProductRepo: mockProductRepo,
		TagBinding:  mockTagBinding,
	})
	ctx := context.Background()
	id := primitive.NewObjectID().Hex()
	product := &usecase.Product{
		Title: ptr("Updated Product"),
		Tags:  []string{"t1", "t2"},
	}
	t.Run("更新成功", func(t *testing.T) {
		mockProductRepo.EXPECT().Transaction(gomock.Any(), gomock.Any(), gomock.Any()).DoAndReturn(
			func(ctx context.Context, fn func(sessCtx mongo.SessionContext) (any, error), opts ...*options.TransactionOptions) error {
				mockProductRepo.EXPECT().Update(gomock.Any(), id, gomock.Any()).Return(nil, nil)
				mockTagBinding.EXPECT().UnbindTagByReferenceID(gomock.Any(), id).Return(nil)
				mockTagBinding.EXPECT().BindTags(gomock.Any(), gomock.Any()).Return(nil)
				_, err := fn(nil)
				return err
			},
		)
		err := useCase.Update(ctx, id, product)
		assert.NoError(t, err)
	})

	t.Run("更新失敗 - ProductRepo", func(t *testing.T) {
		mockProductRepo.EXPECT().Transaction(gomock.Any(), gomock.Any(), gomock.Any()).DoAndReturn(
			func(ctx context.Context, fn func(sessCtx mongo.SessionContext) (any, error), opts ...*options.TransactionOptions) error {
				mockProductRepo.EXPECT().Update(gomock.Any(), id, gomock.Any()).Return(nil, errors.New("update failed"))
				_, err := fn(nil)
				return err
			},
		)
		err := useCase.Update(ctx, id, product)
		assert.Error(t, err)
		assert.Contains(t, err.Error(), "failed to update product")
	})

	t.Run("解除綁定失敗", func(t *testing.T) {
		mockProductRepo.EXPECT().Transaction(gomock.Any(), gomock.Any(), gomock.Any()).DoAndReturn(
			func(ctx context.Context, fn func(sessCtx mongo.SessionContext) (any, error), opts ...*options.TransactionOptions) error {
				mockProductRepo.EXPECT().Update(gomock.Any(), id, gomock.Any()).Return(nil, nil)
				mockTagBinding.EXPECT().UnbindTagByReferenceID(gomock.Any(), id).Return(errors.New("unbind error"))
				_, err := fn(nil)
				return err
			},
		)
		err := useCase.Update(ctx, id, product)
		assert.Error(t, err)
		assert.Contains(t, err.Error(), "failed to unbind tags")
	})

	t.Run("綁定失敗", func(t *testing.T) {
		mockProductRepo.EXPECT().Transaction(gomock.Any(), gomock.Any(), gomock.Any()).DoAndReturn(
			func(ctx context.Context, fn func(sessCtx mongo.SessionContext) (any, error), opts ...*options.TransactionOptions) error {
				mockProductRepo.EXPECT().Update(gomock.Any(), id, gomock.Any()).Return(nil, nil)
				mockTagBinding.EXPECT().UnbindTagByReferenceID(gomock.Any(), id).Return(nil)
				mockTagBinding.EXPECT().BindTags(gomock.Any(), gomock.Any()).Return(errors.New("bind error"))
				_, err := fn(nil)
				return err
			},
		)
		err := useCase.Update(ctx, id, product)
		assert.Error(t, err)
		assert.Contains(t, err.Error(), "failed to bind tags")
	})
}

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

func TestProductUseCase_Delete(t *testing.T) {
	mockCtrl := gomock.NewController(t)
	defer mockCtrl.Finish()
	mockProductRepo := mockRepository.NewMockProductRepository(mockCtrl)
	mockTagRepo := mockRepository.NewMockTagRepo(mockCtrl)
	useCase := MustProductUseCase(ProductUseCaseParam{
		ProductRepo: mockProductRepo,
		TagRepo:     mockTagRepo,
	})
	ctx := context.Background()
	id := primitive.NewObjectID().Hex()
	t.Run("刪除成功", func(t *testing.T) {
		mockProductRepo.EXPECT().Transaction(gomock.Any(), gomock.Any(), gomock.Any()).DoAndReturn(
			func(ctx context.Context, fn func(sessCtx mongo.SessionContext) (any, error), opts ...*options.TransactionOptions) error {
				mockProductRepo.EXPECT().Delete(gomock.Any(), id).Return(nil)
				mockTagRepo.EXPECT().UnbindTagByReferenceID(gomock.Any(), id).Return(nil)
				_, err := fn(nil)
				return err
			},
		)
		err := useCase.Delete(ctx, id)
		assert.NoError(t, err)
	})

	t.Run("刪除失敗", func(t *testing.T) {
		mockProductRepo.EXPECT().Transaction(gomock.Any(), gomock.Any(), gomock.Any()).DoAndReturn(
			func(ctx context.Context, fn func(sessCtx mongo.SessionContext) (any, error), opts ...*options.TransactionOptions) error {
				mockProductRepo.EXPECT().Delete(gomock.Any(), id).Return(errors.New("delete error"))
				_, err := fn(nil)
				return err
			},
		)
		err := useCase.Delete(ctx, id)
		assert.Error(t, err)
		assert.Contains(t, err.Error(), "failed to delete product")
	})

	t.Run("解除綁定失敗", func(t *testing.T) {
		mockProductRepo.EXPECT().Transaction(gomock.Any(), gomock.Any(), gomock.Any()).DoAndReturn(
			func(ctx context.Context, fn func(sessCtx mongo.SessionContext) (any, error), opts ...*options.TransactionOptions) error {
				mockProductRepo.EXPECT().Delete(gomock.Any(), id).Return(nil)
				mockTagRepo.EXPECT().UnbindTagByReferenceID(gomock.Any(), id).Return(errors.New("unbind tag error"))
				_, err := fn(nil)
				return err
			},
		)
		err := useCase.Delete(ctx, id)
		assert.Error(t, err)
		assert.Contains(t, err.Error(), "failed to unbind tags")
	})
}

// ========================= Get =========================

func TestProductUseCase_Get(t *testing.T) {
	mockCtrl := gomock.NewController(t)
	defer mockCtrl.Finish()
	mockProductRepo := mockRepository.NewMockProductRepository(mockCtrl)
	mockStatsRepo := mockRepository.NewMockProductStatisticsRepo(mockCtrl)
	mockTagRepo := mockRepository.NewMockTagRepo(mockCtrl)

	useCase := MustProductUseCase(ProductUseCaseParam{
		ProductRepo:           mockProductRepo,
		ProductStatisticsRepo: mockStatsRepo,
		TagRepo:               mockTagRepo,
	})
	ctx := context.Background()
	id := primitive.NewObjectID()
	t.Run("查詢成功", func(t *testing.T) {
		mockProductRepo.EXPECT().FindOneByID(ctx, id.Hex()).Return(&entity.Product{
			ID:           id,
			UID:          "u1",
			Title:        "test",
			IsPublished:  true,
			Media:        []entity.Media{},
			CustomFields: []entity.CustomFields{},
			CreatedAt:    time.Now().Unix(),
			UpdatedAt:    time.Now().Unix(),
		}, nil)
		mockStatsRepo.EXPECT().GetByID(ctx, id.Hex()).Return(&entity.ProductStatistics{}, nil)
		mockTagRepo.EXPECT().GetBindingsByReference(ctx, id.Hex()).Return([]*entity.TagsBindingTable{}, nil)
		mockTagRepo.EXPECT().GetByIDs(ctx, gomock.Any()).Return([]*entity.Tags{}, nil)
		resp, err := useCase.Get(ctx, id.Hex())
		assert.NoError(t, err)
		assert.Equal(t, "u1", resp.UID)
	})

	t.Run("查詢失敗 - ProductRepo", func(t *testing.T) {
		mockProductRepo.EXPECT().FindOneByID(ctx, id.Hex()).Return(nil, errors.New("db error"))
		resp, err := useCase.Get(ctx, id.Hex())
		assert.Error(t, err)
		assert.Nil(t, resp)
	})
}

// ========================= Tag Binding =========================

func TestProductUseCase_BindTag(t *testing.T) {
	mockCtrl := gomock.NewController(t)
	defer mockCtrl.Finish()
	mockProductRepo := mockRepository.NewMockProductRepository(mockCtrl)
	mockTagRepo := mockRepository.NewMockTagRepo(mockCtrl)
	mockTagBinding := mockRepository.NewMockTagBindingRepo(mockCtrl)

	useCase := MustProductUseCase(ProductUseCaseParam{
		ProductRepo: mockProductRepo,
		TagRepo:     mockTagRepo,
		TagBinding:  mockTagBinding,
	})
	ctx := context.Background()
	binding := usecase.TagsBindingTable{
		ReferenceID: "pid-123",
		TagID:       "tag-123",
	}

	t.Run("成功綁定", func(t *testing.T) {
		mockTagRepo.EXPECT().GetByID(ctx, binding.TagID).Return(&entity.Tags{}, nil)
		mockProductRepo.EXPECT().FindOneByID(ctx, binding.ReferenceID).Return(&entity.Product{}, nil)
		mockTagBinding.EXPECT().BindTags(ctx, gomock.Any()).Return(nil)
		err := useCase.BindTag(ctx, binding)
		assert.NoError(t, err)
	})

	t.Run("Tag 不存在", func(t *testing.T) {
		mockTagRepo.EXPECT().GetByID(ctx, binding.TagID).Return(nil, repo.ErrNotFound)
		err := useCase.BindTag(ctx, binding)
		assert.Error(t, err)
		assert.Contains(t, err.Error(), "failed to get tags")
	})

	t.Run("Product 不存在", func(t *testing.T) {
		mockTagRepo.EXPECT().GetByID(ctx, binding.TagID).Return(&entity.Tags{}, nil)
		mockProductRepo.EXPECT().FindOneByID(ctx, binding.ReferenceID).Return(nil, repo.ErrNotFound)
		err := useCase.BindTag(ctx, binding)
		assert.Error(t, err)
		assert.Contains(t, err.Error(), "failed to get tags")
	})

	t.Run("綁定錯誤", func(t *testing.T) {
		mockTagRepo.EXPECT().GetByID(ctx, binding.TagID).Return(&entity.Tags{}, nil)
		mockProductRepo.EXPECT().FindOneByID(ctx, binding.ReferenceID).Return(&entity.Product{}, nil)
		mockTagBinding.EXPECT().BindTags(ctx, gomock.Any()).Return(errors.New("db error"))
		err := useCase.BindTag(ctx, binding)
		assert.Error(t, err)
		assert.Contains(t, err.Error(), "failed to bind tags")
	})
}

func TestProductUseCase_UnbindTag(t *testing.T) {
	mockCtrl := gomock.NewController(t)
	defer mockCtrl.Finish()
	mockProductRepo := mockRepository.NewMockProductRepository(mockCtrl)
	mockTagRepo := mockRepository.NewMockTagRepo(mockCtrl)
	mockTagBinding := mockRepository.NewMockTagBindingRepo(mockCtrl)

	useCase := MustProductUseCase(ProductUseCaseParam{
		ProductRepo: mockProductRepo,
		TagRepo:     mockTagRepo,
		TagBinding:  mockTagBinding,
	})
	ctx := context.Background()
	binding := usecase.TagsBindingTable{
		ReferenceID: "pid-123",
		TagID:       "tag-123",
	}

	t.Run("成功解除綁定", func(t *testing.T) {
		mockTagRepo.EXPECT().GetByID(ctx, binding.TagID).Return(&entity.Tags{}, nil)
		mockProductRepo.EXPECT().FindOneByID(ctx, binding.ReferenceID).Return(&entity.Product{}, nil)
		mockTagBinding.EXPECT().UnbindTag(ctx, binding.TagID, binding.ReferenceID).Return(nil)
		err := useCase.UnbindTag(ctx, binding)
		assert.NoError(t, err)
	})

	t.Run("解除失敗", func(t *testing.T) {
		mockTagRepo.EXPECT().GetByID(ctx, binding.TagID).Return(&entity.Tags{}, nil)
		mockProductRepo.EXPECT().FindOneByID(ctx, binding.ReferenceID).Return(&entity.Product{}, nil)
		mockTagBinding.EXPECT().UnbindTag(ctx, binding.TagID, binding.ReferenceID).Return(errors.New("unbind error"))
		err := useCase.UnbindTag(ctx, binding)
		assert.Error(t, err)
		assert.Contains(t, err.Error(), "failed to unbind tags")
	})
}

func TestProductUseCase_GetBindingsByReference(t *testing.T) {
	mockCtrl := gomock.NewController(t)
	defer mockCtrl.Finish()
	mockTagBinding := mockRepository.NewMockTagBindingRepo(mockCtrl)
	useCase := MustProductUseCase(ProductUseCaseParam{
		TagBinding: mockTagBinding,
	})
	ctx := context.Background()
	refID := "ref-123"

	t.Run("查詢成功", func(t *testing.T) {
		now := time.Now().Unix()
		mockTagBinding.EXPECT().GetBindingsByReference(ctx, refID).Return([]*entity.TagsBindingTable{
			{
				ID:          primitive.NewObjectID(),
				ReferenceID: refID,
				TagID:       "tag-1",
				CreatedAt:   now,
				UpdatedAt:   now,
			},
		}, nil)
		resp, err := useCase.GetBindingsByReference(ctx, refID)
		assert.NoError(t, err)
		assert.Len(t, resp, 1)
	})

	t.Run("查詢失敗", func(t *testing.T) {
		mockTagBinding.EXPECT().GetBindingsByReference(ctx, refID).Return(nil, errors.New("db error"))
		resp, err := useCase.GetBindingsByReference(ctx, refID)
		assert.Error(t, err)
		assert.Nil(t, resp)
	})
}

func TestProductUseCase_ListTagBinding(t *testing.T) {
	mockCtrl := gomock.NewController(t)
	defer mockCtrl.Finish()
	mockTagBinding := mockRepository.NewMockTagBindingRepo(mockCtrl)
	useCase := MustProductUseCase(ProductUseCaseParam{
		TagBinding: mockTagBinding,
	})
	ctx := context.Background()
	params := usecase.TagBindingQueryParams{
		ReferenceID: ptr("r1"),
		TagID:       ptr("t1"),
		PageSize:    10,
		PageIndex:   1,
	}

	t.Run("查詢成功", func(t *testing.T) {
		now := time.Now().Unix()
		mockTagBinding.EXPECT().ListTagBinding(ctx, repository.TagBindingQueryParams{
			ReferenceID: params.ReferenceID,
			TagID:       params.TagID,
			PageSize:    params.PageSize,
			PageIndex:   params.PageIndex,
		}).Return([]*entity.TagsBindingTable{
			{
				ID:          primitive.NewObjectID(),
				ReferenceID: *params.ReferenceID,
				TagID:       *params.TagID,
				CreatedAt:   now,
				UpdatedAt:   now,
			},
		}, int64(1), nil)

		resp, total, err := useCase.ListTagBinding(ctx, params)
		assert.NoError(t, err)
		assert.Len(t, resp, 1)
		assert.Equal(t, int64(1), total)
	})

	t.Run("查詢失敗", func(t *testing.T) {
		mockTagBinding.EXPECT().ListTagBinding(ctx, repository.TagBindingQueryParams{
			ReferenceID: params.ReferenceID,
			TagID:       params.TagID,
			PageSize:    params.PageSize,
			PageIndex:   params.PageIndex,
		}).Return(nil, int64(0), errors.New("db error"))

		resp, total, err := useCase.ListTagBinding(ctx, params)
		assert.Error(t, err)
		assert.Nil(t, resp)
		assert.Equal(t, int64(0), total)
	})
}

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

func TestProductUseCase_List(t *testing.T) {
	mockCtrl := gomock.NewController(t)
	defer mockCtrl.Finish()
	mockProductRepo := mockRepository.NewMockProductRepository(mockCtrl)
	mockStatsRepo := mockRepository.NewMockProductStatisticsRepo(mockCtrl)
	mockTagRepo := mockRepository.NewMockTagRepo(mockCtrl)

	useCase := MustProductUseCase(ProductUseCaseParam{
		ProductRepo:           mockProductRepo,
		ProductStatisticsRepo: mockStatsRepo,
		TagRepo:               mockTagRepo,
	})
	ctx := context.Background()
	id := primitive.NewObjectID()
	mockProductRepo.EXPECT().ListProduct(ctx, &repository.ProductQueryParams{
		PageIndex: 1,
		PageSize:  10,
	}).Return([]*entity.Product{{ID: id, UID: "u1", Title: "T", CreatedAt: time.Now().Unix(), UpdatedAt: time.Now().Unix()}}, int64(1), nil)
	mockStatsRepo.EXPECT().GetByID(ctx, id.Hex()).Return(&entity.ProductStatistics{}, nil)
	mockTagRepo.EXPECT().GetBindingsByReference(ctx, id.Hex()).Return([]*entity.TagsBindingTable{}, nil)
	mockTagRepo.EXPECT().GetByIDs(ctx, gomock.Any()).Return([]*entity.Tags{}, nil)

	list, count, err := useCase.List(ctx, usecase.ProductQueryParams{
		PageIndex: 1,
		PageSize:  10,
	})
	assert.NoError(t, err)
	assert.Equal(t, int64(1), count)
	assert.Len(t, list, 1)
}

// 工具：指標轉換
func ptr[T any](v T) *T {
	return &v
}