# Source code for canlib.kvmlib.deprecated

    import ctypes as ct
    import datetime
    import time
    import os

    from .. import deprecation
    from . import constants as const
    from .exceptions import kvm_error, KvmNoLogMsg
    from .structures import memoLogEventEx
    from .wrapper import dll

    class kvmVersion(object):
        """
        Class that holds kvmlib version number.

        """
        def __init__(self, major, minor, build):
            self.major = major
            self.minor = minor
            self.build = build

        def __str__(self):
            """
            Presents the version number as 'major.minor.build'.
            """
            return "%d.%d.%d" % (self.major, self.minor, self.build)

    class KvmLib(object):
        """Wrapper class for the Kvaser kvmlib.

        This class wraps the Kvaser kvmlib dll. For more info, see the kvmlib help
        files which are availible in the CANlib SDK.
        https://www.kvaser.com/developer/canlib-sdk/

        """
        dll = dll

        def __init__(self):
            self.handle = None
            self.kmeHandle = None
            self.logFileIndex = None
            self.dll.kvmInitialize()

        def getVersion(self):
            """Get the kvmlib version number.

            Returns the kvmlib version number from the kvmlib DLL currently in use.

            .. deprecated:: 1.5
               Use `dllversion` instead.

            Args:
                None

            Returns:
                version (kvmVersion): Major and minor version number

            """
            major = ct.c_int()
            minor = ct.c_int()
            build = ct.c_int()
            self.dll.kvmGetVersion(ct.byref(major), ct.byref(minor),
                                   ct.byref(build))
            version = kvmVersion(major.value, minor.value, build.value)
            return version

        @deprecation.deprecated.favour("deviceOpen")
        def openDeviceEx(self, memoNr=0, devicetype=const.kvmDEVICE_MHYDRA):
            """Deprecated function

            .. deprecated:: 1.5
               Use `deviceOpen` instead.

            """
            self.deviceOpen(memoNr, devicetype)

        def deviceOpen(self, memoNr=0, devicetype=const.kvmDEVICE_MHYDRA):
            status_p = ct.c_int()
            self.handle = self.dll.kvmDeviceOpen(memoNr, ct.byref(status_p), devicetype)

        @deprecation.deprecated.favour("deviceMountKmf")
        def openLog(self):
            """Deprecated function

            .. deprecated:: 1.5
               Use `deviceMountKmf` instead.

            """
            self.deviceMountKmf()

        def deviceMountKmf(self):
            """Mount device log files (kmf)

            Mount the log area on the SD card on a connected Kvaser Memorator and
            return the logger data format (LDF) version.

            Returns:
                ldfVersion (str): The logger data format (e.g. '5.0')

            """
            ldfMajor = ct.c_int(0)
            ldfMinor = ct.c_int(0)
            self.dll.kvmDeviceMountKmfEx(self.handle, ldfMajor, ldfMinor)
            return "%d.%d" % (ldfMajor.value, ldfMinor.value)

        @deprecation.deprecated.favour("kmfReadConfig")
        def readConfig(self):
            """Deprecated function

            .. deprecated:: 1.5
               Use `kmfReadConfig` instead.

            """
            self.kmfReadConfig()

        def kmfReadConfig(self):
            lif_buf = ct.create_string_buffer(320 * 32 * 1024)
            actual_len = ct.c_size_t(0)
            self.dll.kvmKmfReadConfig(self.handle, ct.byref(lif_buf),
                                      ct.sizeof(lif_buf), ct.byref(actual_len))
            return lif_buf.raw[:actual_len.value]

        @deprecation.deprecated.favour("kmfGetUsage")
        def getFileSystemUsage(self):
            """Deprecated function

            .. deprecated:: 1.5
               Use `kmfGetUsage` instead.

            """
            self.kmfGetUsage()

        def kmfGetUsage(self):
            totalSectorCount = ct.c_uint32()
            usedSectorCount = ct.c_uint32()
            self.dll.kvmKmfGetUsage(self.handle,
                                    ct.byref(totalSectorCount),
                                    ct.byref(usedSectorCount))
            return (int((totalSectorCount.value * 512) / (1000 * 1000)),
                    int((usedSectorCount.value * 512) / (1000 * 1000)))

        def kmfOpen(self, filename, deviceType=const.kvmDEVICE_MHYDRA):
            status_p = ct.c_int()
            self.handle = self.dll.kvmKmfOpen(filename.encode(),
                                              ct.byref(status_p),
                                              deviceType)
            if status_p.value < 0:
                self.handle = None
                print("ERROR filename:%s, devicetype:%d\n" %
                      (filename, deviceType))
                raise kvm_error(status_p.value)

        def kmfOpenEx(self, filename, deviceType=const.kvmDEVICE_MHYDRA):
            status_p = ct.c_int()
            ldfMajor = ct.c_int()
            ldfMinor = ct.c_int()
            self.handle = self.dll.kvmKmfOpenEx(filename.encode(),
                                                ct.byref(status_p),
                                                deviceType, ct.byref(ldfMajor),
                                                ct.byref(ldfMinor))
            if status_p.value < 0:
                self.handle = None
                print("ERROR filename:%s, devicetype:%d\n" %
                      (filename, deviceType))
                raise kvm_error(status_p.value)
            return "%d.%d" % (ldfMajor.value, ldfMinor.value)

        @deprecation.deprecated.favour("deviceGetDiskSize")
        def getDiskSize(self):
            """Deprecated function

            .. deprecated:: 1.5
               Use `deviceGetDiskSize` instead.

            """
            self.deviceGetDiskSize()

        def deviceGetDiskSize(self):
            diskSize = ct.c_uint32()
            self.dll.kvmDeviceDiskSize(self.handle, ct.byref(diskSize))
            return int((diskSize.value * 512) / (1000 * 1000))

        def logFileGetStartTime(self):
            startTime = ct.c_uint32()
            self.dll.kvmLogFileGetStartTime(self.handle,
                                            ct.byref(startTime))
            return datetime.datetime.fromtimestamp(startTime.value)

        @deprecation.deprecated.favour("deviceGetRTC")
        def getRTC(self):
            """Deprecated function

            .. deprecated:: 1.5
               Use `deviceGetRTC` instead.

            """
            self.deviceGetRTC()

        def deviceGetRTC(self):
            time = ct.c_uint32()
            self.dll.kvmDeviceGetRTC(self.handle, ct.byref(time))
            return datetime.datetime.fromtimestamp(time.value)

        @deprecation.deprecated.favour("deviceSetRTC")
        def setRTC(self, timestamp):
            """Deprecated function

            .. deprecated:: 1.5
               Use `deviceSetRTC` instead.

            """
            self.deviceSetRTC(timestamp)

        def deviceSetRTC(self, timestamp):
            unixTime = ct.c_uint32(int(time.mktime(timestamp.timetuple())))
            self.dll.kvmDeviceSetRTC(self.handle, unixTime)

        @deprecation.deprecated.favour("deviceGetDiskStatus")
        def isDiskPresent(self):
            """Deprecated function

            .. deprecated:: 1.5
               Use `deviceGetDiskStatus` instead.

            """
            self.deviceGetDiskStatus()

        def deviceGetDiskStatus(self):
            present = ct.c_int(0)
            self.dll.kvmDeviceDiskStatus(self.handle,
                                         ct.byref(present))
            return not(present.value == 0)

        @deprecation.deprecated.favour("logFileGetCount")
        def getLogFileCount(self):
            """Deprecated function

            .. deprecated:: 1.5
               Use `logFileGetCount` instead.

            """
            self.logFileGetCount()

        def logFileGetCount(self):
            fileCount = ct.c_uint32()
            self.dll.kvmLogFileGetCount(self.handle,
                                        ct.byref(fileCount))
            return fileCount.value

        @deprecation.deprecated.favour("deviceGetSerialNumber")
        def getSerialNumber(self):
            """Deprecated function

            .. deprecated:: 1.5
               Use `deviceGetSerialNumber` instead.

            """
            self.deviceGetSerialNumber()

        def deviceGetSerialNumber(self):
            serial = ct.c_uint()
            self.dll.kvmDeviceGetSerialNumber(self.handle,
                                              ct.byref(serial))
            return serial.value

        @deprecation.deprecated.favour("logFileDismount")
        def logCloseFile(self):
            """Deprecated function

            .. deprecated:: 1.5
               Use `logFileDismount` instead.

            """
            self.logFileDismount()

        def logFileDismount(self):
            self.dll.kvmLogFileDismount(self.handle)
            self.logFileIndex = None
            self.eventCount = 0

        @deprecation.deprecated.favour("logFileMount")
        def logOpenFile(self, fileIndx):
            """Deprecated function

            .. deprecated:: 1.5
               Use `logFileMount` instead.

            """
            self.logFileMount(fileIndx)

        def logFileMount(self, fileIndx):
            if self.logFileIndex is not None:
                self.logFileDismount
            eventCount = ct.c_uint32()
            self.dll.kvmLogFileMount(self.handle, fileIndx, ct.byref(eventCount))
            self.logFileIndex = fileIndx
            self.eventCount = eventCount.value
            self.events = []
            return self.eventCount

        @deprecation.deprecated.favour("logFileReadEvent")
        def logReadEventEx(self):
            """Deprecated function

            .. deprecated:: 1.5
               Use `logFileReadEvent` instead.

            """
            self.logFileReadEvent()

        def logFileReadEvent(self):
            logevent = memoLogEventEx()
            try:
                self.dll.kvmLogFileReadEvent(self.handle, ct.byref(logevent))
            except (KvmNoLogMsg):
                return None
            memoEvent = logevent.createMemoEvent()
            return memoEvent

        def logFileReadEventLogFormat(self):
            logevent = memoLogEventEx()
            try:
                self.dll.kvmLogFileReadEvent(self.handle, ct.byref(logevent))
            except (KvmNoLogMsg):
                return None
            return logevent

        def kmeReadEvent(self):
            logevent = memoLogEventEx()
            try:
                self.dll.kvmKmeReadEvent(self.kmeHandle, ct.byref(logevent))
            except (KvmNoLogMsg):
                return None
            memoEvent = logevent.createMemoEvent()
            return memoEvent

        def kmeReadEventLogFormat(self):
            logevent = memoLogEventEx()
            try:
                self.dll.kvmKmeReadEvent(self.kmeHandle, ct.byref(logevent))
            except (KvmNoLogMsg):
                return None
            return logevent

        def kmeWriteEvent(self, logevent):
            self.dll.kvmKmeWriteEvent(self.kmeHandle, ct.byref(logevent))

        @deprecation.deprecated.favour("logFileReadEvents")
        def readEvents(self):
            """Deprecated function

            .. deprecated:: 1.5
               Use `logFileReadEvents` instead.

            """
            return self.logFileReadEvents()

        @deprecation.deprecated.favour("logFileReadEvents")
        def logReadEvents(self):
            """Deprecated function

            .. deprecated:: 1.5
               Use `logFileReadEvents` instead.

            """
            self.logFileReadEvents()

        def logFileReadEvents(self):
            while True:
                event = self.logFileReadEvent()
                if event is None:
                    break
                self.events.append(event)
            return self.events

        @deprecation.deprecated.favour("kmfValidate")
        def validateDisk(self, fix=0):
            """Deprecated function

            .. deprecated:: 1.5
               Use `kmfValidate` instead.

            """
            self.kmfValidate(fix)

        def kmfValidate(self, fix=0):
            self.dll.kvmKmfValidate(self.handle)

        @deprecation.deprecated.favour("kmfWriteConfig")
        def writeConfigLif(self, lifData):
            """writeConfig

            .. deprecated:: 1.5
               Use `kmfWriteConfig` instead.

            """
            self.kmfWriteConfig(lifData)

        def kmfWriteConfig(self, lifData):
            buf = ct.create_string_buffer(lifData)
            self.dll.kvmKmfWriteConfig(self.handle, ct.byref(buf), len(lifData))

        def logFileDeleteAll(self):
            self.dll.kvmLogFileDeleteAll(self.handle)

        def writeConfig(self, config):
            self.kmfWriteConfig(config.toLif())

        @deprecation.deprecated.favour("deviceFormatDisk")
        def formatDisk(self, reserveSpace=10, dbaseSpace=2, fat32=True):
            """Deprecated function

            .. deprecated:: 1.5
               Use `deviceFormatDisk` instead.

            """
            self.deviceFormatDisk(reserveSpace, dbaseSpace, fat32)

        def deviceFormatDisk(self, reserveSpace=10, dbaseSpace=2, fat32=True):
            return self.dll.kvmDeviceFormatDisk(self.handle, fat32, reserveSpace,
                                                dbaseSpace)

        @deprecation.deprecated.favour("close")
        def closeDevice(self):
            """Deprecated function

            .. deprecated:: 1.5
               Use `close` instead.

            """
            self.close()

        def close(self):
            self.dll.kvmClose(self.handle)
            self.handle = None

        def kmeOpenFile(self, filename, filetype=const.kvmFILE_KME40):
            if self.kmeHandle is not None:
                self.kmeCloseFile()
            status_p = ct.c_int32()
            self.kmeHandle = self.dll.kvmKmeOpenFile(filename.encode(),
                                                     ct.byref(status_p),
                                                     filetype)
            if status_p.value != 0:
                self.kmeHandle = None
                print("ERROR kmeOpenFile failed with filename:"
                      "%s, filetype:%s\n" % (filename, filetype))
                raise kvm_error(status_p.value)

        def kmeScanFileType(self, filename):
            """Scan KME file and report version

            Open and read the file filename and try to decode what version
            of KME it contains. Returns type as kvmFILE_xxx.
            """
            type = ct.c_int32()
            filename = os.path.realpath(filename)
            ct_filename = ct.c_char_p(filename.encode())
            self.dll.kvmKmeScanFileType(ct_filename, ct.byref(type))
            return type.value

        def kmeCreateFile(self, filename, filetype=const.kvmFILE_KME40):
            if self.kmeHandle is not None:
                self.kmeCloseFile()
            status_p = ct.c_int32()
            ct_filename = ct.c_char_p(filename.encode())
            self.kmeHandle = self.dll.kvmKmeCreateFile(ct_filename,
                                                       ct.byref(status_p),
                                                       filetype)
            if status_p.value != 0:
                self.kmeHandle = None
                print("ERROR kmeCreateFile failed with filename:"
                      "%s, filetype:%s\n" % (filename, filetype))
                raise kvm_error(status_p.value)

        def kmeCountEvents(self):
            eventCount = ct.c_uint32(0)
            self.dll.kvmKmeCountEvents(self.kmeHandle,
                                       ct.byref(eventCount))
            return eventCount.value

        def kmeCloseFile(self):
            self.dll.kvmKmeCloseFile(self.kmeHandle)
            self.kmeHandle = None