import struct

file_track = []
print_debug = False


def debug_print(s):
    if print_debug:
        print(s)


def init_filetrack(size):
    global file_track
    file_track = [0] * size


def show_filetrack():
    i = 0
    curr = 1
    curr_len = 0
    while i < len(file_track):
        if file_track[i] != curr:
            if curr == 0:
                print("%s starts at %s, ends at %s for %s (%s) bytes (%s ints)" % (curr, i-curr_len, i, curr_len, hex(curr_len), curr_len/4))
            curr = file_track[i]
            curr_len = 1
        else:
            curr_len += 1
        i += 1
    print(file_track)


def advance_track(offset, size):
    if not file_track:
        return
    for i in range(size):
        file_track[offset+i] = 1


def stat_track():
    r = 0
    total = len(file_track)
    for i in file_track:
        if i == 1:
            r += 1
    return r/total*100


def read_int(fp):
    advance_track(fp.tell(), 4)
    return struct.unpack("<L", fp.read(4))[0]


def read_byte(fp):
    advance_track(fp.tell(), 1)
    return struct.unpack("<B", fp.read(1))[0]


def read_float(fp):
    advance_track(fp.tell(), 4)
    return struct.unpack("<f", fp.read(4))[0]


def read_short(fp):
    advance_track(fp.tell(), 2)
    return struct.unpack("<H", fp.read(2))[0]


def read_string(fp, size):
    return read_bytes(fp, size).decode("utf8").replace("\x00", "")


def read_bytes(fp, size):
    advance_track(fp.tell(), size)
    return bytes(struct.unpack('<' + str(size) + 'B', fp.read(size)))


def read_string_until_none(fp) -> str:
    s = ""
    c = read_byte(fp)
    while c != 0x00:
        s += chr(c)
        c = read_byte(fp)
    return s


def decompress(compressed_bytes, original_size: int):
    i = 0
    j = 0
    dec_byte = 0
    dec_bits = 8
    buff_start = 0xFEE

    res = bytearray(original_size)

    if original_size == 0:
        return res

    while j < original_size:
        if dec_bits == 8:
            dec_byte = compressed_bytes[i]
            i += 1
            dec_bits = 0
        if (dec_byte >> dec_bits & 1) == 0:
            dec_pos = ((compressed_bytes[i] + (
                        (compressed_bytes[i + 1] & 0xF0) << 4) - buff_start - j) & 0xFFF) - 0x1000 + j
            dec_len = (compressed_bytes[i + 1] & 0xF) + 3
            i += 2
            while dec_len > 0:
                if dec_pos >= 0:
                    res[j] = res[dec_pos]
                else:
                    res[j] = 32
                j += 1
                dec_pos += 1
                dec_len -= 1
        else:
            res[j] = compressed_bytes[i]
            i += 1
            j += 1
        dec_bits += 1
    return res


def read_int_and_print(n, b):
    a = read_int(b)
    debug_print("%s=%s" % (n, a))
    return a


def read_float_and_print(n, b):
    a = read_float(b)
    debug_print("%s=%s" % (n, a))
    return a


def read_byte_and_print(n, b):
    a = read_byte(b)
    debug_print("%s=%s" % (n, a))
    return a


def read_short_and_print(n, b):
    a = read_short(b)
    debug_print("%s=%s" % (n, a))
    return a


def read_string_until_none_and_print(n, b):
    s = read_string_until_none(b)
    debug_print("%s=%s" % (n, s))
    return s