package routes

import (
	"github.com/gofiber/fiber/v2"

	"github.com/break/junhong_cmp_fiber/internal/bootstrap"
	"github.com/break/junhong_cmp_fiber/internal/model/dto"
	"github.com/break/junhong_cmp_fiber/pkg/openapi"
)

// RegisterAdminRoutes 注册管理后台相关路由
func RegisterAdminRoutes(router fiber.Router, handlers *bootstrap.Handlers, middlewares *bootstrap.Middlewares, doc *openapi.Generator, basePath string) {
	if handlers.AdminAuth != nil {
		registerAdminAuthRoutes(router, handlers.AdminAuth, middlewares.AdminAuth, doc, basePath)
	}

	authGroup := router.Group("", middlewares.AdminAuth)

	if handlers.Account != nil {
		registerAccountRoutes(authGroup, handlers.Account, doc, basePath)
	}
	if handlers.Role != nil {
		registerRoleRoutes(authGroup, handlers.Role, doc, basePath)
	}
	if handlers.Permission != nil {
		registerPermissionRoutes(authGroup, handlers.Permission, doc, basePath)
	}
	if handlers.Shop != nil {
		registerShopRoutes(authGroup, handlers.Shop, doc, basePath)
	}
	if handlers.ShopAccount != nil {
		registerShopAccountRoutes(authGroup, handlers.ShopAccount, doc, basePath)
	}
	if handlers.ShopCommission != nil {
		registerShopCommissionRoutes(authGroup, handlers.ShopCommission, doc, basePath)
	}
	if handlers.CommissionWithdrawal != nil {
		registerCommissionWithdrawalRoutes(authGroup, handlers.CommissionWithdrawal, doc, basePath)
	}
	if handlers.CommissionWithdrawalSetting != nil {
		registerCommissionWithdrawalSettingRoutes(authGroup, handlers.CommissionWithdrawalSetting, doc, basePath)
	}
	if handlers.Enterprise != nil {
		registerEnterpriseRoutes(authGroup, handlers.Enterprise, doc, basePath)
	}
	if handlers.EnterpriseCard != nil {
		registerEnterpriseCardRoutes(authGroup, handlers.EnterpriseCard, doc, basePath)
	}
	if handlers.Authorization != nil {
		registerAuthorizationRoutes(authGroup, handlers.Authorization, doc, basePath)
	}
	if handlers.CustomerAccount != nil {
		registerCustomerAccountRoutes(authGroup, handlers.CustomerAccount, doc, basePath)
	}
	if handlers.MyCommission != nil {
		registerMyCommissionRoutes(authGroup, handlers.MyCommission, doc, basePath)
	}
	if handlers.IotCard != nil {
		registerIotCardRoutes(authGroup, handlers.IotCard, handlers.IotCardImport, doc, basePath)
	}
	if handlers.Device != nil {
		registerDeviceRoutes(authGroup, handlers.Device, handlers.DeviceImport, doc, basePath)
	}
	if handlers.AssetAllocationRecord != nil {
		registerAssetAllocationRecordRoutes(authGroup, handlers.AssetAllocationRecord, doc, basePath)
	}
	if handlers.Storage != nil {
		registerStorageRoutes(authGroup, handlers.Storage, doc, basePath)
	}
	if handlers.Carrier != nil {
		registerCarrierRoutes(authGroup, handlers.Carrier, doc, basePath)
	}
	if handlers.PackageSeries != nil {
		registerPackageSeriesRoutes(authGroup, handlers.PackageSeries, doc, basePath)
	}
	if handlers.Package != nil {
		registerPackageRoutes(authGroup, handlers.Package, doc, basePath)
	}
	if handlers.ShopSeriesAllocation != nil {
		registerShopSeriesAllocationRoutes(authGroup, handlers.ShopSeriesAllocation, doc, basePath)
	}
	if handlers.ShopPackageAllocation != nil {
		registerShopPackageAllocationRoutes(authGroup, handlers.ShopPackageAllocation, doc, basePath)
	}
	if handlers.ShopPackageBatchAllocation != nil {
		registerShopPackageBatchAllocationRoutes(authGroup, handlers.ShopPackageBatchAllocation, doc, basePath)
	}
	if handlers.ShopPackageBatchPricing != nil {
		registerShopPackageBatchPricingRoutes(authGroup, handlers.ShopPackageBatchPricing, doc, basePath)
	}
	if handlers.AdminOrder != nil {
		registerAdminOrderRoutes(authGroup, handlers.AdminOrder, doc, basePath)
	}
}

func registerAdminAuthRoutes(router fiber.Router, handler interface{}, authMiddleware fiber.Handler, doc *openapi.Generator, basePath string) {
	h := handler.(interface {
		Login(c *fiber.Ctx) error
		Logout(c *fiber.Ctx) error
		RefreshToken(c *fiber.Ctx) error
		GetMe(c *fiber.Ctx) error
		ChangePassword(c *fiber.Ctx) error
	})

	Register(router, doc, basePath, "POST", "/login", h.Login, RouteSpec{
		Summary: "后台登录",
		Tags:    []string{"认证"},
		Input:   new(dto.LoginRequest),
		Output:  new(dto.LoginResponse),
		Auth:    false,
	})

	Register(router, doc, basePath, "POST", "/refresh-token", h.RefreshToken, RouteSpec{
		Summary: "刷新 Token",
		Tags:    []string{"认证"},
		Input:   new(dto.RefreshTokenRequest),
		Output:  new(dto.RefreshTokenResponse),
		Auth:    false,
	})

	authGroup := router.Group("", authMiddleware)

	Register(authGroup, doc, basePath, "POST", "/logout", h.Logout, RouteSpec{
		Summary: "登出",
		Tags:    []string{"认证"},
		Input:   nil,
		Output:  nil,
		Auth:    true,
	})

	Register(authGroup, doc, basePath, "GET", "/me", h.GetMe, RouteSpec{
		Summary: "获取当前用户信息",
		Tags:    []string{"认证"},
		Input:   nil,
		Output:  new(dto.UserInfo),
		Auth:    true,
	})

	Register(authGroup, doc, basePath, "PUT", "/password", h.ChangePassword, RouteSpec{
		Summary: "修改密码",
		Tags:    []string{"认证"},
		Input:   new(dto.ChangePasswordRequest),
		Output:  nil,
		Auth:    true,
	})
}