gem 'rhales'

# config/initializers/rhales.rb or similar
Rhales.configure do |config|
  config.default_locale = 'en'
  config.template_paths = ['templates']
  config.features = { dark_mode: true }
  config.site_host = 'example.com'

  # CSP configuration
  config.csp_enabled = true
  config.auto_nonce = true
end

# Optional: Configure logger
Rhales.logger = Rails.logger

# In your controller/route handler
view = Rhales::View.new(
  request,
  client: {
    greeting: 'Hello',
    userName: 'World'
  }
)

html = view.render('hello')
# Returns HTML with schema-validated data injected as window.appData

view = Rhales::View.new(
  request,
  server: {
    page_title: 'Dashboard',
    vite_assets_html: vite_javascript_tag('application'),
    admin_notes: 'Internal use only'  # Never sent to client
  }
)

view = Rhales::View.new(
  request,
  client: {
    user: current_user.name,
    items: Item.all.map(&:to_h)
  }
)

# ⚠️ DANGER: ALL client data serialized (including password!)
view = Rhales::View.new(request,
  client: {
    user: 'Alice',
    password: 'secret123',  # ← Serialized to browser!
    api_key: 'xyz'          # ← Serialized to browser!
  }
)

# Schema only validates structure, doesn't prevent serialization
# If schema doesn't include password/api_key, validation FAILS
# But data already leaked to browser in HTML response

# config/routes.rb (Rails) or route handler
class DashboardController < ApplicationController
  def show
    view = Rhales::View.new(
      request,
      client: {
        user: current_user.name,
        userId: current_user.id,
        items: current_user.items.map { |i|
          { id: i.id, name: i.name, price: i.price }
        },
        apiBaseUrl: ENV['API_BASE_URL']
      },
      server: {
        page_title: 'Dashboard',
        internal_notes: 'User has premium access',  # Server-only
        vite_assets: vite_javascript_tag('application')
      }
    )

    render html: view.render('dashboard').html_safe
  end
end

# config/initializers/rhales.rb
Rhales.configure do |config|
  config.template_paths = ['app/templates']
  config.default_locale = 'en'
end

# app/controllers/application_controller.rb
class ApplicationController < ActionController::Base
  def render_rhales(template_name, client: {}, server: {})
    view = Rhales::View.new(request, client: client, server: server)
    view.render(template_name)
  end
end

# In your controller
def dashboard
  html = render_rhales('dashboard',
    client: { user: current_user.name, items: @items },
    server: { page_title: 'Dashboard' }
  )
  render html: html.html_safe
end

# app.rb
require 'roda'
require 'rhales'

class App < Roda
  plugin :render

  Rhales.configure do |config|
    config.template_paths = ['templates']
    config.default_locale = 'en'
  end

  route do |r|
    r.on 'dashboard' do
      view = Rhales::View.new(
        request,
        client: { user: current_user.name },
        server: { page_title: 'Dashboard' }
      )
      view.render('dashboard')
    end
  end
end

require 'sinatra'
require 'rhales'

Rhales.configure do |config|
  config.template_paths = ['templates']
  config.default_locale = 'en'
end

helpers do
  def render_rhales(template_name, client: {}, server: {})
    view = Rhales::View.new(request, client: client, server: server)
    view.render(template_name)
  end
end

get '/dashboard' do
  render_rhales('dashboard',
    client: { user: 'Alice' },
    server: { page_title: 'Dashboard' }
  )
end

require 'grape'
require 'rhales'

Rhales.configure do |config|
  config.template_paths = ['templates']
  config.default_locale = 'en'
end

class MyAPI < Grape::API
  helpers do
    def render_rhales(template_name, client: {}, server: {})
      mock_request = OpenStruct.new(env: env)
      view = Rhales::View.new(mock_request, client: client, server: server)
      view.render(template_name)
    end
  end

  get '/dashboard' do
    content_type 'text/html'
    render_rhales('dashboard',
      client: { user: 'Alice' },
      server: { page_title: 'Dashboard' }
    )
  end
end

Rhales.configure do |config|
  config.csp_enabled = true     # Default: true
  config.auto_nonce = true      # Default: true
end

Rhales.configure do |config|
  config.csp_policy = {
    'default-src' => ["'self'"],
    'script-src' => ["'self'", "'nonce-{{nonce}}'", 'https://cdn.example.com'],
    'style-src' => ["'self'", "'nonce-{{nonce}}'"],
    'img-src' => ["'self'", 'data:', 'https://images.example.com'],
    'connect-src' => ["'self'", 'https://api.example.com']
  }
end

class ApplicationController < ActionController::Base
  after_action :set_csp_header

  private

  def set_csp_header
    csp_header = request.env['csp_header']
    response.headers['Content-Security-Policy'] = csp_header if csp_header
  end
end

class App < Roda
  def render_with_csp(template_name, **data)
    result = render_rhales(template_name, **data)
    csp_header = request.env['csp_header']
    response.headers['Content-Security-Policy'] = csp_header if csp_header
    result
  end
end

# Configure logger
Rhales.logger = Rails.logger  # or Logger.new($stdout)

# Example log output
INFO  View rendered: template=dashboard layout=main partials=[header,footer] duration_ms=15.2
WARN  Hydration schema mismatch: template=user_profile missing=[email] extra=[]
ERROR Template not found: template=missing_partial parent=dashboard
DEBUG Template cache hit: template=header

# test/test_helper.rb or spec/spec_helper.rb
require 'rhales'

Rhales.configure do |config|
  config.default_locale = 'en'
  config.app_environment = 'test'
  config.cache_templates = false
  config.template_paths = ['test/fixtures/templates']
end

# Minimal context for testing
context = Rhales::Context.minimal(
  client: { user: 'Test' },
  server: { page_title: 'Test Page' }
)

expect(context.get('user')).to eq('Test')
expect(context.get('page_title')).to eq('Test Page')

# Test inline template
template = '{{#if active}}Active{{else}}Inactive{{/if}}'
result = Rhales.render_template(template, active: true)
expect(result).to eq('Active')

# Test .rue file
mock_request = OpenStruct.new(env: {})
view = Rhales::View.new(mock_request, client: { message: 'Hello' })
html = view.render('test_template')
expect(html).to include('Hello')

# v0.4 (REMOVED)
view = Rhales::View.new(req, session, customer, 'en',
  props: { user: customer.name },
  app_data: { page_title: 'Dashboard' }
)

# v0.5 (Current)
view = Rhales::View.new(req,
  client: { user: customer.name },
  server: { page_title: 'Dashboard' }
)

# Set locale in request
req.env['rhales.locale'] = 'en'

# v0.4: Template interpolation
view = Rhales::View.new(req, sess, cust, 'en',
  props: { user: cust }  # Object reference, interpolated in <data>
)

# v0.5: Resolved values upfront
view = Rhales::View.new(req,
  client: {
    user: cust.name,      # Resolved value
    userId: cust.id       # Resolved value
  }
)

gem 'oj', '~> 3.13'

# Gemfile or application initialization
require 'oj'       # Load Oj first
require 'rhales'   # Rhales will detect and use Oj

Rhales::JSONSerializer.backend
# => :oj (if available) or :json (stdlib)