gem 'action_webhook'

# app/webhooks/user_webhook.rb
class UserWebhook < ActionWebhook::Base
  def user_created
    @user = params[:user]
    @timestamp = Time.current

    endpoints = [
      {
        url: 'https://api.example.com/webhooks',
        headers: {
          'Authorization' => 'Bearer your-token',
          'Content-Type' => 'application/json'
        }
      }
    ]

    deliver(endpoints)
  end
end

# Immediate delivery
UserWebhook.user_created(user: @user).deliver_now

# Background delivery (recommended)
UserWebhook.user_created(user: @user).deliver_later

# With custom queue
UserWebhook.user_created(user: @user).deliver_later(queue: 'webhooks')

class PaymentWebhook < ActionWebhook::Base
  # Configure retry behavior
  self.max_retries = 5
  self.retry_delay = 30.seconds
  self.retry_backoff = :exponential  # :exponential, :linear, or :fixed
  self.retry_jitter = 5.seconds      # Adds randomness to prevent thundering herd

  def payment_completed
    @payment = params[:payment]

    endpoints = [
      { url: 'https://accounting.example.com/webhooks' },
      { url: 'https://analytics.example.com/webhooks' },
      { url: 'https://notifications.example.com/webhooks' }
    ]

    deliver(endpoints)
    # If only analytics.example.com fails, only that URL will be retried
  end
end

class OrderWebhook < ActionWebhook::Base
  # Called immediately when any URLs succeed
  after_deliver :handle_successful_deliveries

  # Called when retries are exhausted for failed URLs
  after_retries_exhausted :handle_permanent_failures

  def order_created
    @order = params[:order]
    deliver(webhook_endpoints)
  end

  private

  def handle_successful_deliveries(successful_responses)
    successful_responses.each do |response|
      Rails.logger.info "Webhook delivered to #{response[:url]} (#{response[:status]})"
    end
  end

  def handle_permanent_failures(failed_responses)
    failed_responses.each do |response|
      Rails.logger.error "Webhook permanently failed for #{response[:url]} after #{response[:attempt]} attempts"
      AdminMailer.webhook_failure(@order.id, response).deliver_later
    end
  end
end

class MyWebhook < ActionWebhook::Base
  self.debug_headers = true  # Enable header debugging

  def user_created
    @user = params[:user]
    endpoints = [
      {
        url: 'https://api.example.com/webhooks',
        headers: [
          { 'key' => 'Authorization', 'value' => 'Bearer token123' },
          { 'key' => 'X-Custom-Header', 'value' => 'debug-mode' }
        ]
      }
    ]
    deliver(endpoints)
  end
end

class NotificationWebhook < ActionWebhook::Base
  def user_registered
    @user = params[:user]

    endpoints = [
      {
        url: 'https://analytics.example.com/events',
        headers: { 'X-API-Key' => Rails.application.credentials.analytics_key }
      },
      {
        url: 'https://crm.example.com/webhooks',
        headers: { 'Authorization' => "Bearer #{Rails.application.credentials.crm_token}" }
      },
      {
        url: 'https://marketing.example.com/api/events',
        headers: { 'X-Service-Token' => Rails.application.credentials.marketing_token }
      }
    ]

    deliver(endpoints)
    # If marketing.example.com fails but others succeed,
    # only marketing.example.com will be retried
  end
end

class OrderWebhook < ActionWebhook::Base
  self.max_retries = 3
  self.retry_delay = 30.seconds
  self.retry_backoff = :exponential

  after_deliver :log_successful_integrations
  after_retries_exhausted :handle_integration_failures

  def order_placed
    @order = params[:order]

    endpoints = [
      { url: 'https://inventory.company.com/webhooks' },      # Update inventory
      { url: 'https://shipping.company.com/api/orders' },     # Create shipping label
      { url: 'https://analytics.company.com/events' },       # Track conversion
      { url: 'https://email.company.com/order-confirmation' }, # Send confirmation
      { url: 'https://accounting.company.com/webhooks' }     # Update books
    ]

    deliver(endpoints)
  end

  private

  def log_successful_integrations(responses)
    responses.each do |response|
      OrderIntegration.create!(
        order: @order,
        service_url: response[:url],
        status: 'success',
        http_status: response[:status],
        attempt: response[:attempt]
      )
    end
  end

  def handle_integration_failures(responses)
    responses.each do |response|
      OrderIntegration.create!(
        order: @order,
        service_url: response[:url],
        status: 'failed',
        error_message: response[:error],
        final_attempt: response[:attempt]
      )

      # Alert based on criticality
      case response[:url]
      when /inventory|accounting/
        CriticalAlert.webhook_failure(@order, response)
      else
        StandardAlert.webhook_failure(@order, response)
      end
    end
  end
end

endpoints = [
  {
    url: 'https://api.example.com/webhooks',
    headers: {
      'Authorization' => 'Bearer token123',
      'Content-Type' => 'application/json',
      'X-Custom-Header' => 'custom-value'
    }
  }
]

endpoints = [
  {
    url: 'https://api.example.com/webhooks',
    headers: [
      { 'key' => 'Authorization', 'value' => 'Bearer token123' },
      { 'key' => 'Content-Type', 'value' => 'application/json' },
      { 'key' => 'X-Custom-Header', 'value' => 'custom-value' }
    ]
  }
]

headers: [
  { key: 'Authorization', value: 'Bearer token123' },
  { key: 'Content-Type', value: 'application/json' }
]

# In your test files
require 'action_webhook/test_helper'

class UserWebhookTest < ActiveSupport::TestCase
  include ActionWebhook::TestHelper

  test "user_created webhook sends correct payload" do
    user = users(:john)

    # Test immediate delivery
    webhook = UserWebhook.user_created(user: user)

    assert_enqueued_webhook_deliveries 1 do
      webhook.deliver_later
    end

    # Test payload content
    perform_enqueued_webhook_deliveries do
      webhook.deliver_later
    end

    # Verify webhook was sent
    assert_webhook_delivered UserWebhook, :user_created
  end
end