def deps do
  [
    {:spark, "~> 2.2.65"},
    {:igniter, "~> 0.6.6", only: [:dev]}  # Required for generators
  ]
end

# 1. Define your DSL extension
defmodule MyApp.Validator.Dsl do
  defmodule Field do
    defstruct [:name, :type, :validate]
  end

  @field %Spark.Dsl.Entity{
    name: :field,
    args: [:name, :type],
    target: Field,
    schema: [
      name: [type: :atom, required: true],
      type: [type: {:one_of, [:string, :integer]}, required: true],
      validate: [type: {:fun, 1}]
    ]
  }

  @fields %Spark.Dsl.Section{
    name: :fields,
    entities: [@field]
  }

  use Spark.Dsl.Extension, sections: [@fields]
end

# 2. Create your DSL module
defmodule MyApp.Validator do
  use Spark.Dsl, default_extensions: [
    extensions: [MyApp.Validator.Dsl]
  ]
end

# 3. Use your DSL immediately
defmodule MyApp.PersonValidator do
  use MyApp.Validator

  fields do
    field :name, :string, validate: &(String.length(&1) > 0)
    field :age, :integer, validate: &(&1 >= 0)
  end
end

use Spark.Dsl.Extension,
  sections: [@users, @permissions],
  transformers: [MyApp.Transformers.AddDefaults],
  verifiers: [MyApp.Verifiers.ValidatePermissions]

defmodule MyApp.Transformers.AddTimestamps do
  use Spark.Dsl.Transformer

  def transform(dsl_state) do
    {:ok, 
     dsl_state
     |> add_entity([:fields], %Field{name: :inserted_at, type: :utc_datetime})
     |> add_entity([:fields], %Field{name: :updated_at, type: :utc_datetime})}
  end
end

defmodule MyApp.Verifiers.ValidateUniqueness do
  use Spark.Dsl.Verifier

  def verify(dsl_state) do
    field_names = MyApp.Info.fields(dsl_state) |> Enum.map(& &1.name)
    
    case find_duplicates(field_names) do
      [] -> :ok
      duplicates -> 
        {:error, 
         Spark.Error.DslError.exception(
           message: "Duplicate field names: #{inspect(duplicates)}",
           path: [:fields]
         )}
    end
  end
end

defmodule MyApp.Validator.Info do
  use Spark.InfoGenerator, 
    extension: MyApp.Validator.Dsl, 
    sections: [:fields]
end

# Automatically generates:
# - fields(module)          # Get all fields
# - fields!(module)         # Get all fields or raise
# - field(module, name)     # Get specific field
# - field!(module, name)    # Get specific field or raise

@validation %Spark.Dsl.Entity{
  name: :validation,
  args: [:type],
  entities: [
    rule: @rule,
    condition: @condition
  ]
}

schema: [
  timeout: [
    type: :pos_integer,
    default: 5000,
    doc: "Request timeout in milliseconds"
  ],
  retries: [
    type: {:custom, __MODULE__, :validate_retries, []},
    default: 3
  ]
]

def transform(dsl_state) do
  if has_section?(dsl_state, :authentication) do
    add_security_transformations(dsl_state)
  else
    {:ok, dsl_state}
  end
end

defmodule MyApp.API do
  use MyApp.ApiDsl

  api do
    version "v1"
    base_url "/api/v1"
    
    authentication do
      type :bearer_token
      required true
    end

    resources do
      resource :users do
        endpoint :list, method: :get, path: "/users"
        endpoint :create, method: :post, path: "/users"
        endpoint :show, method: :get, path: "/users/:id"
        
        permissions do
          action :list, roles: [:user, :admin]
          action :create, roles: [:admin]
          action :show, roles: [:owner, :admin]
        end
      end
    end
  end
end

defmodule MyApp.Config do
  use MyApp.ConfigDsl

  config do
    environment :production do
      database do
        host "prod-db.example.com"
        pool_size 20
        ssl true
      end
      
      cache do
        adapter :redis
        cluster ["redis1.example.com", "redis2.example.com"]
        ttl :timer.hours(24)
      end
    end

    feature_flags do
      flag :new_ui, default: false, rollout: 0.1
      flag :advanced_search, default: true
    end
  end
end

defmodule MyApp.OrderWorkflow do
  use MyApp.WorkflowDsl

  workflow do
    initial_state :pending

    states do
      state :pending do
        on_enter &send_confirmation_email/1
        transitions [:processing, :cancelled]
      end

      state :processing do
        timeout :timer.minutes(30)
        on_timeout &transition_to_failed/1
        transitions [:shipped, :failed]
      end

      state :shipped do
        final true
        on_enter &send_tracking_info/1
      end
    end

    transitions do
      transition :process_order, from: :pending, to: :processing do
        validate &valid_payment?/1
        action &charge_payment/1
      end

      transition :ship_order, from: :processing, to: :shipped do
        validate &inventory_available?/1
        action &create_shipment/1
      end
    end
  end
end

# Basic DSL
resource :users

# Enhanced with transformers
resource :users do
  timestamps true
  soft_delete true
  auditing enabled: true
end

# Auto-generated with defaults
# - created_at, updated_at fields
# - deleted_at field with queries
# - audit_log association

# Environment-aware DSL
config do
  if Application.get_env(:my_app, :env) == :test do
    database :memory
    external_apis :mock
  else
    database :postgres
    external_apis :live
  end
end

defmodule MyApp.BaseResource do
  use MyApp.ResourceDsl

  resource do
    timestamps true
    soft_delete true
  end
end

defmodule MyApp.UserResource do
  use MyApp.ResourceDsl
  extends MyApp.BaseResource

  resource do
    field :email, :string, unique: true
    field :name, :string
  end
end

defmodule MyApp.FormDsl do
  use Spark.Dsl

  form do
    field :name, :string, required: true
    field :email, :email, validate: &valid_email?/1
    
    submit "Save User" do
      on_success &handle_success/2
      on_error &handle_error/2
    end
  end
end

defmodule MyApp.SchemaDsl do
  use Spark.Dsl

  schema do
    field :title, :string
    field :body, :text
    
    belongs_to :author, MyApp.User
    has_many :comments, MyApp.Comment
    
    timestamps()
  end
end

defmodule MyApp.ValidatorTest do
  use ExUnit.Case

  defmodule TestValidator do
    use MyApp.Validator

    fields do
      field :name, :string
      field :age, :integer
    end
  end

  test "fields are accessible via Info module" do
    fields = MyApp.Validator.Info.fields(TestValidator)
    assert length(fields) == 2
    assert Enum.find(fields, &(&1.name == :name))
  end
end

defmodule MyApp.TransformerPropertyTest do
  use ExUnit.Case
  use PropCheck

  property "transformer preserves entity count" do
    forall entities <- list_of_entities() do
      dsl_state = build_dsl_state(entities)
      {:ok, transformed} = MyApp.Transformer.transform(dsl_state)
      
      original_count = count_entities(dsl_state)
      transformed_count = count_entities(transformed)
      
      transformed_count >= original_count
    end
  end
end

defmodule MyApp.DSLIntegrationTest do
  use ExUnit.Case

  test "complete DSL compilation workflow" do
    # Test that DSL compiles without errors
    assert Code.ensure_loaded?(MyApp.ComplexDsl)
    
    # Test that generated functions work
    result = MyApp.ComplexDsl.process(%{input: "test"})
    assert {:ok, _} = result
    
    # Test introspection capabilities
    entities = MyApp.ComplexDsl.Info.entities()
    assert is_list(entities)
  end
end

# config/prod.exs
config :my_app, :spark,
  compile_time_validations: true,
  generate_docs: false,
  cache_info_modules: true

defmodule MyApp.SparkTelemetry do
  def setup do
    :telemetry.attach_many(
      "spark-events",
      [
        [:spark, :dsl, :compile],
        [:spark, :transformer, :execute],
        [:spark, :verifier, :validate]
      ],
      &handle_event/4,
      nil
    )
  end

  def handle_event([:spark, :dsl, :compile], measurements, metadata, _config) do
    Logger.info("DSL compilation completed", 
      module: metadata.module,
      duration: measurements.duration
    )
  end
end

defmodule MyApp.ErrorHandler do
  def handle_dsl_error(%Spark.Error.DslError{} = error) do
    Logger.error("DSL Error: #{error.message}", 
      module: error.module,
      path: error.path
    )
    
    # Send to error tracking service
    ErrorTracker.capture_exception(error)
  end
end