import bitarray
from typing import Optional

from ._cell import Cell
from ..utils._address import Address


class Slice:
    """Slice like an analog of slice in FunC. Used only for reading."""
    def __init__(self, cell: Cell):
        self.bits = bitarray.bitarray()
        self.bits.frombytes(cell.bits.array)
        self.bits = self.bits[:cell.bits.cursor]
        self.refs = cell.refs
        self.ref_offset = 0

    def __len__(self):
        return len(self.bits)

    def __repr__(self):
        return hex(int(self.bits.to01(), 2))[2:].upper()

    def is_empty(self) -> bool:
        return len(self.bits) == 0

    def end_parse(self):
        """Throws an exception if the slice is not empty."""
        if not self.is_empty() or self.ref_offset != len(self.refs):
            raise Exception("Slice is not empty.")

    def read_bit(self) -> int:
        """Reads single bit from the slice."""
        bit = self.bits[0]
        del self.bits[0]
        return bit

    def preload_bit(self) -> int:
        return self.bits[0]

    def read_bits(self, bit_count: int) -> bitarray.bitarray:
        bits = self.bits[:bit_count]
        del self.bits[:bit_count]
        return bits

    def preload_bits(self, bit_count: int) -> bitarray.bitarray:
        return self.bits[:bit_count]

    def skip_bits(self, bit_count: int):
        del self.bits[:bit_count]

    def read_uint(self, bit_length: int) -> int:
        value = self.bits[:bit_length]
        del self.bits[:bit_length]
        return int(value.to01(), 2)

    def preload_uint(self, bit_length: int) -> int:
        value = self.bits[:bit_length]
        return int(value.to01(), 2)

    def read_bytes(self, bytes_count: int) -> bytes:
        length = bytes_count * 8
        value = self.bits[:length]
        del self.bits[:length]
        return value.tobytes()

    def read_int(self, bit_length: int) -> int:
        if bit_length == 1:
            # if num is -1 then bit is 1. if 0 then 1. see _bit_string.py
            return - self.read_bit()
        else:
            is_negative = self.read_bit()
            value = self.read_uint(bit_length - 1)
            if is_negative == 1:
                # ones complement
                return - (2 ** (bit_length - 1) - value)
            else:
                return value

    def preload_int(self, bit_length: int) -> int:
        tmp = self.bits
        value = self.read_int(bit_length)
        self.bits = tmp
        return value

    def read_msg_addr(self) -> Optional[Address]:
        """Reads contract address from the slice.
        May return None if there is a zero-address."""
        if self.read_uint(2) == 0:
            return None
        self.read_bit()  # anycast
        workchain_id = hex(self.read_int(8)).replace('0x', '')
        hashpart = self.read_bytes(32).hex()
        return Address(workchain_id + ":" + hashpart)

    def read_coins(self) -> int:
        """Reads an amount of coins from the slice. Returns nanocoins."""
        length = self.read_uint(4)
        if length == 0:  # 0 in length means 0 coins
            return 0
        else:
            return self.read_uint(length * 8)

    def read_grams(self) -> int:
        """Reads an amount of coins from the slice. Returns nanocoins."""
        return self.read_coins()

    def read_string(self, length: int = 0) -> str:
        """Reads string from the slice.
        If length is 0, then reads string until the end of the slice."""
        if length == 0:
            length = len(self.bits) // 8
        return self.read_bytes(length).decode("utf-8")

    def read_ref(self) -> Cell:
        """Reads next reference cell from the slice."""
        ref = self.refs[self.ref_offset]
        self.ref_offset += 1
        return ref

    def preload_ref(self) -> Cell:
        return self.refs[self.ref_offset]

    def load_dict(self) -> Optional[Cell]:
        """Loads dictionary like a Cell from the slice.
        Returns None if the dictionary was null()."""
        not_null = self.read_bit()
        if not_null:
            return self.read_ref()
        else:
            return None

    def preload_dict(self) -> Optional[Cell]:
        not_null = self.preload_bit()
        if not_null:
            return self.preload_ref()
        else:
            return None

    def skip_dict(self):
        self.load_dict()