gem 'zen-service'

# app/services/todos/update.rb
module Todos
  class Update < ApplicationService # Base class for app services, inherits from Zen::Service
    attributes :todo, :params

    def call
      if todo.update(params)
        [:ok, todo]
      else
        [:error, todo.errors.messages]
      end
    end
  end
end

# app/controllers/todos_controller.rb
class TodosController < ApplicationController
  def update
    case Todos::Update.call(todo, params: todo_params)
    in [:ok, todo] then render json: Todos::Show.call(todo)
    in [:error, errors] then render json: errors, status: :unprocessable_content
    end
  end
end

class MyService < Zen::Service
  attributes :foo, :bar

  def call
    # Your business logic here
  end

  def foo
    super || 5 # Provide default value
  end
end

# Different ways to initialize services
s1 = MyService.new
s1.foo # => 5
s1.bar # => nil

s2 = MyService.new(6)
s2.foo # => 6
s2.bar # => nil

s3 = MyService.new(foo: 1, bar: 2)
s3.foo # => 1
s3.bar # => 2

# Create a new service from an existing one with some attributes changed
s4 = s3.with_attributes(bar: 3)
s4.foo # => 1
s4.bar # => 3

# Create a service from another service's attributes
s5 = MyService.from(s3)
s5.foo # => 1
s5.bar # => 2

class MyService < Zen::Service
  use :persisted_result, call_unless_called: true

  attributes :value

  def call
    value * 2
  end
end

service = MyService.new(5)
service.called? # => false
service.result  # => 10 (automatically calls #call)
service.called? # => true

class Logger < Zen::Service
  use :result_yielding

  # Will result with value return by `yield` expression
  def call
    Rails.logger.info("Starting operation")
    result = yield
    Rails.logger.info("Operation completed: #{result.inspect}")
  end
end

class UpdateTodo < Zen::Service
  attributes :todo, :params

  def call
    Logger.call do
      todo.update!(params)
      [:ok, todo]
    rescue ActiveRecord::RecordInvalid
      [:error, todo.errors.messages]
    end
  end
end

module CamelizeResult
  extend Zen::Service::Plugins::Plugin

  def self.used(service_class)
    service_class.prepend(Extension)
  end

  def self.camelize(obj)
    case obj
    when Array then obj.map { |item| camelize(item) }
    when Hash then obj.deep_transform_keys { |key| key.to_s.camelize(:lower).to_sym }
    else obj
    end
  end

  module Extension
    def call
      CamelizeResult.camelize(super)
    end
  end
end

class Todos::Show < Zen::Service
  attributes :todo

  use :camelize_result

  def call
    {
      id: todo.id,
      is_completed: todo.completed?
    }
  end
end

Todos::Show[todo] # => { id: 1, isCompleted: true }

# Register a plugin module
Zen::Service::Plugins.register(:my_plugin, MyPlugin)

# Register by class name (useful when autoload isn't available yet, e.g., during Rails initialization)
Zen::Service::Plugins.register(:my_plugin, "MyApp::Services::MyPlugin")

class BaseService < Zen::Service
  use :persisted_result, call_unless_called: false
end

class ChildService < BaseService
  use :persisted_result, call_unless_called: true  # Reconfigures without re-including
end

module MyPlugin
  extend Zen::Service::Plugins::Plugin

  # Override the auto-generated registration name
  register_as :custom_name

  # Set default options
  default_options foo: 5, bar: false

  # Called when plugin is first used on a class
  def self.used(service_class, **options, &block)
    # Include/prepend modules, add class methods, etc.
  end

  # Called every time the plugin is used (including on child classes)
  def self.configure(service_class, **options, &block)
    # Configure behavior based on options
  end
end