UserSchema = Typero.schema do
  name       max: 100
  email      :email
  interests  Set[:label]
  location   :point
end

UserSchema.rules           # rules hash
UserSchema.db_schema       # generate DB schema
UserSchema.validate @user  # validate data

good_email = 'DUX@Net.hr'

# will convert email to 'dux@net.hr' (lowercase)
Typero.set :email, good_email

bad_email = 'duxnet.hr'

# raises TypeError
Typero.set :email, bad_email

# will capture error if block provided
Typero.set(:email, bad_email) { |e| @error = e.message }

schema = Typero.schema do
  # default type is String
  name    min: 3

  # unique info
  email   :email, unique: 'Email is already registered'

  # min and max can be defined for numbers and strings
  speed   :float, min: 10, max: 200

  # use values to define all possible values for a property
  eyes    default: 'blue', values: %w(brown blue green)

  # array type can be defined for any value
  # duplicates are removed by default
  emails  Array[:email], duplicates: true, max_count: 5
  emails  Set[:email]

  # manually set field and value for reserved words
  set :set, String

  # non required fields are defined by ?
  name? # same as "name required: false"

  # meta attributes can accept any value
  name meta: { foo: :bar, baz: 113 } # ok
  name foo: :bar # ArgumentError

  # you can set custom field names and error messages
  # @object.sallary = 500 # error - 'Plata min is 1000 (500 given)'
  sallary  Integer, name: 'Plata', min: 1000, meta: { en: { min_value_error: 'min is %s (%s given)'} }
  # or without locale prefix
  sallary  Integer, name: 'Plata', min: 1000, meta: { min_value_error: 'min is %s (%s given)' }
end

schema = Typero.schema do
  email   :email, req: true
  set     :age, Integer, min: 18, max: 150
end

schema.validate({ email:'dux@net.hr', age:'40' }) # {}
schema.validate({ email:'duxnet.hr', age:'16' })  # {:email=>"Email is missing @", :age=>"Age min is 18, got 16"}

# as an anonymous schema
schema = Typero.schema do
  user_name
end

# as a named schema (stored in SCHEMA_STORE)
Typero.schema(:user) do
  user_name
end

# retrieve a named schema
schema = Typero.schema(:user)

# returns nil if not found (instead of raising)
schema = Typero.schema?(:user)

# create schema
UserSchema = Typero.schema do
  name
  email  :email
  avatar? :url
end

# reference by schema instance
Typero.schema :api1 do
  bar
  foo Integer

  user UserSchema

  # or dynamic declaration
  user do
    name
    email :email
    avatar? :url
  end
end

UserSchema = Typero.schema do
  name
  email      :email
  password
  age        Integer, default: 21
  is_active  false
end

# keep only specific fields
UserSchema.only(:name, :email)

# remove specific fields
UserSchema.except(:password)

# chaining
UserSchema.except(:password).only(:name, :email)

# the returned schema is fully functional
schema = UserSchema.only(:name, :email)
errors = schema.validate({ name: 'Dux', email: 'dux@net.hr' })

# works with nested schemas too
ProfileSchema = Typero.schema do
  name
  settings do
    theme
    lang default: 'en'
  end
end

ProfileSchema.only(:settings)  # nested model field preserved with all its rules

Typero.schema :bulk do
  integer! do
    org_id        req: proc { I18n.t('org.required') }
    product_id?
  end

  false! do
    is_active
    is_locked
  end
end

class Typero::LabelType < Typero::Type
  # default value for blank? == true values
  def default
    nil
  end

  # coerce the value - transform and validate
  def coerce
    value do |data|
      data.to_s.gsub(/[^\w\-]/,'')[0,30].downcase
    end

    error_for(:unallowed_characters_error) unless value =~ /^[\w\-]+$/
  end

  # define database column type
  def db_schema
    [:string, { limit: 30 }]
  end
end

class Typero::SimplePointType < Typero::Type
  def coerce
    value { extract_coords(value) }  # stores array [lat, lon]
  end

  def input_value
    value.join(', ')  # returns "lat, lon" string
  end

  def db_schema
    [:float, { array: true }]  # DB stores array
  end
end

Typero::Type.error :en, :min_length_error, 'min length is %s, you have defined %s'

ERRORS = {
  en: {
    min_length_error: 'min length is %s, you have %s',
    max_length_error: 'max length is %s, you have %s',
    min_value_error: 'min is %s, got %s',
    max_value_error: 'max is %s, got %s',
    unallowed_characters_error: 'is having unallowed characters',
    not_in_range: 'Value is not in allowed range (%s)',
    unsupported_boolean: 'Unsupported boolean param value: %s',
    min_date: 'Minimal allowed date is %s',
    max_date: 'Maximal allowed date is %s',
    not_8_chars_error: 'is not having at least 8 characters',
    missing_monkey_error: 'is missing @',
    not_hash_type_error: 'value is not hash type',
    image_not_starting_error: 'URL is not starting with http',
    image_not_image_format: 'URL is not ending with jpg, jpeg, gif, png, svg, webp',
    locale_bad_format: 'Locale "%s" is in bad format (should be xx or xx-xx)',
    not_an_oib_error: 'not in an OIB format',
    invalid_time_zone: 'Invalid time zone',
    url_not_starting_error: 'URL is not starting with http or https',
    invalid_phone: 'is not a valid phone number',
    invalid_uuid: 'is not a valid UUID',
    invalid_slug: 'contains invalid characters',
  }
}