import array
import os
import threading
import time
from concurrent import interpreters

import numpy as np


n_cores = os.cpu_count() // 2
print("Working with half of available cores:", n_cores)


def boundaries(parts, size):
    """Calculate boundaries.

    Ejemplos:
        boundaries(4, 23) -> [0, 6, 12, 18, 23]
        boundaries(7, 25) -> [0, 4, 8, 12, 16, 19, 22, 25]
    """
    len_bigs = size % parts
    len_smalls = parts - len_bigs
    chunk_sizes = [size // parts + 1] * len_bigs + [size // parts] * len_smalls

    result = [0]
    for cs in chunk_sizes:
        result.append(result[-1] + cs)
    return result


def sum_seq(a, b, c, lim_inf, lim_sup):
    """Sum sequentially between two limits."""
    for i in range(lim_inf, lim_sup):
        c[i] = a[i] + b[i]


def serial(size):
    """Sequential, reading and writing into lists."""
    a = [1] * size
    b = [3] * size
    c = [None] * size
    sum_seq(a, b, c, 0, size)
    return c


def subinterp_tuple_array(size):
    """Subinterpreters, reading from tuples, writing into arrays."""
    a = tuple([1] * size)
    b = tuple([3] * size)
    bnd = boundaries(n_cores, size)
    c = memoryview(array.array("B", [0] * size))

    def run_in_interp(i):
        lim_inf = bnd[i]
        lim_sup = bnd[i + 1]
        interp = interpreters.create()
        interp.call(sum_seq, a, b, c, lim_inf, lim_sup)

    threads = []
    for i in range(n_cores):
        t = threading.Thread(target=run_in_interp, args=(i,))
        t.start()
        threads.append(t)
    for t in threads:
        t.join()

    return c


def subinterp_tuple_numpy(size):
    """Subinterpreters, reading from tuples, writing into numpy."""
    a = tuple([1] * size)
    b = tuple([3] * size)
    bnd = boundaries(n_cores, size)
    c = np.ndarray((size,), dtype=np.int8)
    m = memoryview(c)

    def run_in_interp(i):
        lim_inf = bnd[i]
        lim_sup = bnd[i + 1]
        interp = interpreters.create()
        interp.call(sum_seq, a, b, m, lim_inf, lim_sup)

    threads = []
    for i in range(n_cores):
        t = threading.Thread(target=run_in_interp, args=(i,))
        t.start()
        threads.append(t)
    for t in threads:
        t.join()

    return c


def subinterp_numpy_array(size):
    """Subinterpreters, reading from numpy, writing into arrays."""
    a = memoryview(np.full(size, 1))
    b = memoryview(np.full(size, 3))
    bnd = boundaries(n_cores, size)
    c = memoryview(array.array("B", [0] * size))

    def run_in_interp(i):
        lim_inf = bnd[i]
        lim_sup = bnd[i + 1]
        interp = interpreters.create()
        interp.call(sum_seq, a, b, c, lim_inf, lim_sup)

    threads = []
    for i in range(n_cores):
        t = threading.Thread(target=run_in_interp, args=(i,))
        t.start()
        threads.append(t)
    for t in threads:
        t.join()

    return c


def subinterp_numpy_numpy(size):
    """Subinterpreters, reading and writing from/to numpy."""
    a = memoryview(np.full(size, 1))
    b = memoryview(np.full(size, 3))
    bnd = boundaries(n_cores, size)
    c = np.ndarray((size,), dtype=np.int8)
    m = memoryview(c)

    def run_in_interp(i):
        lim_inf = bnd[i]
        lim_sup = bnd[i + 1]
        interp = interpreters.create()
        interp.call(sum_seq, a, b, m, lim_inf, lim_sup)

    threads = []
    for i in range(n_cores):
        t = threading.Thread(target=run_in_interp, args=(i,))
        t.start()
        threads.append(t)
    for t in threads:
        t.join()

    return c


def sequential_tuple_array(size):
    """Sequential, reading from tuples, writing into arrays."""
    a = tuple([1] * size)
    b = tuple([3] * size)
    c = memoryview(array.array("B", [0] * size))

    sum_seq(a, b, c, 0, size)
    return c


def sequential_tuple_numpy(size):
    """Sequential, reading from tuples, writing into numpy."""
    a = tuple([1] * size)
    b = tuple([3] * size)
    c = np.ndarray((size,), dtype=np.int8)
    m = memoryview(c)

    sum_seq(a, b, m, 0, size)
    return c


def sequential_numpy_array(size):
    """Sequential, reading from numpy, writing into arrays."""
    a = memoryview(np.full(size, 1))
    b = memoryview(np.full(size, 3))
    c = memoryview(array.array("B", [0] * size))

    sum_seq(a, b, c, 0, size)
    return c


def sequential_numpy_numpy(size):
    """Sequential, reading and writing from/to numpy."""
    a = memoryview(np.full(size, 1))
    b = memoryview(np.full(size, 3))
    c = np.ndarray((size,), dtype=np.int8)
    m = memoryview(c)

    sum_seq(a, b, m, 0, size)
    return c


def test(func):
    size = 500_000
    print(f"\n{func.__name__}: {func.__doc__}")
    t_start = time.time()
    result = func(size)
    print("    end:", time.time() - t_start)
    assert len(result) == size
    assert set(result) == {4}


_variants = [
    serial,
    subinterp_tuple_array,
    subinterp_tuple_numpy,
    subinterp_numpy_array,
    subinterp_numpy_numpy,
    sequential_tuple_array,
    sequential_tuple_numpy,
    sequential_numpy_array,
    sequential_numpy_numpy,
]


for func in _variants:
    test(func)
