#!/usr/bin/python3

from os import remove, rename, stat
from os.path import basename, isfile, splitext
from shutil import copy
from sys import argv
from time import perf_counter
from zipfile import ZipFile, ZIP_DEFLATED

BLOCK_SIZE = 1024
BLOCK_AMOUNT = 1024**2
COPIES_AMOUNT = 10

get_file_size = lambda filename: stat(filename).st_size
get_filename_without_extension = lambda name: splitext(basename(name))[0]
get_file_extension = lambda name: splitext(basename(name))[-1]


def generate_dummy_file(filename, size):
    with open(filename, "wb") as dummy:
        for i in range(BLOCK_SIZE):
            dummy.write((size * BLOCK_AMOUNT) * b"\0")


def compress_file(infile, outfile):
    zf = ZipFile(outfile, mode="w", allowZip64=True)
    zf.write(infile, compress_type=ZIP_DEFLATED)
    zf.close()


def make_copies_and_compress(infile, outfile, n_copies):
    zf = ZipFile(outfile, mode="w", allowZip64=True)

    for i in range(n_copies):
        f_name = "%s-%d.%s" % (
            get_filename_without_extension(infile),
            i,
            get_file_extension(infile),
        )
        copy(infile, f_name)
        zf.write(f_name, compress_type=ZIP_DEFLATED)
        remove(f_name)

    zf.close()


if __name__ == "__main__":
    if len(argv) != 3:
        print(f"Usage: { basename(__file__) } <n_levels> <out_zip_file>")
        raise SystemExit

    n_levels = int(argv[1])
    out_zip_file = argv[2]

    start_time = perf_counter()

    dummy_name = "empty.bin"
    level_1_zip = "1.zip"
    generate_dummy_file(dummy_name, 1)
    compress_file(dummy_name, level_1_zip)
    remove(dummy_name)

    decompressed_size = 1

    for i in range(1, n_levels + 1):
        make_copies_and_compress("%d.zip" % i, "%d.zip" % (i + 1), COPIES_AMOUNT)
        decompressed_size *= COPIES_AMOUNT
        remove("%d.zip" % i)

    if isfile(out_zip_file):
        remove(out_zip_file)

    rename("%d.zip" % (n_levels + 1), out_zip_file)

    end_time = perf_counter()
    time_diff = end_time - start_time
    compressed_size = get_file_size(out_zip_file)
    decompressed_size *= BLOCK_SIZE * BLOCK_AMOUNT
    print("Compressed file size: %d bytes" % compressed_size)
    print("Decompression file size: %d bytes" % decompressed_size)
    print("Generation time performance: %.15f" % time_diff)