IMMREX7

# coding: utf-8

"""
Exceptions and compatibility shims for consistently using ctypes and cffi
"""

from __future__ import unicode_literals, division, absolute_import, print_function

import sys
import platform

from ctypes.util import find_library

from . import ffi
from ._types import str_cls, byte_cls, int_types, bytes_to_list


__all__ = [
    'array_from_pointer',
    'array_set',
    'buffer_from_bytes',
    'buffer_from_unicode',
    'buffer_pointer',
    'byte_array',
    'byte_string_from_buffer',
    'bytes_from_buffer',
    'callback',
    'cast',
    'deref',
    'errno',
    'FFIEngineError',
    'get_library',
    'is_null',
    'native',
    'new',
    'null',
    'pointer_set',
    'ref',
    'register_ffi',
    'sizeof',
    'struct',
    'struct_bytes',
    'struct_from_buffer',
    'unwrap',
    'write_to_buffer',
]


if ffi() == 'cffi':
    from cffi import FFI

    _ffi_registry = {}

    ffi = FFI()

    def register_ffi(library, ffi_obj):
        _ffi_registry[library] = ffi_obj

    def _get_ffi(library):
        if library in _ffi_registry:
            return _ffi_registry[library]
        return ffi

    def buffer_from_bytes(initializer):
        if sys.platform == 'win32':
            return ffi.new('unsigned char[]', initializer)
        return ffi.new('char[]', initializer)

    def buffer_from_unicode(initializer):
        return ffi.new('wchar_t []', initializer)

    def write_to_buffer(buffer, data, offset=0):
        buffer[offset:offset + len(data)] = data

    def buffer_pointer(buffer):
        return ffi.new('char *[]', [buffer])

    def cast(library, type_, value):
        ffi_obj = _get_ffi(library)
        return ffi_obj.cast(type_, value)

    def sizeof(library, value):
        ffi_obj = _get_ffi(library)
        return ffi_obj.sizeof(value)

    def bytes_from_buffer(buffer, maxlen=None):
        if maxlen is not None:
            return ffi.buffer(buffer, maxlen)[:]
        return ffi.buffer(buffer)[:]

    def byte_string_from_buffer(buffer):
        return ffi.string(buffer)

    def byte_array(byte_string):
        return byte_string

    def pointer_set(pointer_, value):
        pointer_[0] = value

    def array_set(array, value):
        for index, val in enumerate(value):
            array[index] = val

    def null():
        return ffi.NULL

    def is_null(point):
        if point is None:
            return True
        if point == ffi.NULL:
            return True
        if ffi.getctype(ffi.typeof(point)) == 'void *':
            return False
        if point[0] == ffi.NULL:
            return True
        return False

    def errno():
        return ffi.errno

    def new(library, type_, value=None):
        ffi_obj = _get_ffi(library)

        params = []
        if value is not None:
            params.append(value)
        if type_ in set(['BCRYPT_KEY_HANDLE', 'BCRYPT_ALG_HANDLE']):
            return ffi_obj.cast(type_, 0)
        return ffi_obj.new(type_, *params)

    def ref(value, offset=0):
        return value + offset

    def native(type_, value):
        if type_ == str_cls:
            return ffi.string(value)
        if type_ == byte_cls:
            return ffi.buffer(value)[:]
        return type_(value)

    def deref(point):
        return point[0]

    def unwrap(point):
        return point[0]

    def struct(library, name):
        ffi_obj = _get_ffi(library)
        return ffi_obj.new('%s *' % name)

    def struct_bytes(struct_):
        return ffi.buffer(struct_)[:]

    def struct_from_buffer(library, name, buffer):
        ffi_obj = _get_ffi(library)
        new_struct_pointer = ffi_obj.new('%s *' % name)
        new_struct = new_struct_pointer[0]
        struct_size = sizeof(library, new_struct)
        struct_buffer = ffi_obj.buffer(new_struct_pointer)
        struct_buffer[:] = ffi_obj.buffer(buffer, struct_size)[:]
        return new_struct_pointer

    def array_from_pointer(library, name, point, size):
        ffi_obj = _get_ffi(library)
        array = ffi_obj.cast('%s[%s]' % (name, size), point)
        total_bytes = ffi_obj.sizeof(array)
        if total_bytes == 0:
            return []
        output = []

        string_types = {
            'LPSTR': True,
            'LPCSTR': True,
            'LPWSTR': True,
            'LPCWSTR': True,
            'char *': True,
            'wchar_t *': True,
        }
        string_type = name in string_types

        for i in range(0, size):
            value = array[i]
            if string_type:
                value = ffi_obj.string(value)
            output.append(value)
        return output

    def callback(library, signature_name, func):
        ffi_obj = _get_ffi(library)
        return ffi_obj.callback(signature_name, func)

    engine = 'cffi'

else:

    import ctypes
    from ctypes import pointer, c_int, c_char_p, c_uint, c_void_p, c_wchar_p

    _pointer_int_types = int_types + (c_char_p, ctypes.POINTER(ctypes.c_byte))

    _pointer_types = {
        'void *': True,
        'wchar_t *': True,
        'char *': True,
        'char **': True,
    }
    _type_map = {
        'void *': c_void_p,
        'wchar_t *': c_wchar_p,
        'char *': c_char_p,
        'char **': ctypes.POINTER(c_char_p),
        'int': c_int,
        'unsigned int': c_uint,
        'size_t': ctypes.c_size_t,
        'uint32_t': ctypes.c_uint32,
    }
    if sys.platform == 'win32':
        from ctypes import wintypes
        _pointer_types.update({
            'LPSTR': True,
            'LPWSTR': True,
            'LPCSTR': True,
            'LPCWSTR': True,
        })
        _type_map.update({
            'BYTE': ctypes.c_byte,
            'LPSTR': c_char_p,
            'LPWSTR': c_wchar_p,
            'LPCSTR': c_char_p,
            'LPCWSTR': c_wchar_p,
            'ULONG': wintypes.ULONG,
            'DWORD': wintypes.DWORD,
            'char *': ctypes.POINTER(ctypes.c_byte),
            'char **': ctypes.POINTER(ctypes.POINTER(ctypes.c_byte)),
        })

    def _type_info(library, type_):
        is_double_pointer = type_[-3:] == ' **'
        if is_double_pointer:
            type_ = type_[:-1]
        is_pointer = type_[-2:] == ' *' and type_ not in _pointer_types
        if is_pointer:
            type_ = type_[:-2]

        is_array = type_.find('[') != -1
        if is_array:
            is_array = type_[type_.find('[') + 1:type_.find(']')]
            if is_array == '':
                is_array = True
            else:
                is_array = int(is_array)
            type_ = type_[0:type_.find('[')]

        if type_ in _type_map:
            type_ = _type_map[type_]
        else:
            type_ = getattr(library, type_)

        if is_double_pointer:
            type_ = ctypes.POINTER(type_)

        return (is_pointer, is_array, type_)

    def register_ffi(library, ffi_obj):
        pass

    def buffer_from_bytes(initializer):
        return ctypes.create_string_buffer(initializer)

    def buffer_from_unicode(initializer):
        return ctypes.create_unicode_buffer(initializer)

    def write_to_buffer(buffer, data, offset=0):
        if isinstance(buffer, ctypes.POINTER(ctypes.c_byte)):
            ctypes.memmove(buffer, data, len(data))
            return

        if offset == 0:
            buffer.value = data
        else:
            buffer.value = buffer.raw[0:offset] + data

    def buffer_pointer(buffer):
        return pointer(ctypes.cast(buffer, c_char_p))

    def cast(library, type_, value):
        is_pointer, is_array, type_ = _type_info(library, type_)

        if is_pointer:
            type_ = ctypes.POINTER(type_)
        elif is_array:
            type_ = type_ * is_array

        return ctypes.cast(value, type_)

    def sizeof(library, value):
        return ctypes.sizeof(value)

    def bytes_from_buffer(buffer, maxlen=None):
        if isinstance(buffer, _pointer_int_types):
            return ctypes.string_at(buffer, maxlen)
        if maxlen is not None:
            return buffer.raw[0:maxlen]
        return buffer.raw

    def byte_string_from_buffer(buffer):
        return buffer.value

    def byte_array(byte_string):
        return (ctypes.c_byte * len(byte_string))(*bytes_to_list(byte_string))

    def pointer_set(pointer_, value):
        pointer_.contents.value = value

    def array_set(array, value):
        for index, val in enumerate(value):
            array[index] = val

    def null():
        return None

    def is_null(point):
        return not bool(point)

    def errno():
        return ctypes.get_errno()

    def new(library, type_, value=None):
        is_pointer, is_array, type_ = _type_info(library, type_)
        if is_array:
            if is_array is True:
                type_ = type_ * value
                value = None
            else:
                type_ = type_ * is_array

        params = []
        if value is not None:
            params.append(value)
        output = type_(*params)

        if is_pointer:
            output = pointer(output)

        return output

    def ref(value, offset=0):
        if offset == 0:
            return ctypes.byref(value)
        return ctypes.cast(ctypes.addressof(value) + offset, ctypes.POINTER(ctypes.c_byte))

    def native(type_, value):
        if isinstance(value, type_):
            return value
        if sys.version_info < (3,) and type_ == int and isinstance(value, int_types):
            return value
        if isinstance(value, ctypes.Array) and value._type_ == ctypes.c_byte:
            return ctypes.string_at(ctypes.addressof(value), value._length_)
        return type_(value.value)

    def deref(point):
        return point[0]

    def unwrap(point):
        return point.contents

    def struct(library, name):
        return pointer(getattr(library, name)())

    def struct_bytes(struct_):
        return ctypes.string_at(struct_, ctypes.sizeof(struct_.contents))

    def struct_from_buffer(library, type_, buffer):
        class_ = getattr(library, type_)
        value = class_()
        ctypes.memmove(ctypes.addressof(value), buffer, ctypes.sizeof(class_))
        return ctypes.pointer(value)

    def array_from_pointer(library, type_, point, size):
        _, _, type_ = _type_info(library, type_)
        array = ctypes.cast(point, ctypes.POINTER(type_))
        output = []
        for i in range(0, size):
            output.append(array[i])
        return output

    def callback(library, signature_type, func):
        return getattr(library, signature_type)(func)

    engine = 'ctypes'


def get_library(name, dylib_name, version):
    """
    Retrieve the C library path with special handling for Mac

    :param name:
        A unicode string of the library to search the system for

    :param dylib_name:
        Mac only - a unicode string of the unversioned dylib name

    :param version:
        Mac only - a unicode string of the dylib version to use. Used on macOS
        10.15+ when the unversioned dylib is found, since unversioned
        OpenSSL/LibreSSL are just placeholders, and a versioned dylib must be
        imported. Used on macOS 10.16+ when find_library() doesn't return a
        result, due to system dylibs not being present on the filesystem any
        longer.

    :return:
        A unicode string of the path to the library
    """

    library = find_library(name)

    if sys.platform == 'darwin':
        unversioned = '/usr/lib/%s' % dylib_name
        versioned = unversioned.replace('.dylib', '.%s.dylib' % version)
        mac_ver = tuple(map(int, platform.mac_ver()[0].split('.')))
        if not library and mac_ver >= (10, 16):
            # On macOS 10.16+, find_library doesn't work, so we set a static path
            library = versioned
        elif mac_ver >= (10, 15) and library == unversioned:
            # On macOS 10.15+, we want to strongly version since unversioned libcrypto has a non-stable ABI
            library = versioned

    return library


class FFIEngineError(Exception):

    """
    An exception when trying to instantiate ctypes or cffi
    """

    pass