gem "interactor-validation"

class CreateUser
  include Interactor
  include Interactor::Validation

  # Declare expected parameters
  params :email, :username, :age

  # Define validation rules
  validates :email, presence: true, format: { with: /@/ }
  validates :username, presence: true, length: { maximum: 100 }
  validates :age, numericality: { greater_than: 0 }

  def call
    # Validations run automatically before this
    User.create!(email: email, username: username, age: age)
  end
end

result = CreateUser.call(email: "", username: "", age: -5)
result.failure? # => true
result.errors   # => Array of error hashes

result.errors
# => [
#      { attribute: :email, type: :blank, message: "Email can't be blank" },
#      { attribute: :username, type: :blank, message: "Username can't be blank" },
#      { attribute: :age, type: :greater_than, message: "Age must be greater than 0" }
#    ]

# Set mode to :code in configuration
Interactor::Validation.configure { |config| config.mode = :code }

result.errors
# => [
#      { code: 'EMAIL_IS_REQUIRED' },
#      { code: 'USERNAME_IS_REQUIRED' },
#      { code: 'AGE_MUST_BE_GREATER_THAN_0' }
#    ]

validates :name, presence: true
validates :email, presence: { message: "Email is required" }

validates :email, format: { with: /\A[\w+\-.]+@[a-z\d\-]+(\.[a-z\d\-]+)*\.[a-z]+\z/i }
validates :username, format: { with: /\A[a-z0-9_]+\z/, message: "Invalid username" }

validates :password, length: { minimum: 8, maximum: 128 }
validates :code, length: { is: 6 }
validates :bio, length: { maximum: 500 }

validates :status, inclusion: { in: %w[active pending inactive] }
validates :role, inclusion: { in: ["admin", "user", "guest"], message: "Invalid role" }

validates :age, numericality: { greater_than: 0 }
validates :price, numericality: { greater_than_or_equal_to: 0 }
validates :quantity, numericality: { greater_than: 0, less_than_or_equal_to: 100 }
validates :rating, numericality: { equal_to: 5 }
validates :count, numericality: true  # Just verify it's numeric

# Shorthand: 'numeric' alias
validates :age, numeric: { greater_than: 0 }

validates :is_active, boolean: true
validates :terms_accepted, boolean: true

class CreateUser
  include Interactor
  include Interactor::Validation

  params :user

  validates :user, presence: true do
    attribute :name, presence: true
    attribute :email, format: { with: /@/ }
    attribute :age, numericality: { greater_than: 0 }
  end

  def call
    User.create!(user)
  end
end

result = CreateUser.call(user: { name: "", email: "bad" })
result.errors
# => [
#      { attribute: :"user.name", type: :blank, message: "User name can't be blank" },
#      { attribute: :"user.email", type: :invalid, message: "User email is invalid" }
#    ]

class BulkCreateItems
  include Interactor
  include Interactor::Validation

  params :items

  validates :items do
    attribute :name, presence: true
    attribute :price, numericality: { greater_than: 0 }
  end

  def call
    items.each { |item| Item.create!(item) }
  end
end

result = BulkCreateItems.call(items: [
  { name: "Widget", price: 10 },
  { name: "", price: -5 }
])
result.errors
# => [
#      { attribute: :"items[1].name", type: :blank, message: "Items[1] name can't be blank" },
#      { attribute: :"items[1].price", type: :greater_than, message: "Items[1] price must be greater than 0" }
#    ]

class CreateOrder
  include Interactor
  include Interactor::Validation

  params :product_id, :quantity, :user_id

  validates :product_id, presence: true
  validates :quantity, numericality: { greater_than: 0 }
  validates :user_id, presence: true

  def validate!
    # Parameter validations have already run at this point
    # No need to call super - there is no parent validate! method

    product = Product.find_by(id: product_id)
    if product.nil?
      errors.add(:product_id, :not_found, message: "Product not found")
    elsif product.stock < quantity
      errors.add(:quantity, :insufficient, message: "Insufficient stock")
    end
  end

  def call
    Order.create!(product_id: product_id, quantity: quantity, user_id: user_id)
  end
end

class CreateUser
  include Interactor
  include Interactor::Validation

  # Option 1: Using configure block
  configure do |config|
    config.halt = true
    config.mode = :code
  end

  # Option 2: Using dedicated methods
  validation_halt true
  validation_mode :code
  validation_skip_validate false

  # ... validations and call method
end

Interactor::Validation.configure do |config|
  config.skip_validate = true  # Skip custom validate! if params fail (default: true)
  config.mode = :default       # Error format: :default or :code (default: :default)
  config.halt = false          # Stop on first error (default: false)
end

Interactor::Validation.configure do |config|
  config.skip_validate = false  # Always run custom validate! even if params fail
end

Interactor::Validation.configure do |config|
  config.mode = :default
end

result = CreateUser.call(email: "", age: -5)
result.errors
# => [
#      { attribute: :email, type: :blank, message: "Email can't be blank" },
#      { attribute: :age, type: :greater_than, message: "Age must be greater than 0" }
#    ]

Interactor::Validation.configure do |config|
  config.mode = :code
end

result = CreateUser.call(email: "", age: -5)
result.errors
# => [
#      { code: "EMAIL_IS_REQUIRED" },
#      { code: "AGE_GREATER_THAN" }
#    ]

Interactor::Validation.configure do |config|
  config.halt = true
end

result = CreateUser.call(email: "", username: "", age: -5)
result.errors.size # => 1 (only the first error is captured)

{
  attribute: :email,                    # The field that failed
  type: :blank,                         # The validation type
  message: "Email can't be blank"       # Human-readable message
}

{
  code: "EMAIL_IS_REQUIRED"  # Machine-readable error code (SCREAMING_SNAKE_CASE)
}

result = CreateUser.call(email: "")
result.failure?
# => true

result.errors
# => [
#      { attribute: :email, type: :blank, message: "Email can't be blank" }
#    ]

class UpdateUser
  include Interactor
  include Interactor::Validation

  params :user_id, :email

  validates :email, format: { with: /@/ }

  def call
    # Access params directly instead of context.user_id, context.email
    user = User.find(user_id)
    user.update!(email: email)
  end
end