/*
    * Copyright 2020 The Netty Project
    *
    * The Netty Project licenses this file to you 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:
    *
    *   https://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.
   */
  package io.netty.util;
  
  import io.netty.util.internal.PlatformDependent;
  import io.netty.util.internal.SocketUtils;
  import io.netty.util.internal.logging.InternalLogger;
  import io.netty.util.internal.logging.InternalLoggerFactory;
  
  import java.net.Inet4Address;
  import java.net.Inet6Address;
  import java.net.InetAddress;
  import java.net.NetworkInterface;
  import java.net.SocketException;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.Enumeration;
  import java.util.List;
  
  final class NetUtilInitializations {
      /**
       * The logger being used by this class
       */
      private static final InternalLogger logger = InternalLoggerFactory.getInstance(NetUtilInitializations.class);
  
      private NetUtilInitializations() {
      }
  
      static Inet4Address createLocalhost4() {
          byte[] LOCALHOST4_BYTES = {127, 0, 0, 1};
  
          Inet4Address localhost4 = null;
          try {
              localhost4 = (Inet4Address) InetAddress.getByAddress("localhost", LOCALHOST4_BYTES);
          } catch (Exception e) {
              // We should not get here as long as the length of the address is correct.
              PlatformDependent.throwException(e);
          }
  
          return localhost4;
      }
  
      static Inet6Address createLocalhost6() {
          byte[] LOCALHOST6_BYTES = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1};
  
          Inet6Address localhost6 = null;
          try {
              localhost6 = (Inet6Address) InetAddress.getByAddress("localhost", LOCALHOST6_BYTES);
          } catch (Exception e) {
              // We should not get here as long as the length of the address is correct.
              PlatformDependent.throwException(e);
          }
  
          return localhost6;
      }
  
      static Collection<NetworkInterface> networkInterfaces() {
          List<NetworkInterface> networkInterfaces = new ArrayList<NetworkInterface>();
          try {
              Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces();
              if (interfaces != null) {
                  while (interfaces.hasMoreElements()) {
                      networkInterfaces.add(interfaces.nextElement());
                  }
              }
          } catch (SocketException e) {
              logger.warn("Failed to retrieve the list of available network interfaces", e);
          } catch (NullPointerException e) {
              if (!PlatformDependent.isAndroid()) {
                  throw e;
              }
              // Might happen on earlier version of Android.
              // See https://developer.android.com/reference/java/net/NetworkInterface#getNetworkInterfaces()
          }
          return Collections.unmodifiableList(networkInterfaces);
      }
  
      static NetworkIfaceAndInetAddress determineLoopback(
              Collection<NetworkInterface> networkInterfaces, Inet4Address localhost4, Inet6Address localhost6) {
          // Retrieve the list of available network interfaces.
          List<NetworkInterface> ifaces = new ArrayList<NetworkInterface>();
          for (NetworkInterface iface: networkInterfaces) {
              // Use the interface with proper INET addresses only.
              if (SocketUtils.addressesFromNetworkInterface(iface).hasMoreElements()) {
                  ifaces.add(iface);
             }
         }
 
         // Find the first loopback interface available from its INET address (127.0.0.1 or ::1)
         // Note that we do not use NetworkInterface.isLoopback() in the first place because it takes long time
         // on a certain environment. (e.g. Windows with -Djava.net.preferIPv4Stack=true)
         NetworkInterface loopbackIface = null;
         InetAddress loopbackAddr = null;
         loop: for (NetworkInterface iface: ifaces) {
             for (Enumeration<InetAddress> i = SocketUtils.addressesFromNetworkInterface(iface); i.hasMoreElements();) {
                 InetAddress addr = i.nextElement();
                 if (addr.isLoopbackAddress()) {
                     // Found
                     loopbackIface = iface;
                     loopbackAddr = addr;
                     break loop;
                 }
             }
         }
 
         // If failed to find the loopback interface from its INET address, fall back to isLoopback().
         if (loopbackIface == null) {
             try {
                 for (NetworkInterface iface: ifaces) {
                     if (iface.isLoopback()) {
                         Enumeration<InetAddress> i = SocketUtils.addressesFromNetworkInterface(iface);
                         if (i.hasMoreElements()) {
                             // Found the one with INET address.
                             loopbackIface = iface;
                             loopbackAddr = i.nextElement();
                             break;
                         }
                     }
                 }
 
                 if (loopbackIface == null) {
                     logger.warn("Failed to find the loopback interface");
                 }
             } catch (SocketException e) {
                 logger.warn("Failed to find the loopback interface", e);
             }
         }
 
         if (loopbackIface != null) {
             // Found the loopback interface with an INET address.
             logger.debug(
                     "Loopback interface: {} ({}, {})",
                     loopbackIface.getName(), loopbackIface.getDisplayName(), loopbackAddr.getHostAddress());
         } else {
             // Could not find the loopback interface, but we can't leave LOCALHOST as null.
             // Use LOCALHOST6 or LOCALHOST4, preferably the IPv6 one.
             if (loopbackAddr == null) {
                 try {
                     if (NetworkInterface.getByInetAddress(localhost6) != null) {
                         logger.debug("Using hard-coded IPv6 localhost address: {}", localhost6);
                         loopbackAddr = localhost6;
                     }
                 } catch (Exception e) {
                     // Ignore
                 } finally {
                     if (loopbackAddr == null) {
                         logger.debug("Using hard-coded IPv4 localhost address: {}", localhost4);
                         loopbackAddr = localhost4;
                     }
                 }
             }
         }
 
         return new NetworkIfaceAndInetAddress(loopbackIface, loopbackAddr);
     }
 
     static final class NetworkIfaceAndInetAddress {
         private final NetworkInterface iface;
         private final InetAddress address;
 
         NetworkIfaceAndInetAddress(NetworkInterface iface, InetAddress address) {
             this.iface = iface;
             this.address = address;
         }
 
         public NetworkInterface iface() {
             return iface;
         }
 
         public InetAddress address() {
             return address;
         }
     }
 }