#!/usr/bin/env python3
# -*- coding: utf-8 -*-

# Copyright (c) 2021 Battelle Energy Alliance, LLC.  All rights reserved.

# script for configuring sensor network interface controller(s)

import locale
import os
import sys
import netifaces
import fileinput
import re
from dialog import Dialog
from debinterface.interfaces import Interfaces
from sensorcommon import *

class Constants:
  DHCP = 'dhcp'
  STATIC = 'static'
  UNASSIGNED = 'manual'

  DEV_IDENTIFIER_FILE = '/etc/installer'
  DEV_UNKNOWN = 'unknown'
  DEV_AGGREGATOR = 'aggregator'
  DEV_SENSOR = 'sensor'
  DEV_VALID = {DEV_AGGREGATOR, DEV_SENSOR}
  MSG_ERR_DEV_INVALID = f'Could not determine installation type (not one of {DEV_VALID})'

  CONFIG_IFACE = 'Interface Configuration'

  SENSOR_BACKUP_CONFIG = '/tmp/sensor_interface.bak'
  SENSOR_INTERFACES_CONFIG = '/etc/network/interfaces.d/sensor'
  ETC_HOSTS = '/etc/hosts'

  TIME_SYNC_NTP = 'ntp'
  TIME_SYNC_HTPDATE = 'htpdate'
  TIME_SYNC_HTPDATE_CRON = '/etc/cron.d/htpdate'
  TIME_SYNC_HTPDATE_TEST_COMMAND = '/usr/sbin/htpdate -4 -a -b -d'
  TIME_SYNC_HTPDATE_COMMAND = '/usr/sbin/htpdate -4 -a -b -l -s'
  TIME_SYNC_NTP_CONFIG = '/etc/ntp.conf'

  MSG_CONFIG_MODE = 'Configuration Mode'
  MSG_BACKGROUND_TITLE = 'Sensor Configuration'
  MSG_CONFIG_HOST = ('Hostname', 'Configure sensor hostname')
  MSG_CONFIG_INTERFACE = ('Interface', 'Configure an interface\'s IP address')
  MSG_CONFIG_TIME_SYNC = ('Time Sync', 'Configure time synchronization')
  MSG_CONFIG_STATIC_TITLE = 'Provide the values for static IP configuration'
  MSG_ERR_ROOT_REQUIRED = 'Elevated privileges required, run as root'
  MSG_ERR_BAD_HOST = 'Invalid host or port'
  MSG_MESSAGE_DHCP = 'Configuring for DHCP provided address...'
  MSG_MESSAGE_ERROR = 'Error: {}\n\nPlease try again.'
  MSG_MESSAGE_STATIC = 'Configuring for static IP address...'
  MSG_MESSAGE_UNASSIGNED = 'Configuring for no IP address...'
  MSG_NETWORK_START_ERROR = 'Error occured while configuring network interface!\n\n'
  MSG_NETWORK_START_SUCCESS = 'Network interface configuration completed successfully!\n\n'
  MSG_NETWORK_STOP_ERROR = 'Error occured while bringing down the network interface!\n\n'
  MSG_NETWORK_STOP_SUCCESS = 'Brought down the network interface successfully!\n\n'
  MSG_TIME_SYNC_TYPE = 'Select time synchronization method'
  MSG_TIME_SYNC_HTPDATE_CONFIG = 'Provide values for HTTP/HTTPS Server'
  MSG_TIME_SYNC_TEST_SUCCESS = 'Server time retrieved successfully!\n\n'
  MSG_TIME_SYNC_CONFIG_SUCCESS = 'Time synchronization configured successfully!\n\n'
  MSG_TIME_SYNC_TEST_FAILURE = 'Server time could not be retrieved. Ignore error?\n\n'
  MSG_TIME_SYNC_NTP_CONFIG = 'Provide values for NTP Server'
  MSG_TESTING_CONNECTION = 'Testing {} connection...'
  MSG_TESTING_CONNECTION_FAILURE = "Connection error: could not connect to {}:{}"
  MSG_SET_HOSTNAME_CURRENT = 'Current sensor identification information\n\n'
  MSG_SET_HOSTNAME_SUCCESS = 'Set sensor hostname successfully!\n\n'
  MSG_IDENTIFY_NICS = 'Do you need help identifying network interfaces?'
  MSG_SELECT_INTERFACE = 'Select interface to configure'
  MSG_SELECT_BLINK_INTERFACE = 'Select capture interface to identify'
  MSG_BLINK_INTERFACE = '{} will blink for {} seconds'
  MSG_SELECT_SOURCE = 'Select address source'
  MSG_WELCOME_TITLE = 'Welcome to the sensor network interface controller utility!'

# the main dialog window used for the duration of this tool
d = Dialog(dialog='dialog', autowidgetsize=True)
d.set_background_title(Constants.MSG_BACKGROUND_TITLE)

###################################################################################################
# if the given interface is up, "ifdown" it
def network_stop(selected_iface):
  iface_state = "unknown"
  with open(f"/sys/class/net/{selected_iface}/operstate", 'r') as f:
    iface_state = f.readline().strip()

  if (iface_state == "up"):
    command = f"ifdown {selected_iface}"
  else:
    command = f"cat /sys/class/net/{selected_iface}/operstate"

  return run_process(command, stderr=True)

###################################################################################################
# if the given interface is not up, "ifup" it
def network_start(selected_iface):
  iface_state = "unknown"
  with open(f"/sys/class/net/{selected_iface}/operstate", 'r') as f:
    iface_state = f.readline().strip()

  if (iface_state != "up"):
    command = f"ifup {selected_iface}"
  else:
    command = f"cat /sys/class/net/{selected_iface}/operstate"

  return run_process(command, stderr=True)

###################################################################################################
# for a given interface, bring it down, write its new settings, and bring it back up
def write_and_display_results(interfaces, selected_iface):

  ecode, stop_results = network_stop(selected_iface)
  stop_results = list(filter(lambda x: (len(x) > 0) and ('Internet Systems' not in x) and ('Copyright' not in x) and ('All rights' not in x) and ('For info' not in x), stop_results))
  if ecode == 0:
    stop_text = Constants.MSG_NETWORK_STOP_SUCCESS
  else:
    stop_text = Constants.MSG_NETWORK_STOP_ERROR

  interfaces.writeInterfaces()

  ecode, start_results = network_start(selected_iface)
  start_results = list(filter(lambda x: (len(x.strip()) > 0) and ('Internet Systems' not in x) and ('Copyright' not in x) and ('All rights' not in x) and ('For info' not in x), start_results))
  if ecode == 0:
    start_text = Constants.MSG_NETWORK_START_SUCCESS
  else:
    start_text = Constants.MSG_NETWORK_START_ERROR

  code = d.msgbox(stop_text + "\n".join(stop_results) + "\n\n. . .\n\n" + start_text + "\n".join(start_results))

###################################################################################################
###################################################################################################
def main():
  locale.setlocale(locale.LC_ALL, '')

  # make sure we are being run as root
  if os.getuid() != 0:
    print(Constants.MSG_ERR_ROOT_REQUIRED)
    sys.exit(1)

  # what are we (sensor vs. aggregator)
  installation = Constants.DEV_UNKNOWN
  modeChoices = []
  try:
    with open(Constants.DEV_IDENTIFIER_FILE, 'r') as f:
      installation = f.readline().strip()
  except:
    pass
  if (installation == Constants.DEV_SENSOR):
    modeChoices = [Constants.MSG_CONFIG_INTERFACE, Constants.MSG_CONFIG_HOST, Constants.MSG_CONFIG_TIME_SYNC]
  elif (installation == Constants.DEV_AGGREGATOR):
    modeChoices = [Constants.MSG_CONFIG_HOST, Constants.MSG_CONFIG_TIME_SYNC]
  else:
    print(Constants.MSG_ERR_DEV_INVALID)
    sys.exit(1)

  start_dir = os.getcwd()
  quit_flag = False

  while not quit_flag:
    os.chdir(start_dir)
    try:

      # welcome
      code = d.yesno(Constants.MSG_WELCOME_TITLE, yes_label="Continue", no_label="Quit")
      if (code == Dialog.CANCEL or code == Dialog.ESC):
        quit_flag = True
        raise CancelledError

      # configuring an interface or setting the hostname?
      code, config_mode = d.menu(Constants.MSG_CONFIG_MODE, choices=modeChoices)
      if code != Dialog.OK:
        quit_flag = True
        raise CancelledError

      if (config_mode == Constants.MSG_CONFIG_HOST[0]):
        ##### system hostname configuration ##################################################################################################

        # get current host/identification information
        ecode, host_get_output = run_process('hostnamectl', stderr=True)
        if (ecode == 0):
          emsg_str = '\n'.join(host_get_output)
          code = d.msgbox(text=f"{Constants.MSG_SET_HOSTNAME_CURRENT}{emsg_str}")

          code, hostname_get_output = run_process('hostname', stderr=False)
          if (code == 0) and (len(hostname_get_output) > 0):
            old_hostname = hostname_get_output[0].strip()
          else:
            old_hostname = ""

          # user input for new hostname
          while True:
            code, new_hostname = d.inputbox("Sensor hostname", init=old_hostname)
            if (code == Dialog.CANCEL) or (code == Dialog.ESC):
              raise CancelledError
            elif (len(new_hostname) <= 0):
              code = d.msgbox(text=Constants.MSG_MESSAGE_ERROR.format(f'Invalid hostname specified'))
            else:
              break

          # set new hostname
          ecode, host_set_output = run_process(f'hostnamectl set-hostname {new_hostname.strip()}', stderr=True)
          if (ecode == 0):
            ecode, host_get_output = run_process('hostnamectl', stderr=True)
            emsg_str = '\n'.join(host_get_output)
            code = d.msgbox(text=f"{Constants.MSG_SET_HOSTNAME_SUCCESS}{emsg_str}")

            # modify /etc/hosts 127.0.1.1 entry
            local_hosts_re = re.compile(r"^\s*127\.0\.1\.1\b")
            with fileinput.FileInput(Constants.ETC_HOSTS, inplace=True, backup='.bak') as file:
              for line in file:
                if local_hosts_re.search(line) is not None:
                  print(f"127.0.1.1\t{new_hostname}")
                else:
                  print(line, end='')

          else:
            # error running hostnamectl set-hostname
            emsg_str = '\n'.join(host_get_output)
            code = d.msgbox(text=Constants.MSG_MESSAGE_ERROR.format(f"Getting hostname failed with {ecode}:{emsg_str}"))

        else:
          # error running hostnamectl
          emsg_str = '\n'.join(host_get_output)
          code = d.msgbox(text=Constants.MSG_MESSAGE_ERROR.format(f"Getting hostname failed with {ecode}:{emsg_str}"))

      elif (config_mode == Constants.MSG_CONFIG_TIME_SYNC[0]):
        ##### time synchronization configuration##############################################################################################
        time_sync_mode = ''
        code = Dialog.OK
        while (len(time_sync_mode) == 0) and (code == Dialog.OK):
          code, time_sync_mode = d.radiolist(Constants.MSG_TIME_SYNC_TYPE, choices=[(Constants.TIME_SYNC_HTPDATE, 'Use a Malcolm server (or another HTTP/HTTPS server)', (installation == Constants.DEV_SENSOR)),
                                                                                    (Constants.TIME_SYNC_NTP, 'Use an NTP server', False)])
        if (code != Dialog.OK):
          raise CancelledError

        elif (time_sync_mode == Constants.TIME_SYNC_HTPDATE):
          # sync time via htpdate, run via cron

          http_host = ''
          http_port = ''
          while True:
            # host/port for htpdate
            code, values = d.form(Constants.MSG_TIME_SYNC_HTPDATE_CONFIG,
                                  [('Host', 1, 1, '', 1,  25, 30, 255),
                                   ('Port', 2, 1, '9200', 2, 25, 6, 5)])
            values = [x.strip() for x in values]

            if (code == Dialog.CANCEL) or (code == Dialog.ESC):
              raise CancelledError

            elif (len(values[0]) <= 0) or (len(values[1]) <= 0) or (not values[1].isnumeric()):
              code = d.msgbox(text=Constants.MSG_ERR_BAD_HOST)

            else:
              http_host = values[0]
              http_port = values[1]
              break

          # test with htpdate to see if we can connect
          ecode, test_output = run_process(f"{Constants.TIME_SYNC_HTPDATE_TEST_COMMAND} {http_host}:{http_port}")
          if ecode == 0:
            emsg_str = '\n'.join(test_output)
            code = d.msgbox(text=f"{Constants.MSG_TIME_SYNC_TEST_SUCCESS}{emsg_str}")
          else:
            emsg_str = '\n'.join(test_output)
            code = d.yesno(text=f"{Constants.MSG_TIME_SYNC_TEST_FAILURE}{emsg_str}",
                           yes_label="Ignore Error", no_label="Start Over")
            if code != Dialog.OK:
              raise CancelledError

          # get polling interval
          code, htpdate_interval = d.rangebox(f"Time synchronization polling interval (minutes)",
                                              width=60, min=1, max=60, init=15)
          if (code == Dialog.CANCEL or code == Dialog.ESC):
            raise CancelledError

          # stop and disable the ntp process
          run_process('/bin/systemctl stop ntp')
          run_process('/bin/systemctl disable ntp')

          # write out htpdate file for cron
          with open(Constants.TIME_SYNC_HTPDATE_CRON, 'w+') as f:
            f.write('SHELL=/bin/bash\n')
            f.write('PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin\n')
            f.write('\n')
            f.write(f'*/{htpdate_interval} * * * * root {Constants.TIME_SYNC_HTPDATE_COMMAND} {http_host}:{http_port}\n')
            f.write('\n')
          code = d.msgbox(text=f"{Constants.MSG_TIME_SYNC_CONFIG_SUCCESS}")

        elif (time_sync_mode == Constants.TIME_SYNC_NTP):
          # sync time via ntp, run via service

          ntp_host = ''
          while True:
            # host/port for ntp
            code, values = d.form(Constants.MSG_TIME_SYNC_NTP_CONFIG,
                                  [('Host', 1, 1, '', 1,  25, 30, 255)])
            values = [x.strip() for x in values]

            if (code == Dialog.CANCEL) or (code == Dialog.ESC):
              raise CancelledError

            elif (len(values[0]) <= 0):
              code = d.msgbox(text=Constants.MSG_ERR_BAD_HOST)

            else:
              ntp_host = values[0]
              break

          # disable htpdate (no need to have two sync-ers) by removing it from cron
          if os.path.exists(Constants.TIME_SYNC_HTPDATE_CRON):
            os.remove(Constants.TIME_SYNC_HTPDATE_CRON)

          # write out ntp config file (changing values in place)
          server_written = False
          server_re = re.compile(r"^\s*#?\s*(server)\s*.+?$")
          with fileinput.FileInput(Constants.TIME_SYNC_NTP_CONFIG, inplace=True, backup='.bak') as file:
            for line in file:
              line = line.rstrip("\n")
              server_match = server_re.search(line)
              if server_match is not None:
                if not server_written:
                  print(f'server {ntp_host}')
                  server_written = True
                else:
                  print(f"{'' if line.startswith('#') else '#'}{line}")
              else:
                print(line)

          # enable and start the ntp process
          run_process('/bin/systemctl stop ntp')
          run_process('/bin/systemctl enable ntp')
          ecode, start_output = run_process('/bin/systemctl start ntp', stderr=True)
          if ecode == 0:
            code = d.msgbox(text=f"{Constants.MSG_TIME_SYNC_CONFIG_SUCCESS}")
          else:
            code = d.msgbox(text=Constants.MSG_MESSAGE_ERROR.format('\n'.join(start_output)))

        else:
          raise CancelledError

      else:
        ##### interface IP address configuration #############################################################################################

        # read configuration from /etc/network/interfaces.d/sensor (or /etc/network/interfaces if for some reason it doesn't exist)
        if os.path.isfile(Constants.SENSOR_INTERFACES_CONFIG):
          interfaces = Interfaces(interfaces_path=Constants.SENSOR_INTERFACES_CONFIG, backup_path=Constants.SENSOR_BACKUP_CONFIG)
        else:
          interfaces = Interfaces(backup_path=Constants.SENSOR_BACKUP_CONFIG)

        # determine a list of available (non-virtual) adapters
        available_adapters = get_available_adapters()

        while (len(available_adapters) > 0) and (d.yesno(Constants.MSG_IDENTIFY_NICS) == Dialog.OK):
          code, blinky_iface = d.radiolist(Constants.MSG_SELECT_BLINK_INTERFACE, choices=[(adapter.name, adapter.description, False) for adapter in available_adapters])
          if (code == Dialog.OK) and (len(blinky_iface) > 0):
            if (d.yesno(Constants.MSG_BLINK_INTERFACE.format(blinky_iface, NIC_BLINK_SECONDS), yes_label="Ready", no_label="Cancel") == Dialog.OK):
              identify_adapter(adapter=blinky_iface, duration=NIC_BLINK_SECONDS, background=True)
              code = d.pause(f"Identifying {blinky_iface}", seconds=NIC_BLINK_SECONDS, width=60, height=15)
          elif (code != Dialog.OK):
            break

        code, tag = d.menu(Constants.MSG_SELECT_INTERFACE, choices=[(adapter.name, adapter.description) for adapter in available_adapters])
        if code != Dialog.OK:
          raise CancelledError

        # which interface are wer configuring?
        selected_iface = tag

        # check if selected_iface already has entry in system configuration
        configured_iface = None
        for adapter in interfaces.adapters:
          item = adapter.export()
          if item['name'] == selected_iface:
            configured_iface = item
            break

        # if it was already configured, remove from configured adapter list to be replaced by the new settings
        if configured_iface is not None:
          interfaces.removeAdapterByName(selected_iface)

        # static, dynamic, or unassigned IP address?
        code, tag = d.menu(Constants.MSG_SELECT_SOURCE, choices=[(Constants.STATIC, 'Static IP (recommended)'), (Constants.DHCP, 'Dynamic IP'), (Constants.UNASSIGNED, 'No IP')])
        if code != Dialog.OK:
          raise CancelledError

        if tag == Constants.DHCP:
          # DHCP ##########################################################
          code = d.infobox(Constants.MSG_MESSAGE_DHCP)

          interfaces.addAdapter({
            'name': selected_iface,
            'auto': True,
            'hotplug': True,
            'addrFam': 'inet',
            'source': Constants.DHCP}, 0)

          write_and_display_results(interfaces, selected_iface)

        elif tag == Constants.UNASSIGNED:
          # unassigned (but up) ###########################################
          code = d.infobox(Constants.MSG_MESSAGE_UNASSIGNED)

          interfaces.addAdapter({
            'name': selected_iface,
            'auto': True,
            'hotplug': True,
            'addrFam': 'inet',
            'source': Constants.UNASSIGNED,
            'pre-up': 'ip link set dev $IFACE up',
            'post-up': '/usr/local/bin/nic-capture-setup.sh $IFACE',
            'post-down': 'ip link set dev $IFACE down'}, 0)

          write_and_display_results(interfaces, selected_iface)

        elif tag == Constants.STATIC:
          # static ########################################################

          # see if the adapter currently has an IP address, use it as a starting suggestion
          try:
            previous_ip = netifaces.ifaddresses(selected_iface)[netifaces.AF_INET][0]['addr']
            previous_gw = '.'.join(previous_ip.split('.')[0:3] + ['1'])
          except Exception as e:
            code = d.msgbox(text=Constants.MSG_MESSAGE_ERROR.format(e))
            previous_ip = "192.168.0.10"
            previous_gw = "192.168.0.1"
          if previous_ip.startswith('172.'):
            previous_mask = "255.255.0.0"
          elif previous_ip.startswith('10.'):
            previous_mask = "255.0.0.0"
          else:
            previous_mask = "255.255.255.0"

          while True:
            code, values = d.form(Constants.MSG_CONFIG_STATIC_TITLE, [
                                  # title, row_1, column_1, field, row_1, column_20, field_length, input_length
                                  ('IP Address', 1, 1, previous_ip, 1, 20, 15, 15),
                                  # title, row_2, column_1, field, row_2, column_20, field_length, input_length
                                  ('Netmask', 2, 1, previous_mask, 2, 20, 15, 15),
                                  # title, row_3, column_1, field, row_3, column_20, field_length, input_length
                                  ('Gateway', 3, 1, previous_gw, 3, 20, 15, 15)
                                  ])
            values = [x.strip() for x in values]

            if (code == Dialog.CANCEL or code == Dialog.ESC):
              raise CancelledError

            elif (len(values[0]) <= 0) or (len(values[1]) <= 0) or (len(values[2]) <= 0):
              code = d.msgbox(text=Constants.MSG_MESSAGE_ERROR.format("Invalid value(s), please try again"))

            else:
              code = d.infobox(Constants.MSG_MESSAGE_STATIC)

              interfaces.addAdapter({
                'name': selected_iface,
                'auto': True,
                'hotplug': True,
                'addrFam': 'inet',
                'source': Constants.STATIC,
                'address': values[0],
                'netmask': values[1],
                'gateway': values[2]}, 0)

              write_and_display_results(interfaces, selected_iface)
              break

    except CancelledError as c:
      # d.msgbox(text=Constants.MSG_CANCEL_ERROR)
      # just start over
      continue

    except Exception as e:
      d.msgbox(text=Constants.MSG_MESSAGE_ERROR.format(e))
      raise

if __name__ == '__main__':
  main()
  clearquit()