package routers

import (
	"fmt"

	"git.apinb.com/bsm-sdk/core/middleware"
	"git.apinb.com/heqiapp/platforms/backend/api/internal/logic/common"
	"git.apinb.com/heqiapp/platforms/backend/api/internal/logic/platform"
	"git.apinb.com/heqiapp/platforms/backend/api/internal/models"
	"github.com/gin-gonic/gin"
)

// RegisterPlatform 注册 /heqi/platform/v1 前缀下的平台总后台路由。
func RegisterPlatform(serviceKey string, engine *gin.Engine) {
	basePath := fmt.Sprintf("/%s/platform/v1", serviceKey)
	anonymous := engine.Group(basePath)
	anonymous.GET("/ping/hello", platform.PingHello)
	anonymous.POST("/auth/login", platform.Login)

	protected := engine.Group(basePath)
	protected.Use(middleware.JwtAuth(true))
	protected.Use(platform.RequirePlatformMenuAccess())
	protected.GET("/auth/profile", platform.CurrentProfile)
	protected.PUT("/auth/password", platform.ChangePassword)
	protected.GET("/dashboard/overview", platform.DashboardOverview)

	registerGasRoute(protected)
	registerDeliveryRoute(protected)
	registerGasorderRoute(protected)
	registerStaffRoute(protected)
	registerUserRoute(protected)
	registerProductRoute(protected)
	registerWalletRoute(protected)
	registerCommerceRoute(protected)
	registerFinanceRoute(protected)
	registerContentRoute(protected)
	registerPlatformRoute(protected)
}

func registerGasRoute(group *gin.RouterGroup) {
	registerWritableResource(group, "/gas_basic", platform.ListGasBasic, platform.CreateGasBasic, platform.GetGasBasic, platform.UpdateGasBasic, &models.GasBasic{})
	registerWritableResource(group, "/gas_account", platform.ListGasAccount, platform.CreateGasAccount, platform.GetGasAccount, platform.UpdateGasAccount, &models.GasAccount{})
}

func registerDeliveryRoute(group *gin.RouterGroup) {
	registerWritableResource(group, "/delivery_basic", platform.ListDeliveryBasic, platform.CreateDeliveryBasic, platform.GetDeliveryBasic, platform.UpdateDeliveryBasic, &models.DeliveryBasic{})
	registerWritableResource(group, "/delivery_account", platform.ListDeliveryAccount, platform.CreateDeliveryAccount, platform.GetDeliveryAccount, platform.UpdateDeliveryAccount, &models.DeliveryAccount{})
}

func registerGasorderRoute(group *gin.RouterGroup) {
	contract := group.Group("/gasorder_contract")
	contract.GET("", platform.ListGasorderContract)
	contract.POST("", platform.CreateGasorderContract)
	contract.GET("/:identity", platform.GetGasorderContract)
	contract.PUT("/:identity", platform.UpdateGasorderContract)
	contract.POST("/:identity/activate", platform.ActivateGasorderContract)
	contract.POST("/:identity/renew", platform.RenewGasorderContract)
	contract.POST("/:identity/terminate", platform.TerminateGasorderContract)

	contractProduct := group.Group("/gasorder_contract_product")
	contractProduct.GET("", platform.ListGasorderContractProduct)
	contractProduct.POST("", platform.BindGasorderContractProduct)
	contractProduct.GET("/:identity", platform.GetGasorderContractProduct)
	contractProduct.POST("/:identity/unbind", platform.UnbindGasorderContractProduct)
	registerReadOnlyHandlers(group, "/gasorder_contract_revision", platform.ListGasorderContractRevision, platform.GetGasorderContractRevision)

	order := group.Group("/gasorder_basic")
	order.GET("", platform.ListGasorderBasic)
	order.POST("", platform.CreateGasorderBasic)
	order.GET("/:identity", platform.GetGasorderBasic)
	order.POST("/:identity/assign", platform.AssignGasorderBasic)
	order.POST("/:identity/filling", platform.GasorderStartFilling)
	order.POST("/:identity/ready", platform.GasorderReady)
	order.POST("/:identity/exception", platform.GasorderException)
	order.POST("/:identity/recover", platform.GasorderRecover)
	order.POST("/:identity/cancel", platform.GasorderCancel)

	registerReadOnlyHandlers(group, "/gasorder_item", platform.ListGasorderItem, platform.GetGasorderItem)
	registerReadOnlyHandlers(group, "/gasorder_assign", platform.ListGasorderAssign, platform.GetGasorderAssign)
	registerReadOnlyHandlers(group, "/gasorder_status", platform.ListGasorderStatus, platform.GetGasorderStatus)
	registerReadOnlyHandlers(group, "/gasorder_track", platform.ListGasorderTrack, platform.GetGasorderTrack)
	registerReadOnlyHandlers(group, "/gasorder_track_point", platform.ListGasorderTrackPoint, platform.GetGasorderTrackPoint)
	registerReadOnlyHandlers(group, "/gasorder_confirm", platform.ListGasorderConfirm, platform.GetGasorderConfirm)
	registerReadOnlyHandlers(group, "/gasorder_payment", platform.ListGasorderPayment, platform.GetGasorderPayment)
}

func registerProductRoute(group *gin.RouterGroup) {
	registerRestrictedNoDeleteResource(group, "/product_type", &models.ProductType{}, []string{"code", "name"})
	registerRestrictedNoDeleteResource(group, "/product_warehouse", &models.ProductWarehouse{}, []string{"code", "name", "address", "manager", "phone", "is_enabled"})

	infoRelations := []common.ResourceRelation{
		requiredRelation("product_type_identity", "product_type_id", &models.ProductType{}),
		optionalRelation("warehouse_identity", "warehouse_id", &models.ProductWarehouse{}),
		optionalRelation("gas_basic_identity", "gas_basic_id", &models.GasBasic{}),
		optionalRelation("delivery_basic_identity", "delivery_basic_id", &models.DeliveryBasic{}),
		optionalRelation("user_account_identity", "user_account_id", &models.UserAccount{}),
	}
	infoList, infoCreate, infoGet, infoUpdate := platform.ProductInfoHandlers(infoRelations...)
	info := group.Group("/product_info")
	info.GET("", infoList)
	info.POST("", infoCreate)
	info.GET("/:identity", infoGet)
	info.PUT("/:identity", infoUpdate)
	info.PATCH("/:identity/status", platform.UpdateProductInfoStatus)

	repairList, repairCreate, repairGet, repairUpdate := platform.ProductRepairHandlers(
		requiredRelation("product_info_identity", "product_info_id", &models.ProductInfo{}),
	)
	registerNoDeleteResource(group, "/product_repair", repairList, repairCreate, repairGet, repairUpdate, &models.ProductRepair{})

	ownerList, ownerCreate, ownerGet := platform.ProductOwnerHandlers(
		requiredRelation("product_info_identity", "product_info_id", &models.ProductInfo{}),
		optionalRelation("warehouse_identity", "warehouse_id", &models.ProductWarehouse{}),
		optionalRelation("gas_basic_identity", "gas_basic_id", &models.GasBasic{}),
		optionalRelation("delivery_basic_identity", "delivery_basic_id", &models.DeliveryBasic{}),
		optionalRelation("user_account_identity", "user_account_id", &models.UserAccount{}),
	)
	owner := group.Group("/product_owner")
	owner.GET("", ownerList)
	owner.POST("", ownerCreate)
	owner.GET("/:identity", ownerGet)
}

func registerWalletRoute(group *gin.RouterGroup) {
	basic := group.Group("/wallet_basic")
	basic.GET("", platform.ListWalletBasic)
	basic.GET("/:identity", platform.GetWalletBasic)
	basic.PATCH("/:identity/status", platform.UpdateWalletBasicStatus)
	basic.POST("/:identity/recharge", platform.RechargeWalletBasic)
	basic.GET("/owner/:owner_type/:owner_identity", platform.GetOrCreateOwnerWallet)

	bank := group.Group("/wallet_bank")
	bank.GET("", platform.ListWalletBank)
	bank.GET("/:identity", platform.GetWalletBank)

	payment := group.Group("/wallet_payment")
	payment.GET("", platform.ListWalletPayment)
	payment.GET("/:identity", platform.GetWalletPayment)

	record := group.Group("/wallet_record")
	record.GET("", platform.ListWalletRecord)
	record.GET("/:identity", platform.GetWalletRecord)

	refund := group.Group("/wallet_refund")
	refund.GET("", platform.ListWalletRefund)
	refund.GET("/:identity", platform.GetWalletRefund)

	applyCash := group.Group("/wallet_apply_cash")
	applyCash.GET("", platform.ListWalletApplyCash)
	applyCash.GET("/:identity", platform.GetWalletApplyCash)
	applyCash.POST("/:identity/approve", platform.ApproveWalletApplyCash)
	applyCash.POST("/:identity/reject", platform.RejectWalletApplyCash)
}

func registerCommerceRoute(group *gin.RouterGroup) {
	categoryRelations := []common.ResourceRelation{optionalRelation("parent_identity", "parent_id", &models.EcCategory{})}
	_, categoryCreate, _, categoryUpdate := common.ResourceHandlers(&models.EcCategory{}, []string{"name", "sort_no"}, []string{"name", "sort_no"}, categoryRelations...)
	registerWritableResource(group, "/ec_category", platform.ListEcCategory, categoryCreate, platform.GetEcCategory, categoryUpdate, &models.EcCategory{})
	registerRestrictedWritableResource(group, "/ec_product", &models.EcProduct{}, []string{"product_code", "name", "price_amount", "stock_quantity"}, requiredRelation("ec_category_identity", "ec_category_id", &models.EcCategory{}))
	registerRestrictedWritableResource(group, "/ec_product_attribute", &models.EcProductAttribute{}, []string{"name", "value", "sort_no"}, requiredRelation("ec_product_identity", "ec_product_id", &models.EcProduct{}))
	registerRestrictedWritableResource(group, "/ec_product_image", &models.EcProductImage{}, []string{"image_uri", "sort_no", "is_cover"}, requiredRelation("ec_product_identity", "ec_product_id", &models.EcProduct{}))
	registerRestrictedWritableResource(group, "/ec_cart", &models.EcCart{}, []string{"quantity", "selected"}, requiredRelation("user_account_identity", "user_account_id", &models.UserAccount{}), requiredRelation("ec_product_identity", "ec_product_id", &models.EcProduct{}))
	orderRelations := []common.ResourceRelation{requiredRelation("user_account_identity", "user_account_id", &models.UserAccount{}), optionalRelation("gas_basic_identity", "gas_station_id", &models.GasBasic{}), optionalRelation("delivery_basic_identity", "delivery_point_id", &models.DeliveryBasic{})}
	list, create, _, update := common.ResourceHandlers(&models.EcOrder{}, []string{"order_no", "total_amount"}, []string{"total_amount"}, orderRelations...)
	registerWritableResource(group, "/ec_order", list, create, platform.GetEcOrder, update, &models.EcOrder{})
	registerRestrictedWritableResource(group, "/ec_order_item", &models.EcOrderItem{}, []string{"product_snapshot", "quantity", "sale_amount"}, requiredRelation("ec_order_identity", "ec_order_id", &models.EcOrder{}), requiredRelation("ec_product_identity", "ec_product_id", &models.EcProduct{}))
	registerRestrictedWritableResource(group, "/ec_review", &models.EcReview{}, []string{"score", "content"}, requiredRelation("ec_order_identity", "ec_order_id", &models.EcOrder{}), requiredRelation("ec_product_identity", "ec_product_id", &models.EcProduct{}), requiredRelation("user_account_identity", "user_account_id", &models.UserAccount{}))
}

func registerStaffRoute(group *gin.RouterGroup) {
	registerWritableResource(group, "/staff_account", platform.ListStaff, platform.CreateStaff, platform.GetStaff, platform.UpdateStaff, &models.StaffAccount{})
	registerWritableResource(group, "/staff_credential", platform.ListStaffCredential, platform.CreateStaffCredential, platform.GetStaffCredential, platform.UpdateStaffCredential, &models.StaffCredential{})
}

func registerUserRoute(group *gin.RouterGroup) {
	registerWritableResource(group, "/user_account", platform.ListUser, platform.CreateUser, platform.GetUser, platform.UpdateUser, &models.UserAccount{})
	registerWritableResource(group, "/user_address", platform.ListUserAddress, platform.CreateUserAddress, platform.GetUserAddress, platform.UpdateUserAddress, &models.UserAddress{})
	registerWritableResource(group, "/user_service_relation", platform.ListUserServiceRelation, platform.CreateUserServiceRelation, platform.GetUserServiceRelation, platform.UpdateUserServiceRelation, &models.UserServiceRelation{})
}

func registerPlatformRoute(group *gin.RouterGroup) {
	registerWritableResource(group, "/platfrom_account", platform.ListPlatfromAccount, platform.CreatePlatfromAccount, platform.GetPlatfromAccount, platform.UpdatePlatfromAccount, &models.PlatfromAccount{})
	role := group.Group("/platform_role")
	role.GET("", platform.ListPlatformRole)
	role.POST("", platform.CreatePlatformRole)
	role.GET("/:identity", platform.GetPlatformRole)
	role.PUT("/:identity", platform.UpdatePlatformRole)
	role.PATCH("/:identity/status", platform.UpdatePlatformRoleStatus)
	role.DELETE("/:identity", platform.ArchivePlatformRole)
	role.GET("/:identity/menu", platform.ListPlatformRoleMenuIdentities)
	role.PUT("/:identity/menu", platform.ReplacePlatformRoleMenus)
	role.PUT("/:identity/menus", platform.ReplacePlatformRoleMenus)
	menu := group.Group("/platform_menu")
	menu.GET("", platform.ListPlatformMenu)
	menu.POST("", platform.CreatePlatformMenu)
	menu.GET("/:identity", platform.GetPlatformMenu)
	menu.PUT("/:identity", platform.UpdatePlatformMenu)
	menu.PATCH("/:identity/status", platform.UpdatePlatformMenuStatus)
	menu.DELETE("/:identity", platform.ArchivePlatformMenu)
}

func registerFinanceRoute(group *gin.RouterGroup) {
	registerRestrictedWritableResource(group, "/fin_payment", &models.FinPayment{}, []string{"channel", "amount", "paid_at"}, requiredRelation("ec_order_identity", "ec_order_id", &models.EcOrder{}))
	settlementList, settlementCreate, settlementGet, settlementUpdate := platform.FinSettlementHandlers()
	registerWritableResource(group, "/fin_settlement", settlementList, settlementCreate, settlementGet, settlementUpdate, &models.FinSettlement{})
	registerRestrictedWritableResource(group, "/fin_reconciliation", &models.FinReconciliation{}, []string{"channel", "bill_date", "difference_amount"})

}

func registerContentRoute(group *gin.RouterGroup) {
	registerRestrictedWritableResource(group, "/cms_content", &models.CmsContent{}, []string{"content_type", "title", "body", "version_no", "publish_status"})
	registerRestrictedWritableResource(group, "/cs_ticket", &models.CsTicket{}, []string{"ticket_no", "category", "priority"}, requiredRelation("user_account_identity", "user_account_id", &models.UserAccount{}))
}

func registerWritableResource(group *gin.RouterGroup, path string, list, create, get, update gin.HandlerFunc, model any) {
	resource := group.Group(path)
	resource.GET("", list)
	resource.POST("", create)
	resource.GET("/:identity", get)
	resource.PUT("/:identity", update)
	resource.PATCH("/:identity/status", func(ctx *gin.Context) { common.UpdateRecordStatus(ctx, model) })
	resource.DELETE("/:identity", func(ctx *gin.Context) { common.ArchiveRecord(ctx, model) })
}

func registerRestrictedWritableResource(group *gin.RouterGroup, path string, model any, fields []string, relations ...common.ResourceRelation) {
	list, create, get, update := common.ResourceHandlers(model, fields, fields, relations...)
	registerWritableResource(group, path, list, create, get, update, model)
}

func registerNoDeleteResource(group *gin.RouterGroup, path string, list, create, get, update gin.HandlerFunc, model any) {
	resource := group.Group(path)
	resource.GET("", list)
	resource.POST("", create)
	resource.GET("/:identity", get)
	resource.PUT("/:identity", update)
	resource.PATCH("/:identity/status", func(ctx *gin.Context) { common.UpdateRecordStatus(ctx, model) })
}

func registerRestrictedNoDeleteResource(group *gin.RouterGroup, path string, model any, fields []string, relations ...common.ResourceRelation) {
	list, create, get, update := common.ResourceHandlers(model, fields, fields, relations...)
	registerNoDeleteResource(group, path, list, create, get, update, model)
}

func registerReadOnlyResource(group *gin.RouterGroup, path string, model any) {
	list, _, get, _ := common.ResourceHandlers(model, nil, nil)
	resource := group.Group(path)
	resource.GET("", list)
	resource.GET("/:identity", get)
}

func registerReadOnlyHandlers(group *gin.RouterGroup, path string, list, get gin.HandlerFunc) {
	resource := group.Group(path)
	resource.GET("", list)
	resource.GET("/:identity", get)
}

func requiredRelation(input, column string, model any) common.ResourceRelation {
	return common.ResourceRelation{Input: input, Column: column, Model: model, Required: true}
}

func optionalRelation(input, column string, model any) common.ResourceRelation {
	return common.ResourceRelation{Input: input, Column: column, Model: model}
}