group :development, :test do
  gem 'query_guard'
end

QueryGuard.configure do |config|
  # Directory where migrations live (default: db/migrate)
  config.migrations_directory = 'db/migrate'

  # Environments to analyze (default: [:development, :test])
  config.enabled_environments = [:development, :test]

  # Max queries to check per request (prevent timeouts)
  config.max_queries_per_request = 100

  # Max query duration in ms before flagging as slow
  config.max_duration_ms_per_query = 5000
end

gem "query_guard"

QueryGuard.configure do |config|
  # Environments where QueryGuard should be active
  config.enabled_environments = %i[development test production]

  # === Budget System (New in v2) ===
  # Define query budgets/SLOs for specific endpoints or jobs
  
  # Controller actions
  config.budget.for("users#index", count: 10, duration_ms: 500)
  config.budget.for("posts#show", count: 5, duration_ms: 200)
  config.budget.for("admin/reports#dashboard", count: 50, duration_ms: 2000)
  
  # Background jobs
  config.budget.for_job("EmailJob", count: 20, duration_ms: 1000)
  config.budget.for_job("DataExportJob", count: 100, duration_ms: 5000)
  
  # Budget enforcement mode
  config.budget.mode = :log       # :log (warn only), :notify (callback), :raise (exception)
  
  # Optional: callback for :notify mode
  config.budget.on_violation = ->(key, violation) {
    # Send to error tracker, metrics service, etc.
    Honeybadger.notify("Budget violation", context: { key: key, violation: violation })
  }

  # === Legacy Limits (Still Supported) ===
  config.max_queries_per_request = 100
  config.max_duration_ms_per_query = 100.0
  config.block_select_star = true
  
  # Ignore certain SQL patterns
  config.ignored_sql = [
    /^PRAGMA /i,
    /^BEGIN/i,
    /^COMMIT/i,
    /^SHOW /i
  ]

  # === Security Features ===
  config.enable_security = true
  config.detect_sql_injection = true
  config.detect_unusual_query_pattern = true
  config.detect_data_exfiltration = true
  config.detect_mass_assignment = true

  # === Export Configuration ===
  config.base_url = ENV["QUERY_GUARD_API_URL"]
  config.api_key = ENV["QUERY_GUARD_API_KEY"]
  config.project = "my_app"
  config.env = Rails.env
  
  # Logging
  config.raise_on_violation = false  # Set to true in CI
  config.log_prefix = "[QueryGuard]"
end

# In config/initializers/query_guard.rb
QueryGuard.configure do |config|
  # Set budgets for controller actions
  config.budget.for("users#index", count: 10, duration_ms: 500)
  config.budget.for("posts#show", count: 5, duration_ms: 200)
  
  # Set budgets for background jobs
  config.budget.for_job("EmailJob", count: 20)
  config.budget.for_job("ReportJob", count: 100, duration_ms: 5000)
  
  # Choose enforcement mode
  config.budget.mode = :log  # Options: :log, :notify, :raise
end

config.budget.mode = :notify
config.budget.on_violation = ->(key, violation) {
  # Send to your monitoring service
  Datadog::Statsd.new.increment("query_guard.budget.exceeded", tags: ["endpoint:#{key}"])
  
  # Or send to error tracker
  Sentry.capture_message("Budget exceeded", extra: { key: key, violation: violation })
}

# In Rails console or tests
result, report = QueryGuard.trace("load active users") do
  User.where(active: true).limit(100).to_a
end

puts "Queries executed: #{report.query_count}"
puts "Total duration: #{report.total_duration_ms}ms"
puts "Violations: #{report.violations.inspect}"
puts "Queries:"
report.queries.each do |q|
  puts "  #{q[:duration_ms]}ms: #{q[:sql]}"
end

result, report = QueryGuard.trace("process batch", context: { batch_id: 123, user_id: 456 }) do
  Batch.find(123).process!
end

# Context is included in the report for correlation
puts report.context  # => { batch_id: 123, user_id: 456 }

require "query_guard/rspec"

RSpec.describe UsersController, type: :controller do
  describe "GET #index" do
    it "stays within query budget" do
      expect {
        get :index
      }.to_not exceed_query_budget(count: 10, duration_ms: 500)
    end
    
    # Or use named budgets defined in config
    it "respects users#index budget" do
      expect {
        get :index
      }.to_not exceed_query_budget("users#index")
    end
  end
end

RSpec.describe "batch processing" do
  it "processes batch efficiently" do
    report = within_query_budget(count: 50, duration_ms: 2000) do
      Batch.process_all
    end
    
    expect(report.query_count).to be < 50
  end
end

# In console or background job
QueryGuard::Fingerprint.record("SELECT * FROM users WHERE id = 123", 45.2)
QueryGuard::Fingerprint.record("SELECT * FROM users WHERE id = 456", 32.1)

# Get stats for a specific fingerprint
fp = QueryGuard::Fingerprint.generate("SELECT * FROM users WHERE id = ?")
stats = QueryGuard::Fingerprint.stats_for(fp)

puts stats[:count]              # => 2
puts stats[:total_duration_ms]  # => 77.3
puts stats[:min_duration_ms]    # => 32.1
puts stats[:max_duration_ms]    # => 45.2
puts stats[:first_seen_at]
puts stats[:last_seen_at]

# Get top queries by various metrics
QueryGuard::Fingerprint.top_by_count(10)         # Most frequently executed
QueryGuard::Fingerprint.top_by_duration(10)      # Highest total time
QueryGuard::Fingerprint.top_by_avg_duration(10)  # Slowest on average

# These all produce the same fingerprint:
QueryGuard::Fingerprint.generate("SELECT * FROM users WHERE id = 1")
QueryGuard::Fingerprint.generate("SELECT * FROM users WHERE id = 999")
QueryGuard::Fingerprint.generate("SELECT  *  FROM users WHERE id = 42")
# All normalize to: "select * from users where id = ?"

config.enable_security = true
config.detect_sql_injection = true
config.detect_unusual_query_pattern = true
config.max_queries_per_minute_per_actor = 300

# Custom actor resolver
config.actor_resolver = ->(env) {
  env["warden"].user&.id || env["action_dispatch.remote_ip"]
}

config.base_url = "https://your-monitoring-service.com"
config.api_key = ENV["MONITORING_API_KEY"]
config.project = "my_rails_app"
config.env = Rails.env
config.export_mode = :async  # Don't block requests

# In Rails console
result, report = QueryGuard.trace("diagnose N+1") do
  Post.limit(10).each { |post| post.comments.to_a }
end

puts "Queries: #{report.query_count}"  # Spot N+1 problems immediately
report.queries.each { |q| puts q[:sql] }

# spec/support/query_guard.rb
RSpec.configure do |config|
  config.around(:each, :query_budget) do |example|
    metadata = example.metadata
    budget = metadata[:query_budget]
    
    expect {
      example.run
    }.to_not exceed_query_budget(**budget)
  end
end

# spec/controllers/users_controller_spec.rb
RSpec.describe UsersController do
  describe "GET #index", :query_budget, query_budget: { count: 5, duration_ms: 200 } do
    it "loads users" do
      get :index
      expect(response).to be_successful
    end
  end
end

# config/initializers/query_guard.rb
QueryGuard.configure do |config|
  config.enabled_environments = [:production]
  config.budget.mode = :notify
  
  config.budget.for("api/v1/users#index", count: 10, duration_ms: 100)
  config.budget.for("api/v1/posts#feed", count: 15, duration_ms: 150)
  
  config.budget.on_violation = ->(key, violation) {
    # Alert when budgets exceeded in production
    Datadog::Statsd.new.increment("query.budget.exceeded", tags: [
      "endpoint:#{key}",
      "type:#{violation[:type]}"
    ])
  }
end

require "query_guard/rspec"

expect { code }.to_not exceed_query_budget(count: 10)
expect { code }.to_not exceed_query_budget(count: 10, duration_ms: 500)
expect { code }.to_not exceed_query_budget("users#index")

report = within_query_budget(count: 10) { code }