package my_package

import (
	"context"
	"testing"

	"github.com/break/junhong_cmp_fiber/internal/model"
	"github.com/break/junhong_cmp_fiber/internal/model/dto"
	"github.com/break/junhong_cmp_fiber/internal/store/postgres"
	"github.com/break/junhong_cmp_fiber/pkg/constants"
	"github.com/break/junhong_cmp_fiber/tests/testutils"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestService_GetCostPrice_Priority(t *testing.T) {
	tx := testutils.NewTestTransaction(t)
	ctx := context.Background()

	seriesAllocationStore := postgres.NewShopSeriesAllocationStore(tx)
	packageAllocationStore := postgres.NewShopPackageAllocationStore(tx)
	packageSeriesStore := postgres.NewPackageSeriesStore(tx)
	packageStore := postgres.NewPackageStore(tx)
	shopStore := postgres.NewShopStore(tx, nil)

	// 创建 Service
	svc := New(seriesAllocationStore, packageAllocationStore, packageSeriesStore, packageStore, shopStore)

	// 创建测试数据：套餐系列
	series := &model.PackageSeries{
		SeriesCode: "TEST_SERIES_001",
		SeriesName: "测试系列",
		Status:     constants.StatusEnabled,
	}
	require.NoError(t, packageSeriesStore.Create(ctx, series))

	// 创建测试数据：套餐
	pkg := &model.Package{
		PackageCode:          "TEST_PKG_001",
		PackageName:          "测试套餐",
		SeriesID:             series.ID,
		PackageType:          "formal",
		DurationMonths:       1,
		DataType:             "real",
		RealDataMB:           1024,
		DataAmountMB:         1024,
		Price:                9900,
		Status:               constants.StatusEnabled,
		ShelfStatus:          1,
		SuggestedCostPrice:   5000, // 基础成本价：50元
		SuggestedRetailPrice: 9900,
	}
	require.NoError(t, packageStore.Create(ctx, pkg))

	// 创建测试数据：上级店铺
	allocatorShop := &model.Shop{
		ShopName:     "上级店铺",
		ShopCode:     "ALLOCATOR_001",
		Status:       constants.StatusEnabled,
		Level:        1,
		ContactName:  "联系人",
		ContactPhone: "13800000000",
	}
	require.NoError(t, shopStore.Create(ctx, allocatorShop))

	// 创建测试数据：下级店铺
	shop := &model.Shop{
		ShopName:     "下级店铺",
		ShopCode:     "SHOP_001",
		Status:       constants.StatusEnabled,
		Level:        2,
		ParentID:     &allocatorShop.ID,
		ContactName:  "联系人",
		ContactPhone: "13800000001",
	}
	require.NoError(t, shopStore.Create(ctx, shop))

	// 创建测试数据：系列分配（系列加价模式）
	seriesAllocation := &model.ShopSeriesAllocation{
		ShopID:          shop.ID,
		SeriesID:        series.ID,
		AllocatorShopID: allocatorShop.ID,
		PricingMode:     model.PricingModeFixed,
		PricingValue:    1000, // 固定加价：10元
		Status:          constants.StatusEnabled,
	}
	require.NoError(t, seriesAllocationStore.Create(ctx, seriesAllocation))

	t.Run("套餐覆盖优先级最高", func(t *testing.T) {
		// 创建套餐覆盖（覆盖成本价：80元）
		packageOverride := &model.ShopPackageAllocation{
			ShopID:       shop.ID,
			PackageID:    pkg.ID,
			AllocationID: seriesAllocation.ID,
			CostPrice:    8000,
			Status:       constants.StatusEnabled,
		}
		require.NoError(t, packageAllocationStore.Create(ctx, packageOverride))

		allocationMap := map[uint]*model.ShopSeriesAllocation{series.ID: seriesAllocation}
		overrideMap := map[uint]*model.ShopPackageAllocation{pkg.ID: packageOverride}

		costPrice, priceSource := svc.GetCostPrice(ctx, shop.ID, pkg, allocationMap, overrideMap)

		// 应该返回套餐覆盖的成本价
		assert.Equal(t, int64(8000), costPrice)
		assert.Equal(t, dto.PriceSourcePackageOverride, priceSource)
	})

	t.Run("套餐覆盖禁用时使用系列加价", func(t *testing.T) {
		pkg2 := &model.Package{
			PackageCode:          "TEST_PKG_001_DISABLED",
			PackageName:          "测试套餐禁用",
			SeriesID:             series.ID,
			PackageType:          "formal",
			DurationMonths:       1,
			DataType:             "real",
			RealDataMB:           1024,
			DataAmountMB:         1024,
			Price:                9900,
			Status:               constants.StatusEnabled,
			ShelfStatus:          1,
			SuggestedCostPrice:   5000,
			SuggestedRetailPrice: 9900,
		}
		require.NoError(t, packageStore.Create(ctx, pkg2))

		packageOverride := &model.ShopPackageAllocation{
			ShopID:       shop.ID,
			PackageID:    pkg2.ID,
			AllocationID: seriesAllocation.ID,
			CostPrice:    8000,
			Status:       constants.StatusDisabled,
		}

		allocationMap := map[uint]*model.ShopSeriesAllocation{series.ID: seriesAllocation}
		overrideMap := map[uint]*model.ShopPackageAllocation{pkg2.ID: packageOverride}

		costPrice, priceSource := svc.GetCostPrice(ctx, shop.ID, pkg2, allocationMap, overrideMap)

		assert.Equal(t, int64(6000), costPrice)
		assert.Equal(t, dto.PriceSourceSeriesPricing, priceSource)
	})

	t.Run("无套餐覆盖时使用系列加价", func(t *testing.T) {
		allocationMap := map[uint]*model.ShopSeriesAllocation{series.ID: seriesAllocation}
		overrideMap := make(map[uint]*model.ShopPackageAllocation)

		costPrice, priceSource := svc.GetCostPrice(ctx, shop.ID, pkg, allocationMap, overrideMap)

		// 应该返回系列加价的成本价：5000 + 1000 = 6000
		assert.Equal(t, int64(6000), costPrice)
		assert.Equal(t, dto.PriceSourceSeriesPricing, priceSource)
	})

	t.Run("无系列分配时返回0", func(t *testing.T) {
		allocationMap := make(map[uint]*model.ShopSeriesAllocation)
		overrideMap := make(map[uint]*model.ShopPackageAllocation)

		costPrice, priceSource := svc.GetCostPrice(ctx, shop.ID, pkg, allocationMap, overrideMap)

		// 应该返回0和空的价格来源
		assert.Equal(t, int64(0), costPrice)
		assert.Equal(t, "", priceSource)
	})
}

func TestService_calculateCostPrice(t *testing.T) {
	tx := testutils.NewTestTransaction(t)

	seriesAllocationStore := postgres.NewShopSeriesAllocationStore(tx)
	packageAllocationStore := postgres.NewShopPackageAllocationStore(tx)
	packageSeriesStore := postgres.NewPackageSeriesStore(tx)
	packageStore := postgres.NewPackageStore(tx)
	shopStore := postgres.NewShopStore(tx, nil)

	// 创建 Service
	svc := New(seriesAllocationStore, packageAllocationStore, packageSeriesStore, packageStore, shopStore)

	tests := []struct {
		name              string
		parentCostPrice   int64
		pricingMode       string
		pricingValue      int64
		expectedCostPrice int64
		description       string
	}{
		{
			name:              "固定金额加价模式",
			parentCostPrice:   5000, // 50元
			pricingMode:       model.PricingModeFixed,
			pricingValue:      1000, // 加价10元
			expectedCostPrice: 6000, // 60元
			description:       "固定加价：5000 + 1000 = 6000",
		},
		{
			name:              "百分比加价模式",
			parentCostPrice:   5000, // 50元
			pricingMode:       model.PricingModePercent,
			pricingValue:      200,  // 20%（千分比：200/1000 = 20%）
			expectedCostPrice: 6000, // 50 + 50*20% = 60元
			description:       "百分比加价：5000 + (5000 * 200 / 1000) = 6000",
		},
		{
			name:              "百分比加价模式-10%",
			parentCostPrice:   10000, // 100元
			pricingMode:       model.PricingModePercent,
			pricingValue:      100,   // 10%（千分比：100/1000 = 10%）
			expectedCostPrice: 11000, // 100 + 100*10% = 110元
			description:       "百分比加价：10000 + (10000 * 100 / 1000) = 11000",
		},
		{
			name:              "未知加价模式返回原价",
			parentCostPrice:   5000,
			pricingMode:       "unknown",
			pricingValue:      1000,
			expectedCostPrice: 5000, // 返回原价不变
			description:       "未知模式：返回 parentCostPrice 不变",
		},
		{
			name:              "零加价",
			parentCostPrice:   5000,
			pricingMode:       model.PricingModeFixed,
			pricingValue:      0,
			expectedCostPrice: 5000,
			description:       "零加价：5000 + 0 = 5000",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			costPrice := svc.calculateCostPrice(tt.parentCostPrice, tt.pricingMode, tt.pricingValue)
			assert.Equal(t, tt.expectedCostPrice, costPrice, tt.description)
		})
	}
}

func TestService_ListMyPackages_Authorization(t *testing.T) {
	tx := testutils.NewTestTransaction(t)
	ctx := context.Background()

	seriesAllocationStore := postgres.NewShopSeriesAllocationStore(tx)
	packageAllocationStore := postgres.NewShopPackageAllocationStore(tx)
	packageSeriesStore := postgres.NewPackageSeriesStore(tx)
	packageStore := postgres.NewPackageStore(tx)
	shopStore := postgres.NewShopStore(tx, nil)

	// 创建 Service
	svc := New(seriesAllocationStore, packageAllocationStore, packageSeriesStore, packageStore, shopStore)

	t.Run("店铺ID为0时返回错误", func(t *testing.T) {
		// 创建不包含店铺ID的context
		ctxWithoutShop := context.WithValue(ctx, constants.ContextKeyShopID, uint(0))

		req := &dto.MyPackageListRequest{
			Page:     1,
			PageSize: 20,
		}

		packages, total, err := svc.ListMyPackages(ctxWithoutShop, req)

		// 应该返回错误
		require.Error(t, err)
		assert.Nil(t, packages)
		assert.Equal(t, int64(0), total)
		assert.Contains(t, err.Error(), "当前用户不属于任何店铺")
	})

	t.Run("无系列分配时返回空列表", func(t *testing.T) {
		// 创建店铺
		shop := &model.Shop{
			ShopName:     "测试店铺",
			ShopCode:     "SHOP_TEST_001",
			Status:       constants.StatusEnabled,
			Level:        1,
			ContactName:  "联系人",
			ContactPhone: "13800000000",
		}
		require.NoError(t, shopStore.Create(ctx, shop))

		// 创建包含店铺ID的context
		ctxWithShop := context.WithValue(ctx, constants.ContextKeyShopID, shop.ID)

		req := &dto.MyPackageListRequest{
			Page:     1,
			PageSize: 20,
		}

		packages, total, err := svc.ListMyPackages(ctxWithShop, req)

		// 应该返回空列表，无错误
		require.NoError(t, err)
		assert.NotNil(t, packages)
		assert.Equal(t, 0, len(packages))
		assert.Equal(t, int64(0), total)
	})

	t.Run("有系列分配时返回套餐列表", func(t *testing.T) {
		// 创建套餐系列
		series := &model.PackageSeries{
			SeriesCode: "TEST_SERIES_002",
			SeriesName: "测试系列2",
			Status:     constants.StatusEnabled,
		}
		require.NoError(t, packageSeriesStore.Create(ctx, series))

		// 创建套餐
		pkg := &model.Package{
			PackageCode:          "TEST_PKG_002",
			PackageName:          "测试套餐2",
			SeriesID:             series.ID,
			PackageType:          "formal",
			DurationMonths:       1,
			DataType:             "real",
			RealDataMB:           1024,
			DataAmountMB:         1024,
			Price:                9900,
			Status:               constants.StatusEnabled,
			ShelfStatus:          1,
			SuggestedCostPrice:   5000,
			SuggestedRetailPrice: 9900,
		}
		require.NoError(t, packageStore.Create(ctx, pkg))

		// 创建上级店铺
		allocatorShop := &model.Shop{
			ShopName:     "上级店铺2",
			ShopCode:     "ALLOCATOR_002",
			Status:       constants.StatusEnabled,
			Level:        1,
			ContactName:  "联系人",
			ContactPhone: "13800000000",
		}
		require.NoError(t, shopStore.Create(ctx, allocatorShop))

		// 创建下级店铺
		shop := &model.Shop{
			ShopName:     "下级店铺2",
			ShopCode:     "SHOP_002",
			Status:       constants.StatusEnabled,
			Level:        2,
			ParentID:     &allocatorShop.ID,
			ContactName:  "联系人",
			ContactPhone: "13800000001",
		}
		require.NoError(t, shopStore.Create(ctx, shop))

		// 创建系列分配
		seriesAllocation := &model.ShopSeriesAllocation{
			ShopID:          shop.ID,
			SeriesID:        series.ID,
			AllocatorShopID: allocatorShop.ID,
			PricingMode:     model.PricingModeFixed,
			PricingValue:    1000,
			Status:          constants.StatusEnabled,
		}
		require.NoError(t, seriesAllocationStore.Create(ctx, seriesAllocation))

		// 创建包含店铺ID的context
		ctxWithShop := context.WithValue(ctx, constants.ContextKeyShopID, shop.ID)

		req := &dto.MyPackageListRequest{
			Page:     1,
			PageSize: 20,
		}

		packages, total, err := svc.ListMyPackages(ctxWithShop, req)

		// 应该返回套餐列表
		require.NoError(t, err)
		assert.NotNil(t, packages)
		assert.Equal(t, 1, len(packages))
		assert.Equal(t, int64(1), total)
		assert.Equal(t, pkg.ID, packages[0].ID)
		assert.Equal(t, pkg.PackageName, packages[0].PackageName)
		// 验证成本价计算：5000 + 1000 = 6000
		assert.Equal(t, int64(6000), packages[0].CostPrice)
		assert.Equal(t, dto.PriceSourceSeriesPricing, packages[0].PriceSource)
	})

	t.Run("分页参数默认值", func(t *testing.T) {
		series := &model.PackageSeries{
			SeriesCode: "TEST_SERIES_PAGING",
			SeriesName: "分页测试系列",
			Status:     constants.StatusEnabled,
		}
		require.NoError(t, packageSeriesStore.Create(ctx, series))

		for i := range 5 {
			pkg := &model.Package{
				PackageCode:          "TEST_PKG_PAGING_" + string(byte('0'+byte(i))),
				PackageName:          "分页测试套餐_" + string(byte('0'+byte(i))),
				SeriesID:             series.ID,
				PackageType:          "formal",
				DurationMonths:       1,
				DataType:             "real",
				RealDataMB:           1024,
				DataAmountMB:         1024,
				Price:                9900,
				Status:               constants.StatusEnabled,
				ShelfStatus:          1,
				SuggestedCostPrice:   5000,
				SuggestedRetailPrice: 9900,
			}
			require.NoError(t, packageStore.Create(ctx, pkg))
		}

		allocatorShop := &model.Shop{
			ShopName:     "分页上级店铺",
			ShopCode:     "ALLOCATOR_PAGING",
			Status:       constants.StatusEnabled,
			Level:        1,
			ContactName:  "联系人",
			ContactPhone: "13800000000",
		}
		require.NoError(t, shopStore.Create(ctx, allocatorShop))

		shop := &model.Shop{
			ShopName:     "分页下级店铺",
			ShopCode:     "SHOP_PAGING",
			Status:       constants.StatusEnabled,
			Level:        2,
			ParentID:     &allocatorShop.ID,
			ContactName:  "联系人",
			ContactPhone: "13800000001",
		}
		require.NoError(t, shopStore.Create(ctx, shop))

		seriesAllocation := &model.ShopSeriesAllocation{
			ShopID:          shop.ID,
			SeriesID:        series.ID,
			AllocatorShopID: allocatorShop.ID,
			PricingMode:     model.PricingModeFixed,
			PricingValue:    1000,
			Status:          constants.StatusEnabled,
		}
		require.NoError(t, seriesAllocationStore.Create(ctx, seriesAllocation))

		ctxWithShop := context.WithValue(ctx, constants.ContextKeyShopID, shop.ID)

		req := &dto.MyPackageListRequest{}

		packages, total, err := svc.ListMyPackages(ctxWithShop, req)

		require.NoError(t, err)
		assert.NotNil(t, packages)
		assert.GreaterOrEqual(t, total, int64(5))
		assert.LessOrEqual(t, len(packages), constants.DefaultPageSize)
	})
}

func TestService_ListMyPackages_Filtering(t *testing.T) {
	tx := testutils.NewTestTransaction(t)
	ctx := context.Background()

	seriesAllocationStore := postgres.NewShopSeriesAllocationStore(tx)
	packageAllocationStore := postgres.NewShopPackageAllocationStore(tx)
	packageSeriesStore := postgres.NewPackageSeriesStore(tx)
	packageStore := postgres.NewPackageStore(tx)
	shopStore := postgres.NewShopStore(tx, nil)

	// 创建 Service
	svc := New(seriesAllocationStore, packageAllocationStore, packageSeriesStore, packageStore, shopStore)

	// 创建两个套餐系列
	series1 := &model.PackageSeries{
		SeriesCode: "SERIES_FILTER_001",
		SeriesName: "系列1",
		Status:     constants.StatusEnabled,
	}
	require.NoError(t, packageSeriesStore.Create(ctx, series1))

	series2 := &model.PackageSeries{
		SeriesCode: "SERIES_FILTER_002",
		SeriesName: "系列2",
		Status:     constants.StatusEnabled,
	}
	require.NoError(t, packageSeriesStore.Create(ctx, series2))

	// 创建不同类型的套餐
	pkg1 := &model.Package{
		PackageCode:          "PKG_FILTER_001",
		PackageName:          "正式套餐1",
		SeriesID:             series1.ID,
		PackageType:          "formal",
		DurationMonths:       1,
		DataType:             "real",
		RealDataMB:           1024,
		DataAmountMB:         1024,
		Price:                9900,
		Status:               constants.StatusEnabled,
		ShelfStatus:          1,
		SuggestedCostPrice:   5000,
		SuggestedRetailPrice: 9900,
	}
	require.NoError(t, packageStore.Create(ctx, pkg1))

	pkg2 := &model.Package{
		PackageCode:          "PKG_FILTER_002",
		PackageName:          "附加套餐1",
		SeriesID:             series2.ID,
		PackageType:          "addon",
		DurationMonths:       1,
		DataType:             "real",
		RealDataMB:           512,
		DataAmountMB:         512,
		Price:                4900,
		Status:               constants.StatusEnabled,
		ShelfStatus:          1,
		SuggestedCostPrice:   2500,
		SuggestedRetailPrice: 4900,
	}
	require.NoError(t, packageStore.Create(ctx, pkg2))

	// 创建上级店铺
	allocatorShop := &model.Shop{
		ShopName:     "上级店铺过滤",
		ShopCode:     "ALLOCATOR_FILTER",
		Status:       constants.StatusEnabled,
		Level:        1,
		ContactName:  "联系人",
		ContactPhone: "13800000000",
	}
	require.NoError(t, shopStore.Create(ctx, allocatorShop))

	// 创建下级店铺
	shop := &model.Shop{
		ShopName:     "下级店铺过滤",
		ShopCode:     "SHOP_FILTER",
		Status:       constants.StatusEnabled,
		Level:        2,
		ParentID:     &allocatorShop.ID,
		ContactName:  "联系人",
		ContactPhone: "13800000001",
	}
	require.NoError(t, shopStore.Create(ctx, shop))

	// 为两个系列都创建分配
	for _, series := range []*model.PackageSeries{series1, series2} {
		seriesAllocation := &model.ShopSeriesAllocation{
			ShopID:          shop.ID,
			SeriesID:        series.ID,
			AllocatorShopID: allocatorShop.ID,
			PricingMode:     model.PricingModeFixed,
			PricingValue:    1000,
			Status:          constants.StatusEnabled,
		}
		require.NoError(t, seriesAllocationStore.Create(ctx, seriesAllocation))
	}

	ctxWithShop := context.WithValue(ctx, constants.ContextKeyShopID, shop.ID)

	t.Run("按系列ID过滤", func(t *testing.T) {
		req := &dto.MyPackageListRequest{
			Page:     1,
			PageSize: 20,
			SeriesID: &series1.ID,
		}

		packages, total, err := svc.ListMyPackages(ctxWithShop, req)

		require.NoError(t, err)
		assert.Equal(t, int64(1), total)
		assert.Equal(t, 1, len(packages))
		assert.Equal(t, pkg1.ID, packages[0].ID)
	})

	t.Run("按套餐类型过滤", func(t *testing.T) {
		packageType := "addon"
		req := &dto.MyPackageListRequest{
			Page:        1,
			PageSize:    20,
			PackageType: &packageType,
		}

		packages, total, err := svc.ListMyPackages(ctxWithShop, req)

		require.NoError(t, err)
		assert.Equal(t, int64(1), total)
		assert.Equal(t, 1, len(packages))
		assert.Equal(t, pkg2.ID, packages[0].ID)
	})

	t.Run("无效的系列ID返回空列表", func(t *testing.T) {
		invalidSeriesID := uint(99999)
		req := &dto.MyPackageListRequest{
			Page:     1,
			PageSize: 20,
			SeriesID: &invalidSeriesID,
		}

		packages, total, err := svc.ListMyPackages(ctxWithShop, req)

		require.NoError(t, err)
		assert.Equal(t, int64(0), total)
		assert.Equal(t, 0, len(packages))
	})
}

func TestService_GetMyPackage(t *testing.T) {
	tx := testutils.NewTestTransaction(t)
	ctx := context.Background()

	seriesAllocationStore := postgres.NewShopSeriesAllocationStore(tx)
	packageAllocationStore := postgres.NewShopPackageAllocationStore(tx)
	packageSeriesStore := postgres.NewPackageSeriesStore(tx)
	packageStore := postgres.NewPackageStore(tx)
	shopStore := postgres.NewShopStore(tx, nil)

	// 创建 Service
	svc := New(seriesAllocationStore, packageAllocationStore, packageSeriesStore, packageStore, shopStore)

	// 创建套餐系列
	series := &model.PackageSeries{
		SeriesCode: "DETAIL_SERIES",
		SeriesName: "详情系列",
		Status:     constants.StatusEnabled,
	}
	require.NoError(t, packageSeriesStore.Create(ctx, series))

	// 创建套餐
	pkg := &model.Package{
		PackageCode:          "DETAIL_PKG",
		PackageName:          "详情套餐",
		SeriesID:             series.ID,
		PackageType:          "formal",
		DurationMonths:       1,
		DataType:             "real",
		RealDataMB:           1024,
		DataAmountMB:         1024,
		Price:                9900,
		Status:               constants.StatusEnabled,
		ShelfStatus:          1,
		SuggestedCostPrice:   5000,
		SuggestedRetailPrice: 9900,
	}
	require.NoError(t, packageStore.Create(ctx, pkg))

	// 创建上级店铺
	allocatorShop := &model.Shop{
		ShopName:     "上级店铺详情",
		ShopCode:     "ALLOCATOR_DETAIL",
		Status:       constants.StatusEnabled,
		Level:        1,
		ContactName:  "联系人",
		ContactPhone: "13800000000",
	}
	require.NoError(t, shopStore.Create(ctx, allocatorShop))

	// 创建下级店铺
	shop := &model.Shop{
		ShopName:     "下级店铺详情",
		ShopCode:     "SHOP_DETAIL",
		Status:       constants.StatusEnabled,
		Level:        2,
		ParentID:     &allocatorShop.ID,
		ContactName:  "联系人",
		ContactPhone: "13800000001",
	}
	require.NoError(t, shopStore.Create(ctx, shop))

	// 创建系列分配
	seriesAllocation := &model.ShopSeriesAllocation{
		ShopID:          shop.ID,
		SeriesID:        series.ID,
		AllocatorShopID: allocatorShop.ID,
		PricingMode:     model.PricingModeFixed,
		PricingValue:    1000,
		Status:          constants.StatusEnabled,
	}
	require.NoError(t, seriesAllocationStore.Create(ctx, seriesAllocation))

	ctxWithShop := context.WithValue(ctx, constants.ContextKeyShopID, shop.ID)

	t.Run("店铺ID为0时返回错误", func(t *testing.T) {
		ctxWithoutShop := context.WithValue(ctx, constants.ContextKeyShopID, uint(0))
		_, err := svc.GetMyPackage(ctxWithoutShop, pkg.ID)
		require.Error(t, err)
		assert.Contains(t, err.Error(), "当前用户不属于任何店铺")
	})

	t.Run("成功获取套餐详情", func(t *testing.T) {
		detail, err := svc.GetMyPackage(ctxWithShop, pkg.ID)
		require.NoError(t, err)
		assert.NotNil(t, detail)
		assert.Equal(t, pkg.ID, detail.ID)
		assert.Equal(t, pkg.PackageName, detail.PackageName)
		assert.Equal(t, series.SeriesName, detail.SeriesName)
		// 验证成本价：5000 + 1000 = 6000
		assert.Equal(t, int64(6000), detail.CostPrice)
		assert.Equal(t, dto.PriceSourceSeriesPricing, detail.PriceSource)
	})

	t.Run("无权限访问套餐时返回错误", func(t *testing.T) {
		// 创建另一个没有系列分配的店铺
		otherShop := &model.Shop{
			ShopName:     "其他店铺",
			ShopCode:     "OTHER_SHOP",
			Status:       constants.StatusEnabled,
			Level:        1,
			ContactName:  "联系人",
			ContactPhone: "13800000002",
		}
		require.NoError(t, shopStore.Create(ctx, otherShop))

		ctxWithOtherShop := context.WithValue(ctx, constants.ContextKeyShopID, otherShop.ID)
		_, err := svc.GetMyPackage(ctxWithOtherShop, pkg.ID)
		require.Error(t, err)
		assert.Contains(t, err.Error(), "您没有该套餐的销售权限")
	})
}

func TestService_ListMySeriesAllocations(t *testing.T) {
	tx := testutils.NewTestTransaction(t)
	ctx := context.Background()

	seriesAllocationStore := postgres.NewShopSeriesAllocationStore(tx)
	packageAllocationStore := postgres.NewShopPackageAllocationStore(tx)
	packageSeriesStore := postgres.NewPackageSeriesStore(tx)
	packageStore := postgres.NewPackageStore(tx)
	shopStore := postgres.NewShopStore(tx, nil)

	// 创建 Service
	svc := New(seriesAllocationStore, packageAllocationStore, packageSeriesStore, packageStore, shopStore)

	t.Run("店铺ID为0时返回错误", func(t *testing.T) {
		ctxWithoutShop := context.WithValue(ctx, constants.ContextKeyShopID, uint(0))
		req := &dto.MySeriesAllocationListRequest{
			Page:     1,
			PageSize: 20,
		}
		_, _, err := svc.ListMySeriesAllocations(ctxWithoutShop, req)
		require.Error(t, err)
		assert.Contains(t, err.Error(), "当前用户不属于任何店铺")
	})

	t.Run("无系列分配时返回空列表", func(t *testing.T) {
		shop := &model.Shop{
			ShopName:     "分配测试店铺",
			ShopCode:     "ALLOC_SHOP",
			Status:       constants.StatusEnabled,
			Level:        1,
			ContactName:  "联系人",
			ContactPhone: "13800000000",
		}
		require.NoError(t, shopStore.Create(ctx, shop))

		ctxWithShop := context.WithValue(ctx, constants.ContextKeyShopID, shop.ID)
		req := &dto.MySeriesAllocationListRequest{
			Page:     1,
			PageSize: 20,
		}

		allocations, total, err := svc.ListMySeriesAllocations(ctxWithShop, req)

		require.NoError(t, err)
		assert.NotNil(t, allocations)
		assert.Equal(t, 0, len(allocations))
		assert.Equal(t, int64(0), total)
	})

	t.Run("成功列表系列分配", func(t *testing.T) {
		// 创建套餐系列
		series := &model.PackageSeries{
			SeriesCode: "ALLOC_SERIES",
			SeriesName: "分配系列",
			Status:     constants.StatusEnabled,
		}
		require.NoError(t, packageSeriesStore.Create(ctx, series))

		// 创建上级店铺
		allocatorShop := &model.Shop{
			ShopName:     "分配者店铺",
			ShopCode:     "ALLOCATOR_ALLOC",
			Status:       constants.StatusEnabled,
			Level:        1,
			ContactName:  "联系人",
			ContactPhone: "13800000000",
		}
		require.NoError(t, shopStore.Create(ctx, allocatorShop))

		// 创建下级店铺
		shop := &model.Shop{
			ShopName:     "被分配店铺",
			ShopCode:     "ALLOCATED_SHOP",
			Status:       constants.StatusEnabled,
			Level:        2,
			ParentID:     &allocatorShop.ID,
			ContactName:  "联系人",
			ContactPhone: "13800000001",
		}
		require.NoError(t, shopStore.Create(ctx, shop))

		// 创建系列分配
		seriesAllocation := &model.ShopSeriesAllocation{
			ShopID:          shop.ID,
			SeriesID:        series.ID,
			AllocatorShopID: allocatorShop.ID,
			PricingMode:     model.PricingModeFixed,
			PricingValue:    1000,
			Status:          constants.StatusEnabled,
		}
		require.NoError(t, seriesAllocationStore.Create(ctx, seriesAllocation))

		ctxWithShop := context.WithValue(ctx, constants.ContextKeyShopID, shop.ID)
		req := &dto.MySeriesAllocationListRequest{
			Page:     1,
			PageSize: 20,
		}

		allocations, total, err := svc.ListMySeriesAllocations(ctxWithShop, req)

		require.NoError(t, err)
		assert.NotNil(t, allocations)
		assert.Equal(t, 1, len(allocations))
		assert.Equal(t, int64(1), total)
		assert.Equal(t, series.SeriesName, allocations[0].SeriesName)
		assert.Equal(t, allocatorShop.ShopName, allocations[0].AllocatorShopName)
	})
}