# frozen_string_literal: true
#
# Author:: James Gartrell (<jgartrel@gmail.com>)
# Copyright:: Copyright (c) Chef Software Inc.
# License:: Apache License, Version 2.0
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#

Ohai.plugin(:Network) do
  provides "network", "network/interfaces"
  provides "counters/network", "counters/network/interfaces"

  def windows_encaps_lookup(encap)
    return "Ethernet" if encap.eql?("Ethernet 802.3")

    encap
  end

  def mac_addresses(iface)
    prop = iface[:configuration][:mac_address] || iface[:instance][:network_addresses]
    [prop].flatten.map { |addr| addr.include?(":") ? addr : addr.scan(/.{1,2}/).join(":") }
  end

  def network_data
    @network_data ||= begin
      data = {}
      wmi = WmiLite::Wmi.new
      data[:addresses] = wmi.instances_of("Win32_NetworkAdapterConfiguration")

      # If we are running on windows nano or another operating system from the future
      # that does not populate the deprecated win32_* WMI classes, then we should
      # grab data from the newer MSFT_* classes
      return msft_adapter_data if data[:addresses].count == 0

      data[:adapters] = wmi.instances_of("Win32_NetworkAdapter")
      data
    end
  end

  def msft_adapter_data
    data = {}
    wmi = WmiLite::Wmi.new("ROOT/StandardCimv2")
    data[:addresses] = wmi.instances_of("MSFT_NetIPAddress")
    data[:adapters] = wmi.instances_of("MSFT_NetAdapter")
    data
  end

  # Returns interface code for an interface
  #
  # Interface Index (if present, Index otherwise) will be converted in hexadecimal format
  #
  # @param int_idx [String or nil] the interface index of interface
  # @param idx [String] the index of interface
  #
  # @return [String]
  #
  # @example Interface Code when interface index is present
  #   plugin.interface_code("1", "1") #=> "ox1"
  # @example Interface Code when interface index is not present
  #   plugin.interface_code(nil, "2") #=> "ox2"
  #
  def interface_code(int_idx, idx)
    sprintf("0x%x", (int_idx || idx)).downcase
  end

  # Returns IPV4 address from list of addresses containing IPV4 and IPV6 formats
  #
  # @param addresses [Array<String>] List of addresses
  #
  # @return [String]
  #
  # @example When list contains both IPV4 and IPV6 formats
  #   plugin.prefer_ipv4([IPV4, IPV6]) #=> "IPV4"
  # @example When list contains only IPV6 format
  #   plugin.prefer_ipv4([IPV6]) #=> "IPV6"
  #
  def prefer_ipv4(addresses)
    return nil unless addresses.is_a?(Array)

    addresses.find { |ip| IPAddress.valid_ipv4?(ip) } ||
      addresses.find { |ip| IPAddress.valid_ipv6?(ip) }
  end

  # Selects default interface and returns its information
  #
  # @note Interface with least metric value should be preferred as default_route
  #
  # @param configuration [Mash] Configuration of interfaces as iface_config
  #   [<interface_index> => {<interface_configurations>}]
  #
  # @return [Hash<:index, :interface_index, :default_ip_gateway, :ip_connection_metric>]
  #
  def favored_default_route_windows(configuration)
    return nil unless configuration.is_a?(Hash)

    config = configuration.dup

    config.inject([]) do |arr, (k, v)|
      if v["default_ip_gateway"]
        arr << { index: v["index"],
                 interface_index: v["interface_index"],
                 default_ip_gateway: prefer_ipv4(v["default_ip_gateway"]),
                 ip_connection_metric: v["ip_connection_metric"] }
      end
      arr
    end.min_by { |r| r[:ip_connection_metric] }
  end

  collect_data(:windows) do
    require "ipaddress" unless defined?(IPAddress)
    require "wmi-lite/wmi" unless defined?(WmiLite::Wmi)

    iface = Mash.new
    iface_config = Mash.new
    iface_instance = Mash.new
    network Mash.new unless network
    network[:interfaces] ||= Mash.new
    counters Mash.new unless counters
    counters[:network] ||= Mash.new

    network_data[:addresses].each do |adapter|
      i = adapter["index"] || adapter["InterfaceIndex"]
      iface_config[i] ||= Mash.new
      iface_config[i][:ip_address] ||= []
      iface_config[i][:ip_address] << adapter["IPAddress"]

      adapter.wmi_ole_object.properties_.each do |p|
        if iface_config[i][p.name.wmi_underscore.to_sym].nil?
          iface_config[i][p.name.wmi_underscore.to_sym] = adapter[p.name.downcase]
        end
      end
    end

    network_data[:adapters].each do |adapter|
      i = adapter["index"] || adapter["InterfaceIndex"]
      iface_instance[i] = Mash.new
      adapter.wmi_ole_object.properties_.each do |p|
        # skip wmi class name fields which make no sense in ohai
        next if %w{creation_class_name system_creation_class_name}.include?(p.name.wmi_underscore)

        iface_instance[i][p.name.wmi_underscore.to_sym] = adapter[p.name.downcase]
      end
    end

    iface_instance.each_key do |i|
      if iface_instance[i][:name] && iface_config[i] && iface_config[i][:ip_address][0]
        cint = interface_code(iface_instance[i][:interface_index], iface_instance[i][:index])
        iface[cint] = Mash.new
        iface[cint][:configuration] = iface_config[i]
        iface[cint][:instance] = iface_instance[i]

        iface[cint][:counters] = Mash.new
        iface[cint][:addresses] = Mash.new
        iface[cint][:configuration][:ip_address] = iface[cint][:configuration][:ip_address].flatten

        iface[cint][:configuration][:ip_address].each_index do |ip_index|
          ip = iface[cint][:configuration][:ip_address][ip_index]
          ip_and_subnet = ip.dup
          ip_and_subnet << "/#{iface[cint][:configuration][:ip_subnet][ip_index]}" if iface[cint][:configuration][:ip_subnet]
          ip2 = IPAddress(ip_and_subnet)
          iface[cint][:addresses][ip] = Mash.new(prefixlen: ip2.prefix)
          if ip2.ipv6?
            iface[cint][:addresses][ip][:family] = "inet6"
            iface[cint][:addresses][ip][:scope] = "Link" if /^fe80/i.match?(ip)
          else
            if iface[cint][:configuration][:ip_subnet]
              iface[cint][:addresses][ip][:netmask] = ip2.netmask.to_s
              if iface[cint][:configuration][:ip_use_zero_broadcast]
                iface[cint][:addresses][ip][:broadcast] = ip2.network.to_s
              else
                iface[cint][:addresses][ip][:broadcast] = ip2.broadcast.to_s
              end
            end
            iface[cint][:addresses][ip][:family] = "inet"
          end
        end
        mac_addresses(iface[cint]).each do |mac_addr|
          iface[cint][:addresses][mac_addr] = {
            "family" => "lladdr",
          }
        end
        iface[cint][:mtu] = iface[cint][:configuration][:mtu] if iface[cint][:configuration].key?(:mtu)
        iface[cint][:type] = iface[cint][:instance][:adapter_type] if iface[cint][:instance][:adapter_type]
        iface[cint][:arp] = {}
        iface[cint][:encapsulation] = windows_encaps_lookup(iface[cint][:instance][:adapter_type]) if iface[cint][:instance][:adapter_type]
      end
    end

    if (route = favored_default_route_windows(iface_config))
      network[:default_gateway] = route[:default_ip_gateway]
      network[:default_interface] = interface_code(route[:interface_index], route[:index])
    end

    cint = nil
    so = shell_out("arp -a")
    if so.exitstatus == 0
      so.stdout.lines do |line|
        if line =~ /^Interface:\s+(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})\s+-+\s+(0x\S+)/
          cint = $2.downcase
        end
        next unless iface[cint]

        if line =~ /^\s+(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})\s+([a-fA-F0-9\:-]+)/
          iface[cint][:arp][$1] = $2.tr("-", ":").downcase
        end
      end
    end

    network["interfaces"] = iface
  end
end
