# Current pattern in config.ex
{:ok, config} <- YamlElixir.read_from_string(content)
# Hard-coded validation in enhanced_config.ex
@enhanced_step_types [
  "set_variable", "claude", "gemini", "parallel_claude",
  "gemini_instructor", "claude_smart", "claude_session",
  "claude_extract", "claude_batch", "claude_robust"
]

# Register DSPy configuration extension
Pipeline.Enhanced.ConfigurationSystem.register_schema_extension(
  "dspy",
  %{
    "properties" => %{
      "workflow" => %{
        "properties" => %{
          "dspy_config" => %{
            "type" => "object",
            "properties" => %{
              "optimization_enabled" => %{"type" => "boolean"},
              "evaluation_mode" => %{
                "type" => "string",
                "enum" => ["bootstrap_few_shot", "copro", "mipro"]
              },
              "training_data_path" => %{"type" => "string"},
              "cache_enabled" => %{"type" => "boolean"}
            }
          }
        }
      }
    }
  }
)

# Load configuration with dynamic extensions
{:ok, config} = Pipeline.Enhanced.ConfigurationManager.load_config(
  "workflow.yaml",
  extensions: ["dspy", "custom_plugin"],
  environment: :production,
  validate: true
)

# Enhanced configuration with DSPy support
workflow:
  name: "dspy_analysis_pipeline"
  
  dspy_config:
    optimization_enabled: true
    evaluation_mode: "bootstrap_few_shot"
    training_data_path: "/data/training"
    cache_enabled: true
    optimization_frequency: "daily"
  
  steps:
    - name: "analyze_code"
      type: "dspy_claude"
      dspy_signature:
        input_fields:
          - name: "code"
            type: "string"
            description: "Source code to analyze"
        output_fields:
          - name: "analysis"
            type: "object"
            description: "Analysis results"
            schema:
              type: "object"
              properties:
                issues: {type: "array", items: {type: "string"}}
                score: {type: "number", minimum: 0, maximum: 100}
      
      dspy_config:
        optimization_enabled: true
        few_shot_examples: 5
        bootstrap_iterations: 3

defmodule Pipeline.Enhanced.ConfigurationSystem do
  def compile_schema_with_extensions(base_schema, extension_names) do
    # Get registered extensions
    extensions = get_registered_extensions(extension_names)
    
    # Compose schemas with conflict resolution
    composed_schema = Enum.reduce(extensions, base_schema, fn extension, acc ->
      Pipeline.Enhanced.SchemaComposer.compose_schemas(acc, extension)
    end)
    
    # Optimize composed schema for validation
    Pipeline.Enhanced.SchemaOptimizer.optimize_schema(composed_schema)
  end
end

def validate_configuration(config, extensions \\ []) do
  # Compile schema with extensions
  {:ok, schema} = get_compiled_schema(extensions)
  
  # Validate with type preservation
  case Pipeline.Enhanced.SchemaValidator.validate_with_type_preservation(config, schema) do
    {:ok, validated_config} ->
      # Apply configuration-specific processing
      {:ok, process_validated_config(validated_config)}
    
    {:error, validation_errors} ->
      {:error, format_validation_errors(validation_errors)}
  end
end

# Base configuration
workflow:
  name: "analysis_pipeline"
  
  defaults:
    claude_preset: "analysis"
    timeout: 30

# Environment-specific overrides
environments:
  development:
    dspy_config:
      optimization_enabled: false
      cache_enabled: true
      
  production:
    dspy_config:
      optimization_enabled: true
      cache_enabled: true
      optimization_frequency: "daily"
      
  testing:
    dspy_config:
      optimization_enabled: false
      cache_enabled: false

defmodule Pipeline.Enhanced.ConfigurationCache do
  def get_compiled_config(config_path, extensions, environment) do
    cache_key = generate_cache_key(config_path, extensions, environment)
    
    case get_cached_config(cache_key) do
      {:ok, cached_config} ->
        if config_changed?(config_path, cached_config.timestamp) do
          compile_and_cache_config(config_path, extensions, environment)
        else
          {:ok, cached_config.config}
        end
      
      :not_found ->
        compile_and_cache_config(config_path, extensions, environment)
    end
  end
end

# Template configuration
workflow:
  name: "{{workflow_name}}"
  
  variables:
    analysis_type: "{{analysis_type | default: 'security'}}"
    max_iterations: "{{max_iterations | default: 10}}"
  
  steps:
    - name: "analyze_{{analysis_type}}"
      type: "dspy_claude"
      prompt: "Analyze this {{analysis_type}} issue: {{input}}"

# Plugin registers configuration extensions
def register_plugin_extensions(plugin_name, plugin_module, plugin_state) do
  if function_exported?(plugin_module, :get_schema_extensions, 1) do
    extensions = apply(plugin_module, :get_schema_extensions, [plugin_state])
    
    Enum.each(extensions, fn {extension_name, extension_schema} ->
      Pipeline.Enhanced.ConfigurationSystem.register_schema_extension(
        extension_name,
        extension_schema,
        metadata: %{plugin: plugin_name}
      )
    end)
  end
end

# Configuration loading error handling
case Pipeline.Enhanced.ConfigurationManager.load_config(path, opts) do
  {:ok, config} ->
    {:ok, config}
  
  {:error, :file_not_found} ->
    {:error, "Configuration file not found: #{path}"}
  
  {:error, :invalid_yaml} ->
    {:error, "Invalid YAML syntax in configuration file"}
  
  {:error, :schema_validation_failed, errors} ->
    {:error, "Configuration validation failed: #{format_errors(errors)}"}
  
  {:error, :extension_not_found, extension} ->
    {:error, "Configuration extension not found: #{extension}"}
end