package service

import (
	"encoding/json"
	"errors"
	"math"
	"regexp"
	"sort"
	"strings"
	"time"

	"infinite-canvas/backend/internal/model"
	"infinite-canvas/backend/internal/repository"

	"gorm.io/gorm"
)

var logicalModelCodePattern = regexp.MustCompile(`^[a-z0-9][a-z0-9._-]{1,79}$`)

type LogicalModelRequest struct {
	Code                    string                `json:"code"`
	Name                    string                `json:"name"`
	Icon                    string                `json:"icon"`
	Description             string                `json:"description"`
	Capability              string                `json:"capability"`
	Enabled                 bool                  `json:"enabled"`
	SortOrder               int                   `json:"sortOrder"`
	PricePolicy             string                `json:"pricePolicy"`
	BillingMode             string                `json:"billingMode"`
	UnitPriceMicrocredits   int64                 `json:"unitPriceMicrocredits"`
	InputPriceMicrocredits  int64                 `json:"inputPriceMicrocredits"`
	OutputPriceMicrocredits int64                 `json:"outputPriceMicrocredits"`
	CachedPriceMicrocredits int64                 `json:"cachedPriceMicrocredits"`
	CapabilitySpec          CapabilitySpec        `json:"capabilitySpec"`
	DefaultOptions          map[string]any        `json:"defaultOptions"`
	Routes                  []LogicalRouteRequest `json:"routes"`
}

type LogicalRouteRequest struct {
	PhysicalVariantID string `json:"physicalVariantId"`
	Enabled           bool   `json:"enabled"`
	Priority          int    `json:"priority"`
	Weight            int    `json:"weight"`
}

type PhysicalVariantRequest struct {
	ChannelModelID string         `json:"channelModelId"`
	Name           string         `json:"name"`
	Enabled        bool           `json:"enabled"`
	CapabilitySpec CapabilitySpec `json:"capabilitySpec"`
}

type PublicLogicalModel struct {
	ID                      string         `json:"id"`
	Code                    string         `json:"code"`
	Name                    string         `json:"name"`
	Icon                    string         `json:"icon"`
	Description             string         `json:"description"`
	Capability              string         `json:"capability"`
	SortOrder               int            `json:"sortOrder"`
	PricePolicy             string         `json:"pricePolicy"`
	BillingMode             string         `json:"billingMode"`
	UnitPriceMicrocredits   int64          `json:"unitPriceMicrocredits"`
	InputPriceMicrocredits  int64          `json:"inputPriceMicrocredits"`
	OutputPriceMicrocredits int64          `json:"outputPriceMicrocredits"`
	CachedPriceMicrocredits int64          `json:"cachedPriceMicrocredits"`
	CapabilitySpec          CapabilitySpec `json:"capabilitySpec"`
	// CapabilityProfiles 是创作端可见的匿名能力组合，不暴露其背后的供应线路关系。
	CapabilityProfiles []CapabilitySpec `json:"capabilityProfiles"`
	DefaultOptions     map[string]any   `json:"defaultOptions"`
	Available          bool             `json:"available"`
}

type AdminLogicalRoute struct {
	ID                    string `json:"id"`
	PhysicalVariantID     string `json:"physicalVariantId"`
	PhysicalVariantName   string `json:"physicalVariantName"`
	ChannelModelID        string `json:"channelModelId"`
	ChannelID             string `json:"channelId"`
	PhysicalModelKey      string `json:"physicalModelKey"`
	PhysicalModelName     string `json:"physicalModelName"`
	Enabled               bool   `json:"enabled"`
	Priority              int    `json:"priority"`
	Weight                int    `json:"weight"`
	Available             bool   `json:"available"`
	structurallyAvailable bool
	CapabilitySpec        CapabilitySpec `json:"capabilitySpec"`
}

type AdminLogicalModel struct {
	PublicLogicalModel
	Enabled            bool                `json:"enabled"`
	ActiveRevisionID   string              `json:"activeRevisionId"`
	RevisionVersion    int                 `json:"revisionVersion"`
	ConfigurationError string              `json:"configurationError,omitempty"`
	AvailabilityError  string              `json:"availabilityError,omitempty"`
	Routes             []AdminLogicalRoute `json:"routes"`
}

type AdminPhysicalVariant struct {
	ID             string         `json:"id"`
	ChannelModelID string         `json:"channelModelId"`
	ChannelID      string         `json:"channelId"`
	ModelKey       string         `json:"modelKey"`
	ModelName      string         `json:"modelName"`
	Name           string         `json:"name"`
	Capability     string         `json:"capability"`
	Protocol       string         `json:"protocol"`
	Enabled        bool           `json:"enabled"`
	ModelEnabled   bool           `json:"modelEnabled"`
	UsageCount     int64          `json:"usageCount"`
	CapabilitySpec CapabilitySpec `json:"capabilitySpec"`
}

type RouteSimulationCandidate struct {
	RouteID        string   `json:"routeId"`
	VariantID      string   `json:"variantId"`
	ChannelModelID string   `json:"channelModelId"`
	Priority       int      `json:"priority"`
	Weight         int      `json:"weight"`
	Enabled        bool     `json:"enabled"`
	Matched        bool     `json:"matched"`
	Blocked        bool     `json:"blocked"`
	InPool         bool     `json:"inPool"`
	Reasons        []string `json:"reasons,omitempty"`
}

type RouteSimulationResult struct {
	ProductMatch CapabilityMatch            `json:"productMatch"`
	Candidates   []RouteSimulationCandidate `json:"candidates"`
}

func (s *Service) PublicLogicalModels(intent *ModelRequestIntent) ([]PublicLogicalModel, error) {
	snapshot, err := s.routeCatalogSnapshot()
	if err != nil {
		return nil, err
	}
	result := make([]PublicLogicalModel, 0, len(snapshot.Ordered))
	for _, id := range snapshot.Ordered {
		cached := snapshot.Models[id]
		structuralSpecs := availableCachedRouteSpecs(cached.Routes)
		coverageValid := logicalModelCapabilityCovered(cached.ProductSpec, structuralSpecs)
		available := coverageValid && hasHealthyCachedRoute(s, cached.Routes)
		if intent != nil {
			resolvedIntent := *intent
			resolvedIntent.Options = mergeIntentDefaults(intent.Options, cached.Defaults)
			productMatch := MatchCapability(cached.ProductSpec, resolvedIntent)
			if !productMatch.Matched {
				continue
			}
			available = false
			if coverageValid {
				for _, route := range cached.Routes {
					if route.Route.Enabled && route.Route.Weight > 0 && !s.logicalRouteBlocked(route) && MatchCapability(route.VariantSpec, resolvedIntent).Matched {
						available = true
						break
					}
				}
			}
		}
		result = append(result, publicLogicalModel(cached, available))
	}
	return result, nil
}

func publicLogicalModel(cached cachedLogicalModel, available bool) PublicLogicalModel {
	item := cached.Model
	routeSpecs := make([]CapabilitySpec, 0, len(cached.Routes))
	for _, route := range cached.Routes {
		routeSpecs = append(routeSpecs, route.VariantSpec)
	}
	productSpec := capabilitySpecWithRoutePresets(cached.ProductSpec, routeSpecs)
	variants := make([]CapabilitySpec, 0, len(cached.Routes))
	seen := make(map[string]bool, len(cached.Routes))
	for _, route := range cached.Routes {
		if !route.Route.Enabled || route.Route.Weight <= 0 {
			continue
		}
		key := capabilityFingerprint(route.VariantSpec)
		if !seen[key] {
			seen[key] = true
			variants = append(variants, route.VariantSpec)
		}
	}
	return PublicLogicalModel{ID: item.ID, Code: item.Code, Name: item.Name, Icon: item.Icon, Description: item.Description, Capability: item.Capability, SortOrder: item.SortOrder, PricePolicy: item.PricePolicy, BillingMode: item.BillingMode, UnitPriceMicrocredits: item.UnitPriceMicrocredits, InputPriceMicrocredits: item.InputPriceMicrocredits, OutputPriceMicrocredits: item.OutputPriceMicrocredits, CachedPriceMicrocredits: item.CachedPriceMicrocredits, CapabilitySpec: productSpec, CapabilityProfiles: variants, DefaultOptions: cached.Defaults, Available: available}
}

// capabilitySpecWithRoutePresets repairs old front-model snapshots that stored
// only `*` for a custom size. The wildcard remains for matching custom values,
// while route presets are restored for admin and creator-side selectors.
func capabilitySpecWithRoutePresets(spec CapabilitySpec, routes []CapabilitySpec) CapabilitySpec {
	result := spec
	result.Options = make(map[string]OptionConstraint, len(spec.Options))
	for name, constraint := range spec.Options {
		if !isWildcardOptionConstraint(constraint) {
			result.Options[name] = constraint
			continue
		}
		values := append([]any(nil), constraint.Values...)
		seen := make(map[string]bool, len(values))
		for _, value := range values {
			seen[normalizedScalar(value)] = true
		}
		for _, route := range routes {
			for _, value := range route.Options[name].Values {
				key := normalizedScalar(value)
				if key != "" && !seen[key] {
					seen[key] = true
					values = append(values, value)
				}
			}
		}
		result.Options[name] = OptionConstraint{Values: values}
	}
	return result
}

// capabilityFingerprint 用规范化后的结构去重能力画像；不能直接依赖原始 JSON，
// 因为同一组枚举能力的数组顺序不应造成重复展示。
func capabilityFingerprint(spec CapabilitySpec) string {
	copySpec := spec
	copySpec.Operations = append([]string(nil), spec.Operations...)
	sort.Strings(copySpec.Operations)
	copySpec.Inputs = make(map[string]InputConstraint, len(spec.Inputs))
	for name, constraint := range spec.Inputs {
		copySpec.Inputs[name] = constraint
	}
	copySpec.Options = make(map[string]OptionConstraint, len(spec.Options))
	for name, constraint := range spec.Options {
		values := append([]any(nil), constraint.Values...)
		sort.SliceStable(values, func(i, j int) bool { return normalizedScalar(values[i]) < normalizedScalar(values[j]) })
		constraint.Values = values
		copySpec.Options[name] = constraint
	}
	encoded, _ := json.Marshal(copySpec)
	return string(encoded)
}

func (s *Service) AdminLogicalModels(actor *model.User) ([]AdminLogicalModel, error) {
	if err := s.RequireAdmin(actor); err != nil {
		return nil, err
	}
	items, err := s.repo.LogicalModels(true)
	if err != nil {
		return nil, err
	}
	graphs, err := s.repo.LogicalModelGraphs(items, true)
	if err != nil {
		return nil, err
	}
	systemChannelIDs := make([]string, 0)
	for _, graph := range graphs {
		if graph == nil {
			continue
		}
		for _, channelModel := range graph.ChannelModels {
			systemChannelIDs = append(systemChannelIDs, channelModel.ChannelID)
		}
	}
	systemChannels, err := s.repo.SystemChannelsByIDs(systemChannelIDs, true)
	if err != nil {
		return nil, err
	}
	systemChannelByID := make(map[string]model.ModelChannel, len(systemChannels))
	for _, channel := range systemChannels {
		systemChannelByID[channel.ID] = channel
	}
	result := make([]AdminLogicalModel, 0, len(items))
	for _, item := range items {
		graph := graphs[item.ID]
		if graph == nil || graph.Revision == nil {
			continue
		}
		admin, buildErr := s.buildAdminLogicalModel(item, graph, systemChannelByID)
		if buildErr != nil {
			continue
		}
		result = append(result, *admin)
	}
	return result, nil
}

func (s *Service) buildAdminLogicalModel(item model.LogicalModel, graph *repository.LogicalModelGraph, systemChannelByID map[string]model.ModelChannel) (*AdminLogicalModel, error) {
	productSpec, err := DecodeCapabilitySpec(graph.Revision.CapabilitySpecJSON)
	if err != nil {
		return nil, err
	}
	variantByID := make(map[string]model.PhysicalCapabilityVariant, len(graph.Variants))
	for _, variant := range graph.Variants {
		variantByID[variant.ID] = variant
	}
	channelModelByID := make(map[string]model.ChannelModel, len(graph.ChannelModels))
	for _, channelModel := range graph.ChannelModels {
		channelModelByID[channelModel.ID] = channelModel
	}
	admin := AdminLogicalModel{PublicLogicalModel: publicLogicalModel(cachedLogicalModel{Model: item, ProductSpec: productSpec, Defaults: map[string]any{}}, false), Enabled: item.Enabled, ActiveRevisionID: graph.Revision.ID, RevisionVersion: graph.Revision.Version, Routes: []AdminLogicalRoute{}}
	for _, route := range graph.Routes {
		variant, variantOK := variantByID[route.PhysicalVariantID]
		if !variantOK {
			continue
		}
		channelModel, channelOK := channelModelByID[variant.ChannelModelID]
		if !channelOK {
			continue
		}
		variantSpec, specErr := effectivePhysicalVariantSpec(variant, channelModel)
		if specErr != nil {
			continue
		}
		_, channelOK = systemChannelByID[channelModel.ChannelID]
		structurallyAvailable := route.Enabled && route.Weight > 0 && variant.Enabled && channelModel.Enabled && channelOK
		available := structurallyAvailable && (item.PricePolicy != "channel" || channelModel.PriceConfigured)
		admin.Routes = append(admin.Routes, AdminLogicalRoute{ID: route.ID, PhysicalVariantID: variant.ID, PhysicalVariantName: variant.Name, ChannelModelID: channelModel.ID, ChannelID: channelModel.ChannelID, PhysicalModelKey: channelModel.ModelKey, PhysicalModelName: channelModel.DisplayName, Enabled: route.Enabled, Priority: route.Priority, Weight: route.Weight, Available: available, structurallyAvailable: structurallyAvailable, CapabilitySpec: variantSpec})
	}
	routeSpecs := make([]CapabilitySpec, 0, len(admin.Routes))
	for _, route := range admin.Routes {
		routeSpecs = append(routeSpecs, route.CapabilitySpec)
	}
	productSpec = capabilitySpecWithRoutePresets(productSpec, routeSpecs)
	defaults, err := decodeLogicalDefaults(graph.Revision.DefaultOptionsJSON, productSpec)
	if err != nil {
		return nil, err
	}
	admin.PublicLogicalModel = publicLogicalModel(cachedLogicalModel{Model: item, ProductSpec: productSpec, Defaults: defaults}, false)
	// publicLogicalModel above has no route list; admin routes are already attached
	// and the enriched product spec is the source used by the editor.
	admin.CapabilitySpec = productSpec
	admin.DefaultOptions = defaults
	structuralRouteSpecs := structuralAdminRouteSpecs(admin.Routes)
	settlementRouteSpecs := settlementReadyAdminRouteSpecs(admin.Routes)
	admin.ConfigurationError = logicalModelConfigurationError(productSpec, structuralRouteSpecs)
	admin.AvailabilityError = logicalModelAvailabilityError(item.PricePolicy, productSpec, structuralRouteSpecs, settlementRouteSpecs)
	admin.Available = len(settlementRouteSpecs) > 0 && admin.ConfigurationError == "" && admin.AvailabilityError == ""
	return &admin, nil
}

func countAvailableAdminRoutes(routes []AdminLogicalRoute) int {
	count := 0
	for _, route := range routes {
		if route.Available {
			count++
		}
	}
	return count
}

func structuralAdminRouteSpecs(routes []AdminLogicalRoute) []CapabilitySpec {
	result := make([]CapabilitySpec, 0, len(routes))
	for _, route := range routes {
		if route.structurallyAvailable {
			result = append(result, route.CapabilitySpec)
		}
	}
	return result
}

func settlementReadyAdminRouteSpecs(routes []AdminLogicalRoute) []CapabilitySpec {
	result := make([]CapabilitySpec, 0, countAvailableAdminRoutes(routes))
	for _, route := range routes {
		if route.Available {
			result = append(result, route.CapabilitySpec)
		}
	}
	return result
}

func availableCachedRouteSpecs(routes []cachedLogicalRoute) []CapabilitySpec {
	result := make([]CapabilitySpec, 0, len(routes))
	for _, route := range routes {
		if route.Route.Enabled && route.Route.Weight > 0 {
			result = append(result, route.VariantSpec)
		}
	}
	return result
}

func hasHealthyCachedRoute(s *Service, routes []cachedLogicalRoute) bool {
	for _, route := range routes {
		if route.Route.Enabled && route.Route.Weight > 0 && !s.logicalRouteBlocked(route) {
			return true
		}
	}
	return false
}

func logicalModelCapabilityCovered(product CapabilitySpec, routeSpecs []CapabilitySpec) bool {
	return len(routeSpecs) > 0 && validateProductSpecWithinRoutes(product, routeSpecs) == nil
}

func logicalModelConfigurationError(product CapabilitySpec, routeSpecs []CapabilitySpec) string {
	if len(routeSpecs) == 0 || logicalModelCapabilityCovered(product, routeSpecs) {
		return ""
	}
	return "供应线路已无法完整覆盖创作端能力，请调整线路或能力范围"
}

func logicalModelAvailabilityError(pricePolicy string, product CapabilitySpec, structuralRouteSpecs, settlementRouteSpecs []CapabilitySpec) string {
	if pricePolicy != "channel" || len(structuralRouteSpecs) == 0 {
		return ""
	}
	if len(settlementRouteSpecs) == 0 {
		return "供应线路尚未配置可结算价格，请先完善渠道模型价格"
	}
	if !logicalModelCapabilityCovered(product, settlementRouteSpecs) {
		return "部分创作端能力只能由未配置价格的渠道模型承接，请完善对应价格"
	}
	return ""
}

func (s *Service) SaveAdminLogicalModel(actor *model.User, id string, req LogicalModelRequest) (*AdminLogicalModel, error) {
	if err := s.RequireAdmin(actor); err != nil {
		return nil, err
	}
	item, revision, routes, creating, err := s.logicalModelBundle(actor, id, req)
	if err != nil {
		return nil, err
	}
	if err := s.repo.SaveLogicalModelBundle(item, revision, routes, creating); err != nil {
		return nil, err
	}
	s.invalidateRouteCatalog()
	_ = s.appendAdminAudit(actor, map[bool]string{true: "logical_model.create", false: "logical_model.update"}[creating], "logical_model", item.ID, "保存前台模型及供应线路", map[string]any{"revisionId": revision.ID, "routeCount": len(routes)})
	graph, err := s.repo.LogicalModelGraph(item.ID, true)
	if err != nil {
		return nil, err
	}
	channelIDs := make([]string, 0, len(graph.ChannelModels))
	for _, channelModel := range graph.ChannelModels {
		channelIDs = append(channelIDs, channelModel.ChannelID)
	}
	systemChannels, err := s.repo.SystemChannelsByIDs(channelIDs, true)
	if err != nil {
		return nil, err
	}
	systemChannelByID := make(map[string]model.ModelChannel, len(systemChannels))
	for _, channel := range systemChannels {
		systemChannelByID[channel.ID] = channel
	}
	return s.buildAdminLogicalModel(*item, graph, systemChannelByID)
}

func (s *Service) logicalModelBundle(actor *model.User, id string, req LogicalModelRequest) (*model.LogicalModel, *model.LogicalModelRevision, []model.LogicalModelRoute, bool, error) {
	code := strings.ToLower(strings.TrimSpace(req.Code))
	name := strings.TrimSpace(req.Name)
	capability := normalizeCapability(req.Capability)
	if !logicalModelCodePattern.MatchString(code) {
		return nil, nil, nil, false, BadAuthRequest("模型 code 需为 2-80 位小写字母、数字、点、下划线或连字符")
	}
	if name == "" || len([]rune(name)) > 120 {
		return nil, nil, nil, false, BadAuthRequest("请填写 1-120 个字符的模型名称")
	}
	normalizedSpec, err := NormalizeCapabilitySpec(req.CapabilitySpec)
	if err != nil {
		return nil, nil, nil, false, err
	}
	req.CapabilitySpec = normalizedSpec
	if normalizeCapability(req.CapabilitySpec.Capability) != capability {
		return nil, nil, nil, false, BadAuthRequest("前台模型类型与能力配置不一致")
	}
	normalizedDefaults, err := normalizeLogicalDefaults(req.CapabilitySpec, req.DefaultOptions)
	if err != nil {
		return nil, nil, nil, false, err
	}
	req.DefaultOptions = normalizedDefaults
	if req.UnitPriceMicrocredits < 0 || req.InputPriceMicrocredits < 0 || req.OutputPriceMicrocredits < 0 || req.CachedPriceMicrocredits < 0 {
		return nil, nil, nil, false, BadAuthRequest("用户价格不能为负数")
	}
	pricePolicy := strings.TrimSpace(req.PricePolicy)
	if pricePolicy != "channel" && pricePolicy != "unified" {
		return nil, nil, nil, false, BadAuthRequest("请选择跟随供应价格或统一定价")
	}
	billingMode := strings.TrimSpace(req.BillingMode)
	if pricePolicy == "channel" {
		billingMode = "fixed_request"
		req.UnitPriceMicrocredits, req.InputPriceMicrocredits, req.OutputPriceMicrocredits, req.CachedPriceMicrocredits = 0, 0, 0, 0
	} else if billingMode != "fixed_request" && billingMode != "per_second" && billingMode != "token" {
		return nil, nil, nil, false, BadAuthRequest("前台模型计费方式仅支持按次、按秒或 Token")
	}
	if pricePolicy == "unified" && billingMode == "per_second" && capability != "video" {
		return nil, nil, nil, false, BadAuthRequest("只有视频前台模型可以按秒计费")
	}
	if pricePolicy == "unified" && billingMode == "token" && capability != "text" {
		return nil, nil, nil, false, BadAuthRequest("当前仅文本前台模型支持 Token 计费")
	}
	creating := strings.TrimSpace(id) == ""
	var item *model.LogicalModel
	if creating {
		id, err = s.repo.NextPrefixedID("LMODEL")
		if err != nil {
			return nil, nil, nil, false, err
		}
		item = &model.LogicalModel{ID: id, CreatedAt: time.Now()}
	} else {
		item, err = s.repo.LogicalModel(id)
		if err != nil {
			return nil, nil, nil, false, err
		}
	}
	item.Code, item.Name, item.Icon, item.Description, item.Capability = code, name, strings.TrimSpace(req.Icon), strings.TrimSpace(req.Description), capability
	item.Enabled, item.SortOrder, item.PricePolicy, item.BillingMode = req.Enabled, req.SortOrder, pricePolicy, billingMode
	item.UnitPriceMicrocredits, item.InputPriceMicrocredits, item.OutputPriceMicrocredits, item.CachedPriceMicrocredits = req.UnitPriceMicrocredits, req.InputPriceMicrocredits, req.OutputPriceMicrocredits, req.CachedPriceMicrocredits
	item.UpdatedAt = time.Now()
	revisionID, err := s.repo.NextPrefixedID("REVISION")
	if err != nil {
		return nil, nil, nil, false, err
	}
	specJSON, _ := json.Marshal(req.CapabilitySpec)
	defaultsJSON, _ := json.Marshal(defaultMap(req.DefaultOptions))
	revision := &model.LogicalModelRevision{ID: revisionID, LogicalModelID: item.ID, CapabilitySpecJSON: string(specJSON), DefaultOptionsJSON: string(defaultsJSON), CreatedBy: actor.ID, CreatedAt: time.Now()}
	routes := make([]model.LogicalModelRoute, 0, len(req.Routes))
	seenVariants := make(map[string]bool, len(req.Routes))
	structuralRouteSpecs := make([]CapabilitySpec, 0, len(req.Routes))
	settlementRouteSpecs := make([]CapabilitySpec, 0, len(req.Routes))
	for _, input := range req.Routes {
		variantID := strings.TrimSpace(input.PhysicalVariantID)
		if variantID == "" || seenVariants[variantID] {
			return nil, nil, nil, false, BadAuthRequest("供应线路必须选择不重复的可用配置")
		}
		seenVariants[variantID] = true
		variant, variantErr := s.repo.PhysicalVariant(variantID)
		if variantErr != nil {
			return nil, nil, nil, false, BadAuthRequest("供应线路引用的可用配置不存在")
		}
		channelModel, modelErr := s.repo.ChannelModel(variant.ChannelModelID)
		if modelErr != nil {
			return nil, nil, nil, false, BadAuthRequest("可用配置引用的渠道模型不存在")
		}
		variantSpec, specErr := effectivePhysicalVariantSpec(*variant, *channelModel)
		if specErr != nil || normalizeCapability(variantSpec.Capability) != capability {
			return nil, nil, nil, false, BadAuthRequest("供应线路能力类型与前台模型不一致")
		}
		if req.Enabled && input.Enabled && input.Weight <= 0 {
			return nil, nil, nil, false, BadAuthRequest("启用供应线路的同级权重必须大于 0")
		}
		if input.Weight < 0 {
			return nil, nil, nil, false, BadAuthRequest("供应线路的同级权重不能为负数")
		}
		if req.Enabled && input.Enabled && variant.Enabled {
			if err := validateVariantWithinChannelModel(*channelModel, variantSpec); err != nil {
				return nil, nil, nil, false, err
			}
			if channelModel.Enabled {
				if _, channelErr := s.repo.SystemChannel(channelModel.ChannelID); channelErr == nil {
					structuralRouteSpecs = append(structuralRouteSpecs, variantSpec)
					if pricePolicy != "channel" || channelModel.PriceConfigured {
						settlementRouteSpecs = append(settlementRouteSpecs, variantSpec)
					}
				}
			}
		}
		routeID, idErr := s.repo.NextPrefixedID("ROUTE")
		if idErr != nil {
			return nil, nil, nil, false, idErr
		}
		routes = append(routes, model.LogicalModelRoute{ID: routeID, PhysicalVariantID: variant.ID, Enabled: input.Enabled, Priority: input.Priority, Weight: input.Weight, CreatedAt: time.Now(), UpdatedAt: time.Now()})
	}
	// 停用必须始终可执行，便于管理员立即阻止失效配置继续对外服务；重新启用时再强校验结构能力和计费可用性。
	if req.Enabled {
		if len(structuralRouteSpecs) == 0 {
			return nil, nil, nil, false, BadAuthRequest("启用前台模型前至少需要一条已启用的供应线路")
		}
		if err := validateProductSpecWithinRoutes(req.CapabilitySpec, structuralRouteSpecs); err != nil {
			return nil, nil, nil, false, err
		}
		if availabilityError := logicalModelAvailabilityError(pricePolicy, req.CapabilitySpec, structuralRouteSpecs, settlementRouteSpecs); availabilityError != "" {
			return nil, nil, nil, false, BadAuthRequest(availabilityError)
		}
	}
	return item, revision, routes, creating, nil
}

func normalizeLogicalDefaults(spec CapabilitySpec, defaults map[string]any) (map[string]any, error) {
	result := make(map[string]any, len(defaults))
	for rawName, value := range defaults {
		name := canonicalCapabilityOptionName(rawName)
		if _, exists := result[name]; exists {
			return nil, BadAuthRequest("默认参数存在重复别名：" + name)
		}
		constraint, ok := spec.Options[name]
		if !ok || !matchOptionConstraint(name, constraint, value) {
			return nil, BadAuthRequest("默认参数 " + name + " 不在前台模型能力范围内")
		}
		// `*` 只表示允许任意自定义值，不能作为创作端默认参数发送。
		if normalizedScalar(value) == "*" {
			for _, candidate := range constraint.Values {
				if normalizedScalar(candidate) != "*" {
					value = candidate
					break
				}
			}
		}
		result[name] = value
	}
	return result, nil
}

func defaultMap(value map[string]any) map[string]any {
	if value == nil {
		return map[string]any{}
	}
	return value
}

func (s *Service) AdminPhysicalVariants(actor *model.User) ([]AdminPhysicalVariant, error) {
	return s.adminPhysicalVariants(actor, "")
}

func (s *Service) AdminPhysicalVariantsForChannelModel(actor *model.User, channelModelID string) ([]AdminPhysicalVariant, error) {
	return s.adminPhysicalVariants(actor, strings.TrimSpace(channelModelID))
}

func (s *Service) adminPhysicalVariants(actor *model.User, channelModelID string) ([]AdminPhysicalVariant, error) {
	if err := s.RequireAdmin(actor); err != nil {
		return nil, err
	}
	var variants []model.PhysicalCapabilityVariant
	var err error
	if channelModelID != "" {
		if _, err := s.repo.ChannelModel(channelModelID); err != nil {
			return nil, BadAuthRequest("渠道模型不存在")
		}
		variants, err = s.repo.PhysicalVariants([]string{channelModelID}, true)
	} else {
		variants, err = s.repo.AllPhysicalVariants(true)
	}
	if err != nil {
		return nil, err
	}
	variantIDs := make([]string, 0, len(variants))
	for _, variant := range variants {
		variantIDs = append(variantIDs, variant.ID)
	}
	usageCounts, err := s.repo.PhysicalVariantRouteCounts(variantIDs)
	if err != nil {
		return nil, err
	}
	result := make([]AdminPhysicalVariant, 0, len(variants))
	for _, variant := range variants {
		channelModel, modelErr := s.repo.ChannelModel(variant.ChannelModelID)
		if modelErr != nil {
			continue
		}
		spec, specErr := effectivePhysicalVariantSpec(variant, *channelModel)
		if specErr != nil {
			continue
		}
		result = append(result, AdminPhysicalVariant{ID: variant.ID, ChannelModelID: channelModel.ID, ChannelID: channelModel.ChannelID, ModelKey: channelModel.ModelKey, ModelName: channelModel.DisplayName, Name: variant.Name, Capability: channelModel.Capability, Protocol: string(channelModel.Protocol), Enabled: variant.Enabled, ModelEnabled: channelModel.Enabled, UsageCount: usageCounts[variant.ID], CapabilitySpec: spec})
	}
	return result, nil
}

func effectivePhysicalVariantSpec(variant model.PhysicalCapabilityVariant, channelModel model.ChannelModel) (CapabilitySpec, error) {
	config, configErr := DecodeModelCapabilityConfig(channelModel.CapabilityConfigJSON)
	if configErr == nil && config != nil {
		if spec, err := CapabilitySpecFromModelCapabilityConfig(config, normalizeCapability(channelModel.Capability)); err == nil {
			return spec, nil
		}
	}
	// 音频模型以及历史数据可能没有新的能力配置，保留旧快照作为只读降级，避免读路径直接丢失线路。
	return DecodeCapabilitySpec(variant.CapabilitySpecJSON)
}

func (s *Service) SaveAdminPhysicalVariant(actor *model.User, id string, req PhysicalVariantRequest) (*AdminPhysicalVariant, error) {
	if err := s.RequireAdmin(actor); err != nil {
		return nil, err
	}
	channelModel, err := s.repo.ChannelModel(strings.TrimSpace(req.ChannelModelID))
	if err != nil {
		return nil, BadAuthRequest("请选择有效的渠道模型")
	}
	name := strings.TrimSpace(req.Name)
	if name == "" || len([]rune(name)) > 120 {
		return nil, BadAuthRequest("请填写 1-120 个字符的可用配置名称")
	}
	creating := strings.TrimSpace(id) == ""
	var item *model.PhysicalCapabilityVariant
	if creating {
		existing, existingErr := s.repo.PhysicalVariants([]string{channelModel.ID}, true)
		if existingErr != nil {
			return nil, existingErr
		}
		if len(existing) > 0 {
			return nil, BadAuthRequest("一个渠道模型只能配置一个可用配置，请编辑现有配置")
		}
		id, err = s.repo.NextPrefixedID("VARIANT")
		if err != nil {
			return nil, err
		}
		item = &model.PhysicalCapabilityVariant{ID: id, CreatedAt: time.Now()}
	} else {
		item, err = s.repo.PhysicalVariant(id)
		if err != nil {
			return nil, err
		}
		if item.ChannelModelID != channelModel.ID {
			return nil, BadAuthRequest("已创建的可用配置不能换绑渠道模型，请新建可用配置")
		}
	}
	// variant 不再承载第二份可编辑能力配置，能力快照始终从渠道模型生成。
	// 读取旧请求中的 capabilitySpec 仅为兼容旧客户端，不再作为事实来源。
	// 停用是强制止损操作：即使渠道模型能力 JSON 已损坏，也必须允许管理员先停用；
	// 只有启用路径才要求重新生成并校验能力快照。
	capabilityConfig, configErr := DecodeModelCapabilityConfig(channelModel.CapabilityConfigJSON)
	derivedSpec, deriveErr := CapabilitySpecFromModelCapabilityConfig(capabilityConfig, normalizeCapability(channelModel.Capability))
	if req.Enabled {
		if configErr != nil {
			return nil, BadAuthRequest("渠道模型能力配置无效，请先修复渠道模型")
		}
		if deriveErr != nil {
			return nil, deriveErr
		}
		if err := validateVariantWithinChannelModel(*channelModel, derivedSpec); err != nil {
			return nil, err
		}
	}
	spec := derivedSpec
	if deriveErr != nil {
		// 禁用时保留已有快照，避免坏配置导致管理列表丢失；新建记录使用最小可读快照。
		if existingSpec, existingErr := DecodeCapabilitySpec(item.CapabilitySpecJSON); existingErr == nil {
			spec = existingSpec
		} else {
			spec = CapabilitySpec{Version: 1, Capability: normalizeCapability(channelModel.Capability)}
		}
	}
	specJSON, _ := json.Marshal(spec)
	item.ChannelModelID, item.Name, item.Enabled, item.CapabilitySpecJSON, item.UpdatedAt = channelModel.ID, name, req.Enabled, string(specJSON), time.Now()
	if creating {
		err = s.repo.CreatePhysicalVariant(item)
	} else {
		err = s.repo.SavePhysicalVariant(item)
	}
	if err != nil {
		return nil, err
	}
	s.invalidateRouteCatalog()
	_ = s.appendAdminAudit(actor, map[bool]string{true: "physical_variant.create", false: "physical_variant.update"}[creating], "physical_variant", item.ID, "保存可用配置", map[string]any{"channelModelId": channelModel.ID})
	variants, err := s.AdminPhysicalVariants(actor)
	if err != nil {
		return nil, err
	}
	for index := range variants {
		if variants[index].ID == item.ID {
			return &variants[index], nil
		}
	}
	return nil, gorm.ErrRecordNotFound
}

func (s *Service) SimulateLogicalModelRoute(actor *model.User, id string, intent ModelRequestIntent) (*RouteSimulationResult, error) {
	if err := s.RequireAdmin(actor); err != nil {
		return nil, err
	}
	snapshot, err := s.routeCatalogSnapshot()
	if err != nil {
		return nil, err
	}
	cached, ok := snapshot.Models[id]
	if !ok {
		return nil, BadAuthRequest("前台模型未启用或尚未发布")
	}
	intent.Options = mergeIntentDefaults(intent.Options, cached.Defaults)
	return &RouteSimulationResult{ProductMatch: MatchCapability(cached.ProductSpec, intent), Candidates: s.sortedRouteDiagnostics(cached.Routes, intent)}, nil
}

func logicalModelNotFound(err error) bool { return errors.Is(err, gorm.ErrRecordNotFound) }

// 可用配置只能收窄渠道模型能力，不能声明协议适配器实际无法发送的范围。
func validateVariantWithinChannelModel(channelModel model.ChannelModel, spec CapabilitySpec) error {
	profile, err := DecodeModelCapabilityConfig(channelModel.CapabilityConfigJSON)
	if err != nil {
		return BadAuthRequest("渠道模型能力配置无效，请先修复渠道模型")
	}
	switch normalizeCapability(spec.Capability) {
	case "text":
		if profile == nil || profile.Text == nil {
			return BadAuthRequest("渠道文本模型尚未配置能力参数")
		}
		limits := map[string]int{"image": profile.Text.References.MaxImages, "video": profile.Text.References.MaxVideos}
		for kind, constraint := range spec.Inputs {
			limit, known := limits[kind]
			if !known && constraint.Max > 0 || known && constraint.Max > limit {
				return BadAuthRequest("可用配置的 " + kind + " 输入上限超过渠道模型配置")
			}
		}
		return validateKnownVariantOptions(spec.Options, map[string]OptionConstraint{})
	case "image":
		if profile == nil || profile.Image == nil {
			return BadAuthRequest("渠道图片模型尚未配置能力参数")
		}
		image := profile.Image
		for kind, constraint := range spec.Inputs {
			switch kind {
			case "image":
				if constraint.Max > image.References.MaxImages {
					return BadAuthRequest("可用配置的图片输入上限超过渠道模型配置")
				}
			case "mask":
				if constraint.Max > 1 || constraint.Max > 0 && !image.References.MaskSupported {
					return BadAuthRequest("可用配置声明了渠道模型不支持的蒙版输入")
				}
			default:
				if constraint.Max > 0 {
					return BadAuthRequest("图片协议尚未接入 " + kind + " 输入")
				}
			}
		}
		physical := map[string]OptionConstraint{
			"size":                  imageSizeOptionConstraint(image.Size),
			"quality":               anyValues(image.Quality.Values),
			"transparentBackground": boolValues(image.TransparentBackground.Supported),
			"count":                 numericRange(1, float64(image.MaxOutputs), 1),
		}
		return validateKnownVariantOptions(spec.Options, physical)
	case "video":
		if profile == nil || profile.Video == nil {
			return BadAuthRequest("渠道视频模型尚未配置能力参数")
		}
		video := profile.Video
		limits := map[string]int{"image": video.References.MaxImages, "video": video.References.MaxVideos, "audio": video.References.MaxAudios}
		for kind, constraint := range spec.Inputs {
			limit, known := limits[kind]
			if !known && constraint.Max > 0 || known && constraint.Max > limit {
				return BadAuthRequest("可用配置的 " + kind + " 输入上限超过渠道模型配置")
			}
		}
		for _, operation := range spec.Operations {
			if !containsCapabilityString(video.Operations, operation) {
				return BadAuthRequest("可用配置包含渠道模型不支持的操作：" + operation)
			}
		}
		duration := OptionConstraint{}
		if video.Duration.Selection == "enum" {
			values := make([]any, 0, len(video.Duration.Values))
			for _, value := range video.Duration.Values {
				values = append(values, value)
			}
			duration.Values = values
		} else {
			duration = numericRange(float64(video.Duration.Min), float64(video.Duration.Max), float64(video.Duration.Step))
		}
		physical := map[string]OptionConstraint{
			"videoSeconds":       duration,
			"size":               anyValues(video.Ratios),
			"vquality":           anyValues(video.Resolutions),
			"videoGenerateAudio": boolValues(video.GenerateAudio.Supported),
			"videoWatermark":     boolValues(video.Watermark.Supported),
		}
		return validateKnownVariantOptions(spec.Options, physical)
	case "audio":
		for kind, constraint := range spec.Inputs {
			if constraint.Max > 0 {
				return BadAuthRequest("音频协议尚未接入 " + kind + " 输入")
			}
		}
		wildcard := OptionConstraint{Values: []any{"*"}}
		return validateKnownVariantOptions(spec.Options, map[string]OptionConstraint{"audioVoice": wildcard, "audioFormat": wildcard, "audioSpeed": wildcard, "audioInstructions": wildcard})
	}
	return BadAuthRequest("可用配置类型暂不支持")
}

// 前台模型只声明供应线路真实提供的总目录；组合是否可承接仍由匿名 capabilityProfiles 按 OR 语义判断。
func validateProductSpecWithinRoutes(product CapabilitySpec, routeSpecs []CapabilitySpec) error {
	for _, routeSpec := range routeSpecs {
		if normalizeCapability(routeSpec.Capability) != normalizeCapability(product.Capability) {
			return BadAuthRequest("供应线路能力类型与前台模型不一致")
		}
	}
	if len(product.Operations) == 0 {
		unrestricted := false
		for _, routeSpec := range routeSpecs {
			if len(routeSpec.Operations) == 0 {
				unrestricted = true
				break
			}
		}
		if !unrestricted {
			return BadAuthRequest("创作端生成方式必须从供应线路支持的选项中选择")
		}
	} else {
		for _, operation := range product.Operations {
			supported := false
			for _, routeSpec := range routeSpecs {
				if len(routeSpec.Operations) == 0 || containsCapabilityString(routeSpec.Operations, operation) {
					supported = true
					break
				}
			}
			if !supported {
				return BadAuthRequest("创作端生成方式不受任何供应线路支持：" + operation)
			}
		}
	}
	for name, constraint := range product.Inputs {
		if !inputConstraintCovered(constraint, name, routeSpecs) {
			return BadAuthRequest("创作端输入范围超出供应线路能力：" + name)
		}
	}
	for name, constraint := range product.Options {
		if !optionConstraintCovered(constraint, name, routeSpecs) {
			return BadAuthRequest("创作端参数超出供应线路能力：" + name)
		}
	}
	return nil
}

func inputConstraintCovered(candidate InputConstraint, name string, routeSpecs []CapabilitySpec) bool {
	next := candidate.Min
	for next <= candidate.Max {
		coveredUntil := next - 1
		for _, routeSpec := range routeSpecs {
			constraint, exists := routeSpec.Inputs[name]
			if !exists {
				constraint = InputConstraint{Min: 0, Max: 0}
			}
			if constraint.Min <= next && constraint.Max >= next && constraint.Max > coveredUntil {
				coveredUntil = constraint.Max
			}
		}
		if coveredUntil < next {
			return false
		}
		next = coveredUntil + 1
	}
	return true
}

func optionConstraintCovered(candidate OptionConstraint, name string, routeSpecs []CapabilitySpec) bool {
	routeConstraints := make([]OptionConstraint, 0, len(routeSpecs))
	for _, routeSpec := range routeSpecs {
		if constraint, exists := routeSpec.Options[name]; exists {
			routeConstraints = append(routeConstraints, constraint)
		}
	}
	if len(routeConstraints) == 0 {
		return false
	}
	for _, routeConstraint := range routeConstraints {
		if isWildcardOptionConstraint(routeConstraint) {
			return true
		}
	}
	if len(candidate.Values) > 0 {
		for _, value := range candidate.Values {
			if !optionValueSupported(name, value, routeConstraints) {
				return false
			}
		}
		return true
	}
	if candidate.Min == nil || candidate.Max == nil {
		return false
	}
	if math.Abs(*candidate.Max-*candidate.Min) < 1e-9 {
		return optionValueSupported(name, *candidate.Min, routeConstraints)
	}
	if candidate.Step == nil {
		return continuousOptionRangeCovered(*candidate.Min, *candidate.Max, routeConstraints)
	}
	step := *candidate.Step
	count := int(math.Floor((*candidate.Max-*candidate.Min)/step+1e-9)) + 1
	if count <= 10000 {
		for index := 0; index < count; index++ {
			value := *candidate.Min + float64(index)*step
			if !optionValueSupported(name, value, routeConstraints) {
				return false
			}
		}
		return true
	}
	// 超大离散范围不逐点展开；只有单条连续范围或步长完全兼容的线路才能作为可靠来源。
	for _, routeConstraint := range routeConstraints {
		if routeConstraint.Min == nil || routeConstraint.Max == nil || *routeConstraint.Min > *candidate.Min || *routeConstraint.Max < *candidate.Max {
			continue
		}
		if routeConstraint.Step == nil {
			return true
		}
		startSteps := (*candidate.Min - *routeConstraint.Min) / *routeConstraint.Step
		stepRatio := step / *routeConstraint.Step
		if math.Abs(startSteps-math.Round(startSteps)) < 1e-9 && math.Abs(stepRatio-math.Round(stepRatio)) < 1e-9 {
			return true
		}
	}
	return false
}

func optionValueSupported(name string, value any, constraints []OptionConstraint) bool {
	for _, constraint := range constraints {
		if isWildcardOptionConstraint(constraint) {
			return true
		}
		if matchOptionConstraint(name, constraint, value) {
			return true
		}
	}
	return false
}

func isWildcardOptionConstraint(constraint OptionConstraint) bool {
	for _, value := range constraint.Values {
		if normalizedScalar(value) == "*" {
			return true
		}
	}
	return false
}

func continuousOptionRangeCovered(minimum float64, maximum float64, constraints []OptionConstraint) bool {
	next := minimum
	for next <= maximum+1e-9 {
		coveredUntil := next
		advanced := false
		for _, constraint := range constraints {
			if constraint.Min == nil || constraint.Max == nil || constraint.Step != nil {
				continue
			}
			if *constraint.Min <= next+1e-9 && *constraint.Max >= next-1e-9 && *constraint.Max > coveredUntil {
				coveredUntil = *constraint.Max
				advanced = true
			}
		}
		if coveredUntil >= maximum-1e-9 {
			return true
		}
		if !advanced {
			return false
		}
		next = coveredUntil
	}
	return true
}

func validateKnownVariantOptions(options map[string]OptionConstraint, physical map[string]OptionConstraint) error {
	for name, constraint := range options {
		limit, known := physical[name]
		if !known {
			return BadAuthRequest("参数 " + name + " 尚未接入该类型的供应商协议映射")
		}
		if !optionConstraintWithin(constraint, limit) {
			return BadAuthRequest("参数 " + name + " 超过渠道模型能力范围")
		}
	}
	return nil
}

func optionConstraintWithin(candidate OptionConstraint, limit OptionConstraint) bool {
	return optionConstraintCovered(candidate, "value", []CapabilitySpec{{Options: map[string]OptionConstraint{"value": limit}}})
}

func anyValues(values []string) OptionConstraint {
	result := make([]any, 0, len(values))
	for _, value := range values {
		result = append(result, value)
	}
	return OptionConstraint{Values: result}
}

func boolValues(supportsTrue bool) OptionConstraint {
	values := []any{false}
	if supportsTrue {
		values = append(values, true)
	}
	return OptionConstraint{Values: values}
}

func numericRange(minimum float64, maximum float64, step float64) OptionConstraint {
	return OptionConstraint{Min: &minimum, Max: &maximum, Step: &step}
}