class PublicSuffix::List

def self.default(**options)
  @default ||= parse(File.read(DEFAULT_LIST_PATH), **options)
end

def self.default=(value)
  @default = value
end

def self.parse(input, private_domains: true)
  comment_token = "//"
  private_token = "===BEGIN PRIVATE DOMAINS==="
  section = nil # 1 == ICANN, 2 == PRIVATE
  new do |list|
    input.each_line do |line|
      line.strip!
      case # rubocop:disable Style/EmptyCaseCondition
      # skip blank lines
      when line.empty?
        next
      # include private domains or stop scanner
      when line.include?(private_token)
        break if !private_domains
        section = 2
      # skip comments
      when line.start_with?(comment_token) # rubocop:disable Lint/DuplicateBranch
        next
      else
        list.add(Rule.factory(line, private: section == 2))
      end
    end
  end
end

def ==(other)
  return false unless other.is_a?(List)
  equal?(other) || @rules == other.rules
end

def add(rule)
  @rules[rule.value] = rule_to_entry(rule)
  self
end

def clear
  @rules.clear
  self
end

def default_rule
  PublicSuffix::Rule.default
end

def each(&block)
  Enumerator.new do |y|
    @rules.each do |key, node|
      y << entry_to_rule(node, key)
    end
  end.each(&block)
end

def empty?
  @rules.empty?
end

def entry_to_rule(entry, value)
  entry.type.new(value: value, length: entry.length, private: entry.private)
end

def find(name, default: default_rule, **options)
  rule = select(name, **options).inject do |l, r|
    return r if r.instance_of?(Rule::Exception)
    l.length > r.length ? l : r
  end
  rule || default
end

def initialize
  @rules = {}
  yield(self) if block_given?
end

def rule_to_entry(rule)
  Rule::Entry.new(rule.class, rule.length, rule.private)
end

def select(name, ignore_private: false)
  name = name.to_s
  parts = name.split(DOT).reverse!
  index = 0
  query = parts[index]
  rules = []
  loop do
    match = @rules[query]
    rules << entry_to_rule(match, query) if !match.nil? && (ignore_private == false || match.private == false)
    index += 1
    break if index >= parts.size
    query = parts[index] + DOT + query
  end
  rules
end

def size
  @rules.size
end