module ValidatesEmailFormatOf

# File lib/validates_email_format_of.rb, line 114
def self.default_message
  defined?(I18n) ? I18n.t(ERROR_MESSAGE_I18N_KEY, scope: [:activemodel, :errors, :messages], default: DEFAULT_MESSAGE) : DEFAULT_MESSAGE
end

# File lib/validates_email_format_of.rb, line 298
def self.deprecation_warn(msg)
  if defined?(ActiveSupport::Deprecation)
    ActiveSupport::Deprecation.warn(msg)
  else
    warn(msg)
  end
end

# File lib/validates_email_format_of.rb, line 5
def self.load_i18n_locales
  require "i18n"
  I18n.load_path += Dir.glob(File.expand_path(File.join(File.dirname(__FILE__), "..", "config", "locales", "*.yml")))
end

# File lib/validates_email_format_of.rb, line 271
def self.validate_domain_part_syntax(domain, idn: true)
  parts = domain.downcase.split(".", -1)
  parts.map! { |part| SimpleIDN.to_ascii(part) } if idn

  return false if parts.length <= 1 # Only one domain part

  # ipv4
  return true if parts.length == 4 && parts.all? { |part| part =~ IP_OCTET && part.to_i.between?(0, 255) }

  # From https://datatracker.ietf.org/doc/html/rfc3696#section-2 this is the recommended, pragmatic way to validate a domain name:
  #
  # > It is likely that the better strategy has now become to make the "at least one period" test,
  # > to verify LDH conformance (including verification that the apparent TLD name is not all-numeric),
  # > and then to use the DNS to determine domain name validity, rather than trying to maintain
  # > a local list of valid TLD names.
  #
  # We do a little bit more but not too much and validate the tokens but do not check against a list of valid TLDs.
  parts.each do |part|
    return false if part.nil? || part.empty?
    return false if part.length > 63
    return false unless DOMAIN_PART_LABEL.match?(part)
  end

  return false unless DOMAIN_PART_TLD.match?(parts[-1])
  true
end

# File lib/validates_email_format_of.rb, line 98
def self.validate_email_domain(email, idn: true, check_mx_timeout: 3)
  domain = email.to_s.downcase.match(/@(.+)/)[1]
  domain = SimpleIDN.to_ascii(domain) if idn

  Resolv::DNS.open do |dns|
    dns.timeouts = check_mx_timeout
    @mx = dns.getresources(domain, Resolv::DNS::Resource::IN::MX) + dns.getresources(domain, Resolv::DNS::Resource::IN::A)
  end
  @mx.size > 0
end

# File lib/validates_email_format_of.rb, line 130
def self.validate_email_format(email, options = {})
  default_options = {message: options[:generate_message] ? ERROR_MESSAGE_I18N_KEY : default_message,
                     check_mx: false,
                     check_mx_timeout: 3,
                     idn: true,
                     mx_message: if options[:generate_message]
                                   ERROR_MX_MESSAGE_I18N_KEY
                                 else
                                   (defined?(I18n) ? I18n.t(ERROR_MX_MESSAGE_I18N_KEY, scope: [:activemodel, :errors, :messages], default: DEFAULT_MX_MESSAGE) : DEFAULT_MX_MESSAGE)
                                 end,
                     domain_length: 255,
                     local_length: 64,
                     generate_message: false}
  opts = options.merge(default_options) { |key, old, new| old } # merge the default options into the specified options, retaining all specified options

  begin
    domain, local = email.reverse.split("@", 2)
  rescue
    return [opts[:message]]
  end

  # need local and domain parts
  return [opts[:message]] unless local && !local.empty? && domain && !domain.empty?

  # check lengths
  return [opts[:message]] unless domain.length <= opts[:domain_length] && local.length <= opts[:local_length]

  local.reverse!
  domain.reverse!

  if opts.has_key?(:with) # holdover from versions <= 1.4.7
    deprecation_warn(":with option is deprecated and will be removed in the next version")
    return [opts[:message]] unless email&.match?(opts[:with])
  else
    return [opts[:message]] unless validate_local_part_syntax(local) && validate_domain_part_syntax(domain, idn: opts[:idn])
  end

  if opts[:check_mx] && !validate_email_domain(email, check_mx_timeout: opts[:check_mx_timeout], idn: opts[:idn])
    return [opts[:mx_message]]
  end

  nil # represents no validation errors
end

# File lib/validates_email_format_of.rb, line 174
def self.validate_local_part_syntax(local)
  in_quoted_pair = false
  in_quoted_string = false
  comment_depth = 0

  # The local part is made up of dot-atom and quoted-string joined together by "." characters
  #
  # https://www.rfc-editor.org/rfc/rfc5322#section-3.4.1
  # > local-part      =   dot-atom / quoted-string / obs-local-part
  #
  # https://www.rfc-editor.org/rfc/rfc5322#section-3.2.3
  # Both atom and dot-atom are interpreted as a single unit, comprising
  # > the string of characters that make it up.  Semantically, the optional
  # > comments and FWS surrounding the rest of the characters are not part
  # > of the atom; the atom is only the run of atext characters in an atom,
  # > or the atext and "." characters in a dot-atom.
  joining_atoms = true

  (0..local.length - 1).each do |i|
    ord = local[i].ord

    # accept anything if it's got a backslash before it
    if in_quoted_pair
      in_quoted_pair = false
      next
    end

    # double quote delimits quoted strings
    if ord == 34
      if in_quoted_string # leaving the quoted string
        in_quoted_string = false
        next
      elsif joining_atoms # are we allowed to enter a quoted string?
        in_quoted_string = true
        joining_atoms = false
        next
      else
        return false
      end
    end

    # period indicates we want to join atoms, e.g. `aaa.bbb."ccc"@example.com
    if ord == 46
      return false if i.zero?
      return false if joining_atoms
      joining_atoms = true
      next
    end

    joining_atoms = false

    # quoted string logic must come before comment processing since a quoted string
    # may contain parens, e.g. `"name(a)"@example.com`
    if in_quoted_string
      next if QTEXT.match?(local[i])
    end

    # opening paren to show we are going into a comment (CFWS)
    if ord == 40
      comment_depth += 1
      next
    end

    # closing paren
    if ord == 41
      comment_depth -= 1
      return false if comment_depth < 0
      next
    end

    # backslash signifies the start of a quoted pair
    if ord == 92
      # https://www.rfc-editor.org/rfc/rfc5322#section-3.2.1
      # > The only places in this specification where quoted-pair currently appears are
      # > ccontent, qcontent, and in obs-dtext in section 4.
      return false unless in_quoted_string || comment_depth > 0
      in_quoted_pair = true
      next
    end

    if comment_depth > 0
      next if CTEXT.match?(local[i])
    elsif ATEXT.match?(local[i, 1])
      next
    end

    return false
  end

  return false if in_quoted_pair # unbalanced quoted pair
  return false if in_quoted_string # unbalanced quotes
  return false unless comment_depth.zero? # unbalanced comment parens
  return false if joining_atoms # the last char we encountered was a period

  true
end