# -*- coding: utf-8 -*-
# Copyright 2015 Google Inc. All Rights Reserved.
#
# 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.
"""Signal handling functions."""

from __future__ import absolute_import

import logging
import os
import re
import signal
import sys
import traceback
from gslib.util import IS_WINDOWS
from gslib.util import UTF8

if IS_WINDOWS:
  import ctypes  # pylint: disable=g-import-not-at-top

# Maps from signal_num to list of signal handlers to call.
_non_final_signal_handlers = {}
# Maps from signal_num to the final signal handler (if any) that should be
# called for that signal.
_final_signal_handlers = {}


def RegisterSignalHandler(signal_num, handler, is_final_handler=False):
  """Registers a handler for signal signal_num.

  Unlike calling signal.signal():
    - This function can be called from any thread (and will cause the handler to
      be run by the main thread when the signal is received).
    - Handlers are cumulative: When a given signal is received, all registered
      handlers will be executed (with the exception that only the last handler
      to register with is_final_handler=True will be called).

  Handlers should make no ordering assumptions, other than that the last handler
  to register with is_final_handler=True will be called after all the other
  handlers.

  Args:
    signal_num: The signal number with which to associate handler.
    handler: The handler.
    is_final_handler: Bool indicator whether handler should be called last among
                      all the handlers for this signal_num. The last handler to
                      register this way survives; other handlers registered with
                      is_final_handler=True will not be called when the signal
                      is received.
  Raises:
    RuntimeError: if attempt is made to register a signal_num not in
        GetCaughtSignals.
  """
  if signal_num not in GetCaughtSignals():
    raise RuntimeError('Attempt to register handler (%s) for signal %d, which '
                       'is not in GetCaughtSignals' % (handler, signal_num))
  if is_final_handler:
    _final_signal_handlers[signal_num] = handler
  else:
    _non_final_signal_handlers[signal_num].append(handler)


def _SignalHandler(signal_num, cur_stack_frame):
  """Global signal handler.

  When a signal is caught we execute each registered handler for that signal.

  Args:
    signal_num: Signal that was caught.
    cur_stack_frame: Unused.
  """
  if signal_num in _non_final_signal_handlers:
    for handler in _non_final_signal_handlers[signal_num]:
      handler(signal_num, cur_stack_frame)
  if signal_num in _final_signal_handlers:
    _final_signal_handlers[signal_num](signal_num, cur_stack_frame)


def InitializeSignalHandling():
  """Initializes global signal handling.

  Sets up global signal handler for each signal we handle.
  """
  for signal_num in GetCaughtSignals():
    _non_final_signal_handlers[signal_num] = []
    # Make main signal handler catch the signal.
    signal.signal(signal_num, _SignalHandler)


def GetCaughtSignals():
  """Returns terminating signals that can be caught on this OS platform."""
  signals = [signal.SIGINT, signal.SIGTERM]
  if not IS_WINDOWS:
    # Windows doesn't have SIGQUIT.
    signals.append(signal.SIGQUIT)
  return signals


def KillProcess(pid):
  """Make best effort to kill the given process.

  We ignore all exceptions so a caller looping through a list of processes will
  continue attempting to kill each, even if one encounters a problem.

  Args:
    pid: The process ID.
  """
  try:
    # os.kill doesn't work in 2.X or 3.Y on Windows for any X < 7 or Y < 2.
    if IS_WINDOWS and ((2, 6) <= sys.version_info[:3] < (2, 7) or
                       (3, 0) <= sys.version_info[:3] < (3, 2)):
      kernel32 = ctypes.windll.kernel32
      handle = kernel32.OpenProcess(1, 0, pid)
      kernel32.TerminateProcess(handle, 0)
    else:
      os.kill(pid, signal.SIGKILL)
  except:  # pylint: disable=bare-except
    pass


# pylint: disable=unused-argument
def MultithreadedMainSignalHandler(signal_num, cur_stack_frame):
  """Final signal handler for multi-threaded main process."""
  if signal_num == signal.SIGINT:
    if logging.getLogger().isEnabledFor(logging.DEBUG):
      stack_trace = ''.join(traceback.format_list(traceback.extract_stack()))
      err = ('DEBUG: Caught CTRL-C (signal %d) - Exception stack trace:\n'
             '    %s' % (signal_num, re.sub('\\n', '\n    ', stack_trace)))
      try:
        sys.stderr.write(err.encode(UTF8))
      except UnicodeDecodeError:
        # Can happen when outputting invalid Unicode filenames.
        sys.stderr.write(err)
    else:
      sys.stderr.write('Caught CTRL-C (signal %d) - exiting\n' % signal_num)

  KillProcess(os.getpid())


def ChildProcessSignalHandler(signal_num, cur_stack_frame):
  """Final signal handler for child processes."""
  KillProcess(os.getpid())
# pylint: enable=unused-argument