module DomainSearch

# File lib/domain_search.rb, line 15
def lookup(query, http: nil, rdap_http: nil, env: ENV, sleep_fn: nil, wordnet: nil)
  parsed = DomainParse.parse(query)
  return DomainReport.usage if parsed[:error] == :empty
  return DomainReport.invalid if parsed[:error] == :invalid

  gap = sleep_fn || Kernel.method(:sleep)
  if DomainVariations.eligible?(parsed)
    return lookup_with_variations(
      parsed,
      http: http,
      rdap_http: rdap_http,
      env: env,
      sleep_fn: gap,
      wordnet: wordnet
    )
  end

  lookup_single(parsed, http: http, rdap_http: rdap_http, env: env)
end

# File lib/domain_search.rb, line 105
def lookup_pair(query, http: nil, rdap_http: nil, env: ENV, whois_run: nil, dig_run: nil, sleep_fn: nil, wordnet: nil)
  parsed = DomainParse.parse(query)
  if parsed[:error]
    return [lookup(query, http: http, rdap_http: rdap_http, env: env, sleep_fn: sleep_fn, wordnet: wordnet)]
  end

  probe = probe_lookup(query, whois_run: whois_run, dig_run: dig_run)
  search = lookup(query, http: http, rdap_http: rdap_http, env: env, sleep_fn: sleep_fn, wordnet: wordnet)
  [probe, search]
end

# File lib/domain_search.rb, line 35
def lookup_single(parsed, http: nil, rdap_http: nil, env: ENV)
  pricing_http = http || DomainPricing.method(:default_http)
  rdap_client = rdap_http || http || DomainRdap.method(:default_http)

  rdap = DomainRdap.check(parsed[:domain], http: rdap_client)
  quotes = DomainPricing.collect(parsed[:domain], parsed[:tld], env: env, http: pricing_http)
  DomainReport.format(domain: parsed[:domain], rdap: rdap, quotes: quotes)
end

# File lib/domain_search.rb, line 44
def lookup_with_variations(parsed, http: nil, rdap_http: nil, env: ENV, sleep_fn:, wordnet: nil)
  pricing_http = http || DomainPricing.method(:default_http)
  rdap_client = rdap_http || http || DomainRdap.method(:default_http)
  source_query = parsed[:domain]
  variation_rows = []
  primary = nil
  first_rdap = nil
  first_quotes = nil

  DomainVariations.candidates(source_query, wordnet: wordnet).each_with_index do |candidate, index|
    sleep_fn.call(DomainVariations::LOOKUP_GAP_SEC) if index.positive?

    tld = DomainParse.extract_tld(candidate)
    rdap = DomainRdap.check(candidate, http: rdap_client)
    quotes = DomainPricing.collect(candidate, tld, env: env, http: pricing_http)
    row = { domain: candidate, rdap: rdap, quotes: quotes }
    variation_rows << row

    if candidate == source_query
      first_rdap = rdap
      first_quotes = quotes
    end

    next if DomainVariations.no_results?(rdap: rdap, quotes: quotes)

    primary ||= row
  end

  if primary
    return DomainReport.format(
      domain: primary[:domain],
      rdap: primary[:rdap],
      quotes: primary[:quotes],
      source_query: (primary[:domain] == source_query ? nil : source_query),
      variation_rows: variation_rows
    )
  end

  DomainReport.format(
    domain: source_query,
    rdap: first_rdap,
    quotes: first_quotes,
    variation_rows: variation_rows
  )
end

# File lib/domain_search.rb, line 90
def probe_lookup(query, whois_run: nil, dig_run: nil)
  parsed = DomainParse.parse(query)
  return DomainReport.usage if parsed[:error] == :empty
  return DomainReport.invalid if parsed[:error] == :invalid

  data = DomainProbe.probe(
    parsed[:domain],
    whois_run: whois_run || DomainProbe.default_whois_run,
    dig_run: dig_run || DomainProbe.default_dig_run
  )
  DomainProbeReport.format(domain: data[:domain], whois: data[:whois], dig: data[:dig])
rescue ArgumentError
  DomainReport.invalid
end