defmodule Foundation.Perimeter.Types.Foundation do
  @moduledoc """
  Core Foundation-specific types for perimeter validation.
  """
  
  # Foundation service identifiers
  deftype foundation_service_id :: String.t(),
    pattern: ~r/^foundation_[a-z_]+_[0-9a-f]{8}$/,
    examples: ["foundation_registry_abc12345", "foundation_mabeam_def67890"]
  
  # Foundation protocol messages
  deftype foundation_protocol_message :: %{
    required(:protocol) => foundation_protocol(),
    required(:message) => term(),
    required(:context) => foundation_context(),
    optional(:metadata) => map()
  }
  
  deftype foundation_protocol :: atom(),
    enum: [
      :foundation_registry,
      :foundation_coordination, 
      :foundation_telemetry,
      :foundation_mabeam,
      :foundation_optimization
    ]
  
  # Foundation execution context
  deftype foundation_context :: %{
    required(:node) => node(),
    required(:cluster_id) => String.t(),
    required(:telemetry_scope) => atom(),
    optional(:registry_scope) => atom(),
    optional(:coordination_scope) => atom()
  }
  
  # Foundation service specifications
  deftype foundation_service_spec :: %{
    required(:service_type) => foundation_service_type(),
    required(:capabilities) => [foundation_capability()],
    required(:configuration) => foundation_service_config(),
    optional(:clustering_config) => foundation_clustering_config()
  }
  
  deftype foundation_service_type :: atom(),
    enum: [:registry, :coordination, :telemetry, :mabeam, :optimization, :infrastructure]
  
  deftype foundation_capability :: atom(),
    enum: [
      :agent_coordination, :signal_routing, :telemetry_collection,
      :variable_optimization, :protocol_dispatch, :clustering
    ]
end

defmodule Foundation.Perimeter.Types.AI do
  @moduledoc """
  AI and ML-specific types for Foundation perimeter validation.
  """
  
  # LLM provider specifications
  deftype llm_provider :: %{
    required(:provider) => llm_provider_name(),
    required(:model) => String.t(),
    required(:api_key) => String.t(),
    optional(:base_url) => String.t(),
    optional(:rate_limits) => rate_limit_config()
  }
  
  deftype llm_provider_name :: atom(),
    enum: [:openai, :anthropic, :cohere, :huggingface, :local]
  
  # ML variable specifications
  deftype ml_variable :: %{
    required(:name) => atom(),
    required(:type) => ml_variable_type(),
    required(:bounds) => variable_bounds(),
    optional(:default) => term(),
    optional(:description) => String.t()
  }
  
  deftype ml_variable_type :: atom(),
    enum: [:float, :integer, :choice, :module, :composite]
  
  deftype variable_bounds :: float_bounds() | integer_bounds() | choice_bounds(),
    discriminator: :type
  
  deftype float_bounds :: %{
    required(:type) => :float,
    required(:min) => float(),
    required(:max) => float()
  }
  
  deftype integer_bounds :: %{
    required(:type) => :integer, 
    required(:min) => integer(),
    required(:max) => integer()
  }
  
  deftype choice_bounds :: %{
    required(:type) => :choice,
    required(:choices) => [term()]
  }
  
  # ML pipeline specifications
  deftype ml_pipeline :: %{
    required(:pipeline_id) => String.t(),
    required(:steps) => [ml_pipeline_step()],
    required(:variables) => [ml_variable()],
    optional(:optimization_config) => optimization_config()
  }
  
  deftype ml_pipeline_step :: %{
    required(:name) => String.t(),
    required(:action) => atom(),
    required(:params) => map(),
    optional(:dependencies) => [String.t()]
  }
end

defmodule Foundation.Perimeter.Types.Agent do
  @moduledoc """
  Jido agent-specific types for Foundation integration.
  """
  
  # Jido agent specifications
  deftype jido_agent_spec :: %{
    required(:type) => jido_agent_type(),
    required(:capabilities) => [jido_capability()],
    required(:initial_state) => map(),
    optional(:clustering_config) => agent_clustering_config(),
    optional(:foundation_integration) => foundation_integration_config()
  }
  
  deftype jido_agent_type :: atom(),
    enum: [:task_agent, :coordinator_agent, :monitor_agent, :foundation_agent, :persistent_foundation_agent]
  
  deftype jido_capability :: atom(),
    enum: [
      :nlp, :ml, :coordination, :monitoring, :optimization, 
      :reasoning, :planning, :execution, :learning
    ]
  
  # Agent clustering configuration
  deftype agent_clustering_config :: %{
    required(:enabled) => boolean(),
    required(:strategy) => clustering_strategy(),
    optional(:nodes) => pos_integer(),
    optional(:replication_factor) => pos_integer(),
    optional(:consistency_level) => consistency_level()
  }
  
  deftype clustering_strategy :: atom(),
    enum: [:round_robin, :capability_matched, :load_balanced, :geographic, :cost_optimized]
  
  deftype consistency_level :: atom(),
    enum: [:eventual, :strong, :bounded_staleness]
  
  # Foundation integration for agents
  deftype foundation_integration_config :: %{
    required(:registry_integration) => boolean(),
    required(:telemetry_integration) => boolean(),
    optional(:coordination_patterns) => [coordination_pattern()],
    optional(:protocol_bindings) => [protocol_binding()]
  }
  
  deftype coordination_pattern :: atom(),
    enum: [:consensus, :pipeline, :map_reduce, :auction, :hierarchical]
  
  deftype protocol_binding :: %{
    required(:foundation_protocol) => atom(),
    required(:agent_handler) => atom(),
    optional(:transformation) => atom()
  }
end

defmodule Foundation.Perimeter.External.DSPEx do
  use Foundation.Perimeter
  
  external_contract :create_dspex_program do
    field :name, :string, 
      required: true, 
      length: 1..100,
      pattern: ~r/^[a-zA-Z][a-zA-Z0-9_]*$/
    
    field :description, :string,
      length: 0..1000,
      default: ""
    
    field :schema_fields, {:list, :map},
      required: true,
      validate: &validate_dspex_schema_fields/1
    
    field :signature_spec, :map,
      required: true,
      validate: &validate_signature_specification/1
    
    field :optimization_config, :map,
      validate: &validate_optimization_configuration/1
    
    field :foundation_context, foundation_context(),
      required: true
    
    field :variable_space, {:list, ml_variable()},
      validate: &validate_variable_space_consistency/1
    
    field :performance_targets, :map,
      validate: &validate_performance_targets/1
    
    # Cross-field validations
    validate :ensure_schema_signature_compatibility
    validate :ensure_variables_optimization_compatibility
    validate :ensure_foundation_context_validity
    validate :ensure_performance_targets_achievable
  end
  
  # Validation implementations
  defp validate_dspex_schema_fields(fields) when is_list(fields) do
    required_keys = [:name, :type]
    
    with :ok <- ensure_all_maps(fields),
         :ok <- ensure_required_keys_present(fields, required_keys),
         :ok <- validate_field_types(fields),
         :ok <- validate_field_constraints(fields) do
      :ok
    else
      error -> error
    end
  end
  
  defp validate_signature_specification(%{input: input, output: output} = spec) do
    with :ok <- validate_input_specification(input),
         :ok <- validate_output_specification(output),
         :ok <- validate_signature_consistency(spec) do
      :ok
    else
      error -> error
    end
  end
  
  defp ensure_schema_signature_compatibility(params) do
    schema_field_names = Enum.map(params.schema_fields, &Map.get(&1, :name))
    signature_field_names = extract_signature_field_names(params.signature_spec)
    
    case schema_field_names -- signature_field_names do
      [] -> {:ok, params}
      missing -> {:error, "Schema fields not covered by signature: #{inspect(missing)}"}
    end
  end
end

defmodule Foundation.Perimeter.External.JidoAgent do
  use Foundation.Perimeter
  
  external_contract :deploy_jido_agent do
    field :agent_spec, jido_agent_spec(),
      required: true
    
    field :deployment_config, :map,
      required: true,
      validate: &validate_deployment_configuration/1
    
    field :foundation_integration, foundation_integration_config(),
      required: true
    
    field :clustering_config, agent_clustering_config(),
      validate: &validate_clustering_viability/1
    
    field :resource_limits, :map,
      validate: &validate_resource_constraints/1
    
    field :monitoring_config, :map,
      validate: &validate_monitoring_configuration/1
    
    field :security_config, :map,
      validate: &validate_security_requirements/1
    
    # Complex cross-field validations
    validate :ensure_agent_foundation_compatibility
    validate :ensure_clustering_resource_compatibility
    validate :ensure_security_monitoring_consistency
    validate :ensure_deployment_feasibility
  end
  
  defp validate_deployment_configuration(%{strategy: strategy, target_nodes: nodes} = config) do
    with :ok <- validate_deployment_strategy(strategy),
         :ok <- validate_target_nodes(nodes),
         :ok <- validate_deployment_parameters(config) do
      :ok
    else
      error -> error
    end
  end
  
  defp ensure_agent_foundation_compatibility(params) do
    agent_capabilities = params.agent_spec.capabilities
    foundation_protocols = params.foundation_integration.protocol_bindings
    
    case validate_capability_protocol_mapping(agent_capabilities, foundation_protocols) do
      :ok -> {:ok, params}
      {:error, reason} -> {:error, "Agent-Foundation incompatibility: #{reason}"}
    end
  end
end

defmodule Foundation.Perimeter.External.Coordination do
  use Foundation.Perimeter
  
  external_contract :coordinate_agents do
    field :agent_group, {:list, :string},
      required: true,
      validate: &validate_agent_group_existence/1
    
    field :coordination_pattern, coordination_pattern(),
      required: true
    
    field :coordination_config, :map,
      required: true,
      validate: &validate_coordination_configuration/1
    
    field :foundation_context, foundation_context(),
      required: true
    
    field :performance_requirements, :map,
      validate: &validate_performance_requirements/1
    
    field :timeout_config, :map,
      validate: &validate_timeout_configuration/1
    
    field :economic_params, :map,
      when: [:auction],
      validate: &validate_economic_parameters/1
    
    # Advanced validations
    validate :ensure_coordination_pattern_agent_compatibility
    validate :ensure_foundation_coordination_support
    validate :ensure_performance_feasibility
    validate :ensure_economic_viability
  end
  
  defp validate_coordination_configuration(%{pattern: pattern} = config) do
    case pattern do
      :consensus -> validate_consensus_config(config)
      :pipeline -> validate_pipeline_config(config)
      :map_reduce -> validate_map_reduce_config(config)
      :auction -> validate_auction_config(config)
      :hierarchical -> validate_hierarchical_config(config)
    end
  end
  
  defp ensure_coordination_pattern_agent_compatibility(params) do
    pattern = params.coordination_pattern
    agent_count = length(params.agent_group)
    
    min_agents = case pattern do
      :consensus -> 3
      :auction -> 2
      :hierarchical -> 2
      _ -> 1
    end
    
    if agent_count >= min_agents do
      {:ok, params}
    else
      {:error, "Pattern #{pattern} requires at least #{min_agents} agents, got #{agent_count}"}
    end
  end
end

defmodule Foundation.Perimeter.Services.MABEAM do
  use Foundation.Perimeter
  
  strategic_boundary :coordinate_agent_system do
    field :agent_system_id, :string,
      required: true,
      format: :uuid
    
    field :coordination_context, :map,
      required: true,
      validate: &validate_coordination_context/1
    
    field :optimization_variables, {:list, ml_variable()},
      validate: &validate_variable_consistency/1
    
    field :performance_metrics, :map,
      validate: &validate_metrics_specification/1
    
    # Strategic validation only
    validate :ensure_agent_system_exists
    validate :ensure_coordination_resources_available
  end
  
  strategic_boundary :optimize_agent_coordination do
    field :optimization_request, :map,
      required: true,
      validate: &validate_optimization_request/1
    
    field :training_data, {:list, :map},
      validate: &validate_training_data_format/1
    
    field :strategy_config, :map,
      validate: &validate_strategy_configuration/1
    
    # Optimized validation for frequent operations
    validate :ensure_optimization_feasibility
  end
end

defmodule Foundation.Perimeter.Services.Registry do
  use Foundation.Perimeter
  
  strategic_boundary :register_foundation_service do
    field :service_id, foundation_service_id(),
      required: true
    
    field :service_spec, foundation_service_spec(),
      required: true
    
    field :registry_scope, :atom,
      required: true,
      values: [:local, :cluster, :global]
    
    field :clustering_config, foundation_clustering_config(),
      when: [:cluster, :global]
    
    validate :ensure_service_id_unique
    validate :ensure_service_spec_valid
  end
  
  strategic_boundary :lookup_foundation_service do
    field :service_id, foundation_service_id(),
      required: true
    
    field :lookup_scope, :atom,
      values: [:local, :cluster, :global],
      default: :local
    
    field :timeout_ms, :integer,
      range: 100..30_000,
      default: 5_000
    
    # Fast path validation
    validate :ensure_service_id_format_valid
  end
end

defmodule Foundation.Perimeter.ValidationEngine do
  @moduledoc """
  High-performance validation engine optimized for Foundation workloads.
  """
  
  # Compile-time validation function generation
  defmacro compile_validator(contract) do
    quote do
      def validate_compiled(data) do
        # Generated optimized validation code
        unquote(generate_validation_ast(contract))
      end
    end
  end
  
  # Cached validation for frequent operations
  def validate_with_cache(contract_module, contract_name, data) do
    cache_key = {contract_module, contract_name, :erlang.phash2(data)}
    
    case :ets.lookup(:foundation_validation_cache, cache_key) do
      [{^cache_key, result}] ->
        Foundation.Telemetry.increment([:foundation, :perimeter, :cache_hit])
        result
      
      [] ->
        Foundation.Telemetry.increment([:foundation, :perimeter, :cache_miss])
        result = perform_validation(contract_module, contract_name, data)
        :ets.insert(:foundation_validation_cache, {cache_key, result})
        result
    end
  end
  
  # AI-specific validation optimization
  def validate_ml_data_optimized(data, ml_contract) do
    # Optimized validation for ML data structures
    data
    |> validate_tensor_shapes()
    |> validate_probability_distributions()
    |> validate_variable_bounds()
    |> validate_ml_contract_compliance(ml_contract)
  end
end

defmodule Foundation.Perimeter.ErrorHandler do
  @moduledoc """
  Foundation-specific error handling with telemetry integration.
  """
  
  def handle_external_error(contract_name, violations, context) do
    error = %Foundation.Perimeter.Error{
      zone: :external,
      contract: contract_name,
      violations: violations,
      foundation_context: context,
      timestamp: DateTime.utc_now()
    }
    
    # Foundation telemetry integration
    Foundation.Telemetry.emit(
      [:foundation, :perimeter, :external_violation],
      %{violation_count: length(violations)},
      %{contract: contract_name, context: sanitize_context(context)}
    )
    
    # Foundation-specific error recovery
    case determine_error_severity(violations) do
      :critical -> trigger_foundation_circuit_breaker(contract_name)
      :warning -> log_foundation_warning(error)
      :info -> log_foundation_info(error)
    end
    
    {:error, error}
  end
  
  defp trigger_foundation_circuit_breaker(contract_name) do
    Foundation.Services.CircuitBreaker.trip(contract_name, :validation_failure)
  end
end