# Read file
# https://bitcoin.org/en/developer-reference#block-headers
# https://en.bitcoin.it/wiki/Protocol_specification#block
magic            = ds.read_bytes(4).encode('hex')
block_size       = int(ds.read_bytes(4).encode('hex'), 16)
version          = ds.read_bytes(4).encode('hex')
prev_header_hash = ds.read_bytes(32).encode('hex')
merkle_root_hash = ds.read_bytes(32).encode('hex')
timestamp        = ds.read_bytes(4).encode('hex')
nBits            = ds.read_bytes(4).encode('hex')
nonce            = ds.read_bytes(4).encode('hex')

num_of_transaction = ds.read_bytes(1).encode('hex')
tx_version         = ds.read_bytes(4).encode('hex')
tx_input           = ds.read_bytes(1).encode('hex')
tx_prev_output     = ds.read_bytes(36).encode('hex')
script_length      = ds.read_bytes(1).encode('hex')
scriptsig          = ds.read_bytes(int((script_length), 16)).encode('hex')
sequence           = ds.read_bytes(4).encode('hex')
tx_output          = ds.read_bytes(1).encode('hex')
BTC_num            = ds.read_bytes(8).encode('hex')
pk_script_len      = ds.read_bytes(1).encode('hex')
pk_script          = ds.read_bytes(int(pk_script_len, 16)).encode('hex')
lock_time          = ds.read_bytes(4).encode('hex')

# Read file
# https://bitcoin.org/en/developer-reference#block-headers
# https://en.bitcoin.it/wiki/Protocol_specification#block
magic = ds.read_bytes(4).hex()
block_size = int(struct.pack('>l', *struct.unpack('<l', ds.read_bytes(4))).hex(), 16)
version = struct.pack('>l', *struct.unpack('<l', ds.read_bytes(4))).hex()
prev_header_hash = ds.read_bytes(32)[::-1].hex()
merkle_root_hash = ds.read_bytes(32)[::-1].hex()
timestamp = ds.read_bytes(4)[::-1].hex()
nBits = ds.read_bytes(4)[::-1].hex()
nonce = ds.read_bytes(4)[::-1].hex()

fproofofburn = ds.read_boolean()
hashburnblock = ds.read_bytes(32)[::-1].hex()
burnhash = ds.read_bytes(32)[::-1].hex()
burnblockheight = ds.read_int32()
burnctx = ds.read_int32()
burnctxout = ds.read_int32()
neffectiveburncoins = ds.read_int64()
nburnbits = ds.read_uint32()

num_of_transaction = ds.read_bytes(1)[::-1].hex()
tx_version = ds.read_bytes(4)[::-1].hex()
tx_ntime = ds.read_bytes(4)[::-1].hex()
tx_input = ds.read_bytes(1)[::-1].hex()
tx_prev_output_hash = ds.read_bytes(32)[::-1].hex()
tx_prev_output_sequence = ds.read_bytes(4)[::-1].hex()
coinbase_tx_length = ds.read_bytes(1)[::-1].hex()
coinbase_tx = ds.read_bytes(int((coinbase_tx_length), 16)).hex()
sequence = ds.read_bytes(4)[::-1].hex()
tx_output = ds.read_bytes(2)[::-1].hex()
BTC_num = ds.read_bytes(8)[::-1].hex()
pk_script_len = ds.read_bytes(1)[::-1].hex()
pk_script = ds.read_bytes(int(pk_script_len, 16))[::-1].hex()
lock_time = ds.read_bytes(4)[::-1].hex()

import struct  # conversion between Python values and C structs as Python strings
try:
    import StringIO  # Reads and writes a string buffer
except ImportError:
    from io import StringIO
import os
import mmap  # mutable string
from binascii import unhexlify, hexlify

class BCDataStream(object):
    def __init__(self):
        self.input = None
        self.read_cursor = 0

    def clear(self):
        self.input = None
        self.read_cursor = 0

    def write(self, bytes):  # Initialize with string of bytes
        if self.input is None:
            self.input = bytes
        else:
            self.input += bytes

    def map_file(self, file, start):  # Initialize with bytes from file
        self.input = mmap.mmap(file.fileno(), 0, access=mmap.ACCESS_READ)
        self.read_cursor = start

    def seek_file(self, position):
        self.read_cursor = position

    def close_file(self):
        self.input.close()

    def read_string(self):
        # Strings are encoded depending on length:
        # 0 to 252 :  1-byte-length followed by bytes (if any)
        # 253 to 65,535 : byte'253' 2-byte-length followed by bytes
        # 65,536 to 4,294,967,295 : byte '254' 4-byte-length followed by bytes
        # ... and the Bitcoin client is coded to understand:
        # greater than 4,294,967,295 : byte '255' 8-byte-length followed by bytes of string
        # ... but I don't think it actually handles any strings that big.
        if self.input is None:
            raise SerializationError("call write(bytes) before trying to deserialize")

        try:
            length = self.read_compact_size()
        except IndexError:
            raise SerializationError("attempt to read past end of buffer")

        return self.read_bytes(length)

    def write_string(self, string):
        # Length-encoded as with read-string
        self.write_compact_size(len(string))
        self.write(string)

    def read_bytes(self, length):
        try:
            result = self.input[self.read_cursor:self.read_cursor + length]
            self.read_cursor += length
            return result
        except IndexError:
            raise SerializationError("attempt to read past end of buffer")

        return ''

    def read_boolean(self):
        return self.read_bytes(1)[0] != chr(0)

    def read_int16(self):
        return self._read_num('>h')

    def read_uint16(self):
        return self._read_num('>H')

    def read_int32(self):
        return self._read_num('>i')

    def read_uint32(self):
        return self._read_num('>I')

    def read_int64(self):
        return self._read_num('>q')

    def read_uint64(self):
        return self._read_num('>Q')

    def write_boolean(self, val):
        return self.write(chr(1) if val else chr(0))

    def write_int16(self, val):
        return self._write_num('>h', val)

    def write_uint16(self, val):
        return self._write_num('>H', val)

    def write_int32(self, val):
        return self._write_num('>i', val)

    def write_uint32(self, val):
        return self._write_num('>I', val)

    def write_int64(self, val):
        return self._write_num('>q', val)

    def write_uint64(self, val):
        return self._write_num('>Q', val)

    def read_compact_size(self):
        size = ord(self.input[self.read_cursor])
        self.read_cursor += 1
        if size == 253:
            size = self._read_num('>H')
        elif size == 254:
            size = self._read_num('>I')
        elif size == 255:
            size = self._read_num('>Q')
        return size

    def write_compact_size(self, size):
        if size < 0:
            raise SerializationError("attempt to write size < 0")
        elif size < 253:
            self.write(chr(size))
        elif size < 2**16:
            self.write('\xfd')
            self._write_num('>H', size)
        elif size < 2**32:
            self.write('\xfe')
            self._write_num('>I', size)
        elif size < 2**64:
            self.write('\xff')
            self._write_num('>Q', size)

    def _read_num(self, format):
        (i,) = struct.unpack_from(format, self.input, self.read_cursor)
        self.read_cursor += struct.calcsize(format)
        return i

    def _write_num(self, format, num):
        s = struct.pack(format, num)
        self.write(s)

def import_blkdat():
        pass

ds = BCDataStream()
with open("/home/{}/.slimcoin/blk0001.dat".format(os.environ['USER']), "rb") as file:
    ds.map_file(file, 0)

# Read file
    # https://bitcoin.org/en/developer-reference#block-headers
    # https://en.bitcoin.it/wiki/Protocol_specification#block
    magic = ds.read_bytes(4).hex()
    block_size = int(struct.pack('>l', *struct.unpack('<l', ds.read_bytes(4))).hex(), 16)
    version = struct.pack('>l', *struct.unpack('<l', ds.read_bytes(4))).hex()
    prev_header_hash = ds.read_bytes(32)[::-1].hex()
    merkle_root_hash = ds.read_bytes(32)[::-1].hex()
    timestamp = ds.read_bytes(4)[::-1].hex()
    nBits = ds.read_bytes(4)[::-1].hex()
    nonce = ds.read_bytes(4)[::-1].hex()

    fproofofburn = ds.read_boolean()
    hashburnblock = ds.read_bytes(32)[::-1].hex()
    burnhash = ds.read_bytes(32)[::-1].hex()
    burnblockheight = ds.read_int32()
    burnctx = ds.read_int32()
    burnctxout = ds.read_int32()
    neffectiveburncoins = ds.read_int64()
    nburnbits = ds.read_uint32()

    num_of_transaction = ds.read_bytes(1)[::-1].hex()
    tx_version = ds.read_bytes(4)[::-1].hex()
    tx_ntime = ds.read_bytes(4)[::-1].hex()
    tx_input = ds.read_bytes(1)[::-1].hex()
    tx_prev_output_hash = ds.read_bytes(32)[::-1].hex()
    tx_prev_output_sequence = ds.read_bytes(4)[::-1].hex()
    coinbase_tx_length = ds.read_bytes(1)[::-1].hex()
    coinbase_tx = ds.read_bytes(int((coinbase_tx_length), 16)).hex()
    sequence = ds.read_bytes(4)[::-1].hex()
    tx_output = ds.read_bytes(2)[::-1].hex()
    BTC_num = ds.read_bytes(8)[::-1].hex()
    pk_script_len = ds.read_bytes(1)[::-1].hex()
    pk_script = ds.read_bytes(int(pk_script_len, 16))[::-1].hex()
    lock_time = ds.read_bytes(4)[::-1].hex()
    # If all the data in the genesis block has been read, then the next
    # four bytes should be the "magic bytes" denoting the start of the
    # next block
    nextmagic = ds.read_bytes(4).hex()

    print('magic: {} (6e, 8b, 92, a5)'.format(magic))
    print('block_size: {}'.format(block_size))
    print('version: {}'.format(version))
    print('prevhash: {}'.format(prev_header_hash))
    print('merkle_root: {}'.format(merkle_root_hash))
    print('timestamp: {})'.format(
        int(timestamp, 16), datetime.fromtimestamp(int(timestamp, 16)).isoformat()))
    print('nBits: {}'.format(nBits))
    print('nonce: {}'.format(int(nonce, 16)))

    print('fproofofburn: {}'.format(fproofofburn))
    print('hashburnblock: {}'.format(hashburnblock))
    print('burnhash: {}'.format(burnhash))
    print('burnblockheight: {}'.format(burnblockheight))
    print('burnctx: {}'.format(burnctx))
    print('burnctxout: {}'.format(burnctxout))
    print('neffectiveburncoins: {}'.format(neffectiveburncoins))
    print('nburnbits: {}'.format(nburnbits))

    print('--------------------- Transaction Details: ---------------------')
    print('num_of_transaction: {}'.format(int(num_of_transaction, 16)))
    print('tx_version: {}'.format(tx_version))
    print('tx_ntime: {} ({})'.format(tx_ntime, datetime.fromtimestamp(int(tx_ntime, 16)).isoformat()))
    print('tx_input_num: {}'.format(int(tx_input, 16)))
    print('tx_prev_output_hash: {}'.format(tx_prev_output_hash))
    print('tx_prev_output_sequence: {}'.format(tx_prev_output_sequence))
    print('coinbase_tx_length: {}'.format(coinbase_tx_length))
    print('coinbase_tx: {}'.format(coinbase_tx))
    print('sequence: {}'.format(sequence))
    print('tx_output_num: {}'.format(tx_output))
    print('BTC_num: {}'.format(BTC_num))
    print('pk_script_len: {}'.format(pk_script_len))
    print('pk_script: {}'.format(pk_script))
    print('lock_time: {} ({})'.format(lock_time, datetime.fromtimestamp(int(lock_time, 16)).isoformat()))
    print('----------------------- End of Block: ------------------------')
    print('nextmagic: {} (6e, 8b, 92, a5)'.format(nextmagic))

ds.close_file()