# encoding: utf-8
# author: Christoph Hartmann
# author: Dominik Richter

require 'utils/parser'

class XinetdConf < Inspec.resource(1) # rubocop:disable Metrics/ClassLength
  name 'xinetd_conf'
  desc 'Xinetd services configuration.'
  example "
    describe xinetd_conf.services('chargen') do
      its('socket_types') { should include 'dgram' }
    end

    describe xinetd_conf.services('chargen').socket_types('dgram') do
      it { should be_disabled }
    end
  "

  include XinetdParser

  def initialize(conf_path = '/etc/xinetd.conf', opts = {})
    @conf_path = conf_path
    @params = opts[:params] unless opts[:params].nil?
    @filters = opts[:filters] || ''
    @contents = {}
  end

  def to_s
    "Xinetd config #{@conf_path}"
  end

  def services(condition = nil)
    condition.nil? ? params['services'].keys : filter(service: condition)
  end

  def ids(condition = nil)
    condition.nil? ? services_field('id') : filter(id: condition)
  end

  def socket_types(condition = nil)
    condition.nil? ? services_field('socket_type') : filter(socket_type: condition)
  end

  def types(condition = nil)
    condition.nil? ? services_field('type') : filter(type: condition)
  end

  def wait(condition = nil)
    condition.nil? ? services_field('wait') : filter(wait: condition)
  end

  def disabled?
    filter(disable: 'no').services.empty?
  end

  def enabled?
    filter(disable: 'yes').services.empty?
  end

  def params
    return @params if defined?(@params)
    return @params = {} if read_content.nil?
    flat_params = parse_xinetd(read_content)
    @params = { 'services' => {} }
    flat_params.each do |k, v|
      name = k[/^service (.+)$/, 1]
      if name.nil?
        @params[k] = v
      else
        @params['services'][name] = v
      end
    end
    @params
  end

  def filter(conditions = {})
    res = params.dup
    filters = ''
    conditions.each do |k, v|
      v = v.to_s if v.is_a? Integer
      filters += " #{k} = #{v.inspect}"
      res['services'] = filter_by(res['services'], k.to_s, v)
    end
    XinetdConf.new(@conf_path, params: res, filters: filters)
  end

  private

  # Retrieve the provided field from all configured services.
  #
  # @param [String] field name, e.g. `socket_type`
  # @return [Array[String]] all values of this field across services
  def services_field(field)
    params['services'].values.compact.flatten
                      .map { |x| x.params[field] }.flatten.compact
  end

  def match_condition(sth, condition)
    case sth
    # this does Regex-matching as well as string comparison
    when condition
      true
    else
      false
    end
  end

  # Filter services by a criteria. This allows for search queries for
  # certain values.
  #
  # @param [Hash] service collection
  # @param [String] search key you want to query
  # @param [Any] search value that the key should match
  # @return [Hash] filtered service collection
  def filter_by(services, k, v)
    if k == 'service'
      return Hash[services.find_all { |name, _| match_condition(v, name) }]
    end
    Hash[services.map { |name, service_arr|
      found = service_arr.find_all { |service|
        match_condition(service.params[k], v)
      }
      found.empty? ? nil : [name, found]
    }.compact]
  end

  def read_content(path = @conf_path)
    return @contents[path] if @contents.key?(path)
    file = inspec.file(path)
    if !file.file?
      return skip_resource "Can't find file \"#{path}\""
    end

    @contents[path] = file.content
    if @contents[path].empty? && file.size > 0
      return skip_resource "Can't read file \"#{path}\""
    end

    @contents[path]
  end
end