from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import threading
import functools
import six
from DIRAC.Core.Utilities.DIRACSingleton import DIRACSingleton


@six.add_metaclass(DIRACSingleton)
class ThreadConfig(threading.local):
  """ This class allows to contain extra information when a call is done on behalf of
      somebody else. Typically, when a host performs the request on behalf of a user.
      It is not used inside DIRAC, but is used in WebAppDIRAC for example

      Note that the class is a singleton, meaning that you share the same object in the whole process,
      however the attributes are thread locals (because of the threading.local inheritance).

      Also, this class has to be populated manually, no Client class will do it for you.

  """
  def __init__(self):
    self.reset()

  def reset(self):
    """ Reset extra information
    """
    self.__DN = False
    self.__group = False
    self.__deco = False
    self.__setup = False

  def setDecorator(self, deco):
    """ Set decorator

        :param deco: decorator
    """
    self.__deco = deco

  def getDecorator(self):
    """ Return decorator

        :return: decorator
    """
    return self.__deco

  def setDN(self, DN):
    """ Set DN

        :param str DN: DN
    """
    self.__DN = DN

  def getDN(self):
    """ Return DN

        :return: str
    """
    return self.__DN

  def setGroup(self, group):
    """ Set group

        :param str group: group name
    """
    self.__group = group

  def getGroup(self):
    """ Return group name

        :return: str
    """
    return self.__group

  def setID(self, DN, group):
    """ Set user ID

        :param str DN: user DN
        :param str group: user group
    """
    self.__DN = DN
    self.__group = group

  def getID(self):
    """ Return user ID

        :return: tuple
    """
    return (self.__DN, self.__group)

  def setSetup(self, setup):
    """ Set setup name

        :param str setup: setup name
    """
    self.__setup = setup

  def getSetup(self):
    """ Return setup name

        :return: str
    """
    return self.__setup

  def dump(self):
    """ Return extra information

        :return: tuple
    """
    return (self.__DN, self.__group, self.__setup)

  def load(self, tp):
    """ Save extra information

        :param tuple tp: contain DN, group name, setup name
    """
    if tp[0]:
      self.__DN = tp[0]
    if tp[1]:
      self.__group = tp[1]
    if tp[2]:
      self.__setup = tp[2]


def threadDeco(method):
  """ Tread decorator

      :param method: method

      :return: wrapped method
  """
  tc = ThreadConfig()

  @functools.wraps(method)
  def wrapper(*args, **kwargs):
    """ Wrapper

        :return: wrapped method
    """
    deco = tc.getDecorator()
    if not deco:
      return method(*args, **kwargs)
    # Deco is a decorator sooo....
    return deco(method)(*args, **kwargs)

  return wrapper