gem 'rails_validation_api'

class API::UsersController < ApplicationController
  def create
    # Parameters are automatically validated using API::ValidateParameters::UserValidator
    # and API::UsersValidator (if they exist)
    
    # Your controller logic here
    render json: { message: "User created successfully" }
  end
end

# app/validators/api/validate_parameters/user_validator.rb
class API::ValidateParameters::UserValidator
  # Default empty hash - define your validation rules here
  FIELDS_VALIDATES = {}.freeze

  # Or with comprehensive validation rules defined:
  # FIELDS_VALIDATES = {
  #   # Basic field validation with opts array
  #   name_validate: {
  #     field: :name, 
  #     type: String, 
  #     opts: [
  #       { required: true, message: "Name is required" },
  #       { min: 2, message: "Name must be at least 2 characters" },
  #       { max: 50, message: "Name cannot exceed 50 characters" }
  #     ]
  #   },
  #   
  #   # Email validation with format and required
  #   email_validate: {
  #     field: :email, 
  #     type: String, 
  #     opts: [
  #       { required: true, message: "Email is required" },
  #       { format: /\A[\w+\-.]+@[a-z\d\-]+(\.[a-z\d\-]+)*\.[a-z]+\z/i, message: "Invalid email format" }
  #     ]
  #   },
  #   
  #   # Integer validation with range
  #   age_validate: {
  #     field: :age, 
  #     type: Integer, 
  #     opts: [
  #       { required: false },
  #       { min: 18, message: "Age must be at least 18" },
  #       { max: 120, message: "Age cannot exceed 120" }
  #     ]
  #   },
  #   
  #   # String validation with blank check
  #   search_criteria_validate: {
  #     field: :search_criteria, 
  #     type: String, 
  #     opts: [
  #       { required: true, message: "Search criteria is required" },
  #       { blank: false, message: "Search criteria cannot be blank" }
  #     ]
  #   },
  #   
  #   # Float validation with minimum value
  #   price_validate: {
  #     field: :price, 
  #     type: Float, 
  #     opts: [
  #       { required: true, message: "Price is required" },
  #       { min: 0.01, message: "Price must be greater than 0" }
  #     ]
  #   },
  #   
  #   # Boolean validation
  #   active_validate: {
  #     field: :active, 
  #     type: Boolean, 
  #     opts: [
  #       { required: false }
  #     ]
  #   },
  #   
  #   # Date validation
  #   birth_date_validate: {
  #     field: :birth_date, 
  #     type: Date, 
  #     opts: [
  #       { required: false }
  #     ]
  #   },
  #   
  #   # DateTime validation
  #   created_at_validate: {
  #     field: :created_at, 
  #     type: DateTime, 
  #     opts: [
  #       { required: false }
  #     ]
  #   },
  #   
  #   # Enum validation with 'in' option
  #   status_validate: {
  #     field: :status, 
  #     type: String, 
  #     opts: [
  #       { required: true, message: "Status is required" },
  #       { in: %w[active inactive pending], message: "Status must be active, inactive, or pending" }
  #     ]
  #   },
  #   
  #   # Array validation
  #   tags_validate: {
  #     field: :tags, 
  #     type: Array, 
  #     opts: [
  #       { required: false }
  #     ]
  #   }
  # }.freeze

  def create
    # Return validation rules for create action
    # FIELDS_VALIDATES.slice(:name, :email, :age, :status, :tags)
    []
  end

  def update
    # Return validation rules for update action (excluding some required fields)
    # FIELDS_VALIDATES.slice(:name, :email, :age, :active, :metadata)
    []
  end

  def index
    # Return validation rules for index action (typically query parameters)
    # FIELDS_VALIDATES.slice(:status, :tags, :created_at)
    []
  end
end

field_name_validate: {
  field: :field_name,    # The parameter field to validate
  type: Type,            # The expected data type
  opts: [                # Array of validation options
    { option: value, message: "custom message" }
  ],
  items: [               # Optional: Array of nested field validations (for Hash types)
    { field: :nested_field, type: Type, opts: [...] }
  ]
}

FIELDS_VALIDATES = {
  account_id_validate: {
    field: :account_id,
    type: Integer,
    opts: [
      { required: true, message: "Account ID is required" }
    ]
  },
  search_criteria_validate: {
    field: :search_criteria,
    type: String,
    opts: [
      { required: true, message: "Search criteria is required" },
      { blank: false, message: "Search criteria cannot be blank" }
    ]
  }
}.freeze

# Simple array
tags_validate: { 
  field: :tags, 
  type: Array, 
  opts: [
    { required: false }
  ]
}

# Array with typed items (refer to rails_param gem documentation for complex array validation)
category_ids_validate: { 
  field: :category_ids, 
  type: Array, 
  opts: [
    { required: false }
  ]
}

# Simple hash
metadata_validate: { 
  field: :metadata, 
  type: Hash, 
  opts: [
    { required: false }
  ]
}

# Complex nested hash validation with items array
user_profile_validate: {
  field: :user_profile,
  type: Hash,
  opts: [
    { required: true, message: "User profile is required" }
  ],
  items: [
    { field: :name, type: String, opts: [{ required: true, message: "Name is required" }] },
    { field: :age, type: Integer, opts: [{ required: false }] },
    { field: :email, type: String, opts: [
      { required: true, message: "Email is required" },
      { format: /\A[\w+\-.]+@[a-z\d\-]+(\.[a-z\d\-]+)*\.[a-z]+\z/i, message: "Invalid email format" }
    ]}
  ]
}