from datetime import datetime

Images = {}
Devices = {}

###################
class ImageObj(object):
    ID = 0
    def __init__(self, obj):
        pass

class DzImage(object):
    __name = None
    def __init__(self, name):
        if name[-4:].lower() != ".zip":
            raise ValueError
        self.__name = name[:-4]

    def Create(self):
        global Images
        Images[self.__name] = ImageObj(self)

###################
class DeviceObj(object):
    TimedOut = 0
    sValue = ""
    nValue = 0
    Image = None
    Name=None
    Type=None
    SubType=None

    __unit=None
    __switchtype=None
    __options=None
    __image=None
    __used=None

    def __init__(self, Unit=None, Name=None, Type=None, TypeName=None, Subtype=None, Switchtype=None, Options=None, Image=None, Used=None):
        self.Name = Name
        self.Image = Image
        self.Type = Type
        self.SubType = Subtype

        self.__unit = Unit
        self.__typename = TypeName
        self.__switchtype = Switchtype
        self.__options = Options
        self.__used = Used

    def __repr__(self):
        res = ""
        res = res + f"Unit      : {self.__unit}"
        res = res + f"Name      : {self.__name}"
        res = res + f"Type      : {self.__type}"
        res = res + f"Type Name : {self.__typename}"
        res = res + f"Subtype   : {self.__subtype}"
        res = res + f"Switchtype: {self.__switchtype}"
        res = res + f"Image     : {self.Image}"
        res = res + f"Options   : {self.__options}"
        res = res + f"Used      : {self.__used}"
        return res

    def Update(self, nValue=None, sValue=None, TimedOut=None, Image=None):
        if nValue is not None and self.nValue != nValue:
            self.nValue = nValue
        if sValue is not None and self.sValue != sValue:
            self.sValue = sValue
        if TimedOut is not None and self.TimedOut != TimedOut:
            self.TimedOut = TimedOut
        if Image is not None and self.Image != Image:
            self.Image = Image

    def Touch(self):
        pass

class DzDevice(object):
    __data=None

    def __init__(self, **kwargs):
        self.__data = kwargs

    def Create(self):
        global Devices
        Devices[self.__data["Unit"]] = DeviceObj(**self.__data)

###################
class BaseDomoticz(object):
    __debuglevel = 0
    __heartbeat = 30

    def __init__(self):
        pass

    @staticmethod
    def __print(message):
        print(datetime.now().strftime("%d/%m/%Y %H:%M:%S"), "-", message)

    @staticmethod
    def Image(name):
        return DzImage(name)

    @staticmethod
    def Device(**kwargs):
        return DzDevice(**kwargs)

    def Debugging(self, level):
        self.__debuglevel = int(level)

    def Debug(self, message):
        if self.__debuglevel > 0:
            self.__print("[DEBUG] "+message)

    def Log(self, message):
        self.__print("[LOG] "+message)

    def Status(self, message):
        self.__print("[STATUS] "+message)

    def Error(self, message):
        self.__print("[ERROR] "+message)

    def Heartbeat(self, duration):
        self.__heartbeat = duration

    def GetHeartbeat(self):
        return self.__heartbeat

domo = BaseDomoticz()

###################

def Debugging(level):
    """Debugging"""
    domo.Debugging(level)

def Debug(message):
    """Debug"""
    domo.Debug(message)

def Log(message):
    """Debugging"""
    domo.Log(message)

def Status(message):
    """Status"""
    domo.Status(message)

def Error(message):
    """Error"""
    domo.Error(message)

def Heartbeat(duration):
    """Heartbeat"""

def DomoticzImage(name):
    """Image"""
    return domo.Image(name)

def Device(*args, **kwargs):
    """Device"""
    return domo.Device(**kwargs)

###################