import ctypes
import dataclasses
from typing import Optional

import binaryninja
from binaryninja import BinaryView
from binaryninja._binaryninjacore import BNFreeStringList, BNAllocString, BNFreeString

from . import _sharedcachecore as sccore
from .sharedcache_enums import *

[docs]
@dataclasses.dataclass
class CacheRegion:
    region_type: SharedCacheRegionType
    name: str
    start: int
    size: int
    image_start: int
    # TODO: Might want to make this use the BN segment flag enum?
    flags: sccore.SegmentFlagEnum

    def __str__(self):
        return repr(self)

    def __repr__(self):
        return f"<CacheRegion '{self.name}': 0x{self.start:x} + {self.size:x}>"


[docs]
@dataclasses.dataclass
class CacheImage:
    name: str
    header_address: int
    region_starts: [int]

    def __str__(self):
        return repr(self)

    def __repr__(self):
        return f"<CacheImage '{self.name}': 0x{self.header_address:x}>"


[docs]
@dataclasses.dataclass
class CacheSymbol:
    symbol_type: sccore.SymbolTypeEnum
    symbol_binding: sccore.SymbolBindingEnum
    address: int
    name: str

    def __str__(self):
        return repr(self)

    def __repr__(self):
        return f"<CacheSymbol '{self.name}': 0x{self.address:x}>"


[docs]
def region_from_api(region: sccore.BNSharedCacheRegion) -> CacheRegion:
    return CacheRegion(
        region_type=SharedCacheRegionType(region.regionType),
        name=region.name,
        start=region.vmAddress,
        size=region.size,
        image_start=region.imageStart,
        flags=region.flags
    )


[docs]
def region_to_api(region: CacheRegion) -> sccore.BNSharedCacheRegion:
    return sccore.BNSharedCacheRegion(
        regionType=region.region_type,
        _name=BNAllocString(region.name),
        vmAddress=region.start,
        size=region.size,
        imageStart=region.image_start,
        flags=region.flags
    )


[docs]
def image_from_api(image: sccore.BNSharedCacheImage) -> CacheImage:
    region_starts = []
    for i in range(image.regionStartCount):
        region_starts.append(image.regionStarts[i])
    return CacheImage(
        name=image.name,
        header_address=image.headerAddress,
        region_starts=region_starts
    )


[docs]
def image_to_api(image: CacheImage) -> sccore.BNSharedCacheImage:
    region_start_array = (ctypes.c_ulonglong * len(image.region_starts))()
    for i, region_start in enumerate(image.region_starts):
        region_start_array[i] = region_start
    core_region_starts = sccore.BNSharedCacheAllocRegionList(region_start_array, len(region_start_array))
    return sccore.BNSharedCacheImage(
        _name=BNAllocString(image.name),
        headerAddress=image.header_address,
        regionStartCount=len(region_start_array),
        regionStarts=core_region_starts
    )


[docs]
def symbol_from_api(symbol: sccore.BNSharedCacheSymbol) -> CacheSymbol:
    return CacheSymbol(
        symbol_type=symbol.symbolType,
        symbol_binding=symbol.symbolBinding,
        address=symbol.address,
        name=symbol.name
    )


[docs]
def symbol_to_api(symbol: CacheSymbol) -> sccore.BNSharedCacheSymbol:
    return sccore.BNSharedCacheSymbol(
        symbolType=symbol.symbol_type,
        symbolBinding=symbol.symbol_binding,
        address=symbol.address,
        _name=BNAllocString(symbol.name)
    )






def _get_shared_cache(instance: binaryninja.PythonScriptingInstance):
    if instance.interpreter.active_view is None:
        return None
    controller = SharedCacheController(instance.interpreter.active_view)
    if not controller.is_valid():
        return None
    return controller


binaryninja.PythonScriptingProvider.register_magic_variable(
	"dsc",
    _get_shared_cache
)

binaryninja.PythonScriptingProvider.register_magic_variable(
    "shared_cache",
    _get_shared_cache
)