package store

import (
	"context"
	"fmt"
)

func (s *Store) ListModelCandidates(ctx context.Context, model string, modelType string) ([]RuntimeModelCandidate, error) {
	rows, err := s.pool.Query(ctx, `
SELECT p.id::text, p.platform_key, p.name, p.provider, COALESCE(p.base_url, ''),
       p.auth_type, p.credentials, p.config, p.default_pricing_mode,
       p.default_discount_factor::float8, COALESCE(p.pricing_rule_set_id::text, ''),
       p.retry_policy, p.rate_limit_policy,
       COALESCE(p.dynamic_priority, p.priority) AS effective_priority,
       m.id::text, COALESCE(m.base_model_id::text, ''), COALESCE(b.canonical_model_key, ''),
       COALESCE(b.provider_model_name, ''), m.model_name, COALESCE(m.model_alias, ''),
       m.model_type, m.display_name, m.capabilities, m.capability_override,
       COALESCE(b.base_billing_config, '{}'::jsonb), m.billing_config, m.billing_config_override,
       m.pricing_mode, COALESCE(m.discount_factor, 0)::float8, COALESCE(m.pricing_rule_set_id::text, ''),
       m.retry_policy, m.rate_limit_policy
FROM platform_models m
JOIN integration_platforms p ON p.id = m.platform_id
LEFT JOIN base_model_catalog b ON b.id = m.base_model_id
LEFT JOIN runtime_client_states s
  ON s.client_id = p.platform_key || ':' || m.model_type || ':' || m.model_name
WHERE p.status = 'enabled'
  AND p.deleted_at IS NULL
  AND m.enabled = true
  AND m.model_type = $2
  AND (p.cooldown_until IS NULL OR p.cooldown_until <= now())
  AND (
    m.model_name = $1
    OR m.model_alias = $1
    OR b.canonical_model_key = $1
    OR b.provider_model_name = $1
  )
ORDER BY effective_priority ASC,
         COALESCE(s.limiter_ratio, 0) ASC,
         COALESCE(s.running_count, 0) ASC,
         COALESCE(s.waiting_count, 0) ASC,
         COALESCE(s.last_assigned_at, to_timestamp(0)) ASC,
         m.created_at ASC`, model, modelType)
	if err != nil {
		return nil, err
	}
	defer rows.Close()

	items := make([]RuntimeModelCandidate, 0)
	for rows.Next() {
		var item RuntimeModelCandidate
		var credentials []byte
		var platformConfig []byte
		var platformRetryPolicy []byte
		var platformRateLimitPolicy []byte
		var capabilities []byte
		var capabilityOverride []byte
		var baseBilling []byte
		var billing []byte
		var billingOverride []byte
		var modelRetryPolicy []byte
		var modelRateLimitPolicy []byte
		if err := rows.Scan(
			&item.PlatformID,
			&item.PlatformKey,
			&item.PlatformName,
			&item.Provider,
			&item.BaseURL,
			&item.AuthType,
			&credentials,
			&platformConfig,
			&item.DefaultPricingMode,
			&item.DefaultDiscountFactor,
			&item.PlatformPricingRuleSetID,
			&platformRetryPolicy,
			&platformRateLimitPolicy,
			&item.PlatformPriority,
			&item.PlatformModelID,
			&item.BaseModelID,
			&item.CanonicalModelKey,
			&item.ProviderModelName,
			&item.ModelName,
			&item.ModelAlias,
			&item.ModelType,
			&item.DisplayName,
			&capabilities,
			&capabilityOverride,
			&baseBilling,
			&billing,
			&billingOverride,
			&item.PricingMode,
			&item.DiscountFactor,
			&item.ModelPricingRuleSetID,
			&modelRetryPolicy,
			&modelRateLimitPolicy,
		); err != nil {
			return nil, err
		}
		item.Credentials = decodeObject(credentials)
		item.PlatformConfig = decodeObject(platformConfig)
		item.PlatformRetryPolicy = decodeObject(platformRetryPolicy)
		item.PlatformRateLimitPolicy = decodeObject(platformRateLimitPolicy)
		item.Capabilities = decodeObject(capabilities)
		item.CapabilityOverride = decodeObject(capabilityOverride)
		item.BaseBillingConfig = decodeObject(baseBilling)
		item.BillingConfig = decodeObject(billing)
		item.BillingConfigOverride = decodeObject(billingOverride)
		item.ModelRetryPolicy = decodeObject(modelRetryPolicy)
		item.ModelRateLimitPolicy = decodeObject(modelRateLimitPolicy)
		item.ClientID = fmt.Sprintf("%s:%s:%s", item.PlatformKey, item.ModelType, item.ModelName)
		item.QueueKey = item.ClientID
		items = append(items, item)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	if len(items) == 0 {
		return nil, ErrNoModelCandidate
	}
	return items, nil
}