gem 'rack-ai'

require 'rack/ai'

# Configure Rack::AI
Rack::AI.configure do |config|
  config.provider = :openai
  config.api_key = ENV['OPENAI_API_KEY']
  config.features = [:classification, :security, :moderation]
end

# Add to your Rack application
use Rack::AI::Middleware

# config/application.rb
class Application < Rails::Application
  config.middleware.use Rack::AI::Middleware,
    provider: :openai,
    api_key: ENV['OPENAI_API_KEY'],
    features: [:classification, :moderation, :security]
end

require 'sinatra'
require 'rack/ai'

class MyApp < Sinatra::Base
  use Rack::AI::Middleware,
    provider: :openai,
    api_key: ENV['OPENAI_API_KEY'],
    features: [:classification, :security]
    
  get '/' do
    ai_results = request.env['rack.ai'][:results]
    "Classification: #{ai_results[:classification][:classification]}"
  end
end

Rack::AI.configure do |config|
  # Provider settings
  config.provider = :openai  # :openai, :huggingface, :local
  config.api_key = ENV['OPENAI_API_KEY']
  config.timeout = 30
  config.retries = 3

  # Feature toggles
  config.features = [:classification, :moderation, :security, :caching]
  config.fail_safe = true
  config.async_processing = true

  # Security settings
  config.sanitize_logs = true
  config.allowed_data_types = [:headers, :query_params]

  # Feature-specific configuration
  config.classification.confidence_threshold = 0.8
  config.moderation.toxicity_threshold = 0.7
  config.caching.redis_url = ENV['REDIS_URL']
end

# config/environments/production.rb
Rack::AI.configure do |config|
  config.provider = :openai
  config.timeout = 10  # Shorter timeout in production
  config.explain_decisions = false
  config.sanitize_logs = true
end

# config/environments/development.rb
Rack::AI.configure do |config|
  config.provider = :local
  config.api_url = 'http://localhost:8080'
  config.explain_decisions = true
  config.log_level = :debug
end

Rack::AI.configure do |config|
  config.provider = :openai
  config.api_key = ENV['OPENAI_API_KEY']
  # Optional: config.api_url = 'https://api.openai.com/v1'
end

Rack::AI.configure do |config|
  config.provider = :huggingface
  config.api_key = ENV['HUGGINGFACE_API_KEY']
end

Rack::AI.configure do |config|
  config.provider = :local
  config.api_url = 'http://localhost:8080'
end

# Access classification results
ai_results = request.env['rack.ai'][:results]
classification = ai_results[:classification]

case classification[:classification]
when :human
  # Handle human user
when :bot
  # Handle bot request
when :spam
  # Block or handle spam
when :suspicious
  # Apply additional security measures
end

security = ai_results[:security]

if security[:threat_level] == :high
  # Block request immediately
  halt 403, 'Security threat detected'
elsif security[:threat_level] == :medium
  # Apply additional verification
  require_captcha
end

# Check specific threats
if security[:injection_detection][:threats].include?('sql_injection')
  log_security_incident(request)
end

moderation = ai_results[:moderation]

if moderation[:flagged]
  categories = moderation[:categories]
  
  if categories['hate']
    reject_content('Hate speech detected')
  elsif categories['violence']
    flag_for_review(content)
  end
end

caching = ai_results[:caching]

if caching[:should_prefetch]
  # Schedule prefetching for predicted requests
  PrefetchJob.perform_later(caching[:pattern_analysis])
end

if caching[:cache_hit]
  # Use cached AI analysis
  cached_result = caching[:cached_result]
end

class CustomAIMiddleware
  def initialize(app)
    @app = app
  end

  def call(env)
    # Add custom context for AI processing
    env['rack.ai.custom'] = {
      user_tier: extract_user_tier(env),
      api_version: extract_api_version(env)
    }

    status, headers, body = @app.call(env)

    # Process AI results
    ai_results = env['rack.ai'][:results]
    handle_ai_insights(ai_results)

    [status, headers, body]
  end
end

use Rack::AI::Middleware,
  provider: :openai,
  api_key: ENV['OPENAI_API_KEY'],
  features: [:classification, :security],
  condition: ->(env) { 
    # Only process API requests
    env['PATH_INFO'].start_with?('/api/')
  }

# Primary provider with fallback
primary_config = {
  provider: :openai,
  api_key: ENV['OPENAI_API_KEY']
}

fallback_config = {
  provider: :local,
  api_url: 'http://localhost:8080'
}

use Rack::AI::Middleware, primary_config
use Rack::AI::FallbackMiddleware, fallback_config

# Access metrics
metrics = Rack::AI::Utils::Metrics

# Request processing metrics
processing_time = metrics.get_histogram_stats('rack_ai.processing_time')
request_count = metrics.get_counter('rack_ai.requests_processed')

# Feature-specific metrics
classification_accuracy = metrics.get_histogram_stats('rack_ai.feature.classification.confidence')
security_threats = metrics.get_counter('rack_ai.feature.security.threats_detected')

# Export metrics in Prometheus format
get '/metrics' do
  content_type 'text/plain'
  Rack::AI::Utils::Metrics.export_prometheus_format
end

# Enhanced logging with AI context
class AILogger < Rack::AI::Utils::Logger
  def self.log_request(env, ai_results)
    info('AI-enhanced request processed', {
      path: env['PATH_INFO'],
      classification: ai_results[:classification][:classification],
      threat_level: ai_results[:security][:threat_level],
      processing_time: ai_results[:processing_time]
    })
  end
end

# Enable async processing for better performance
Rack::AI.configure do |config|
  config.async_processing = true
  config.timeout = 5  # Shorter timeout for async
end

# Enable only necessary features
Rack::AI.configure do |config|
  # Lightweight configuration
  config.features = [:classification, :security]
  
  # Heavy configuration (includes caching, enhancement)
  # config.features = [:classification, :moderation, :security, :caching, :enhancement]
end

# Cache AI analysis results
Rack::AI.configure do |config|
  config.cache_enabled = true
  config.cache_ttl = 3600  # 1 hour
  config.caching.redis_url = ENV['REDIS_URL']
end

# Graceful degradation when AI services are unavailable
Rack::AI.configure do |config|
  config.fail_safe = true  # Continue processing even if AI fails
  config.timeout = 10      # Reasonable timeout
  config.retries = 2       # Limited retries
end

class AIErrorHandler
  def initialize(app)
    @app = app
  end

  def call(env)
    @app.call(env)
  rescue Rack::AI::ProviderError => e
    # Handle AI provider errors
    [503, {}, ['AI service temporarily unavailable']]
  rescue Rack::AI::ConfigurationError => e
    # Handle configuration errors
    [500, {}, ['AI configuration error']]
  end
end

Rack::AI.configure do |config|
  # Sanitize sensitive data before sending to AI
  config.sanitize_logs = true
  config.allowed_data_types = [:headers, :query_params]
  config.blocked_data_types = [:body, :cookies]
end

# Use environment variables for API keys
Rack::AI.configure do |config|
  config.api_key = ENV['OPENAI_API_KEY']
  # Never hardcode API keys in your application
end

Rack::AI.configure do |config|
  config.rate_limit = 1000  # Requests per minute
  config.security.rate_limit = 100  # Lower limit for security analysis
end

# spec/spec_helper.rb
RSpec.configure do |config|
  config.before(:each) do
    Rack::AI.configure do |config|
      config.provider = :local
      config.api_url = 'http://localhost:8080'
      config.features = []  # Disable AI in tests
      config.fail_safe = true
    end
  end
end

# Mock AI provider responses
RSpec.describe 'AI Integration' do
  before do
    allow_any_instance_of(Rack::AI::Providers::OpenAI)
      .to receive(:classify_request)
      .and_return({
        classification: :human,
        confidence: 0.9,
        provider: :openai
      })
  end

  it 'processes requests with AI' do
    get '/api/test'
    expect(last_response.headers['X-AI-Classification']).to eq('human')
  end
end