#!/usr/bin/env python3

import random
import sys

import bootstrap
import parallelize as p
import decorator_utils
import executors
import math_utils
import smart_future


@p.parallelize(method=p.Method.THREAD)
def compute_factorial_thread(n):
    total = 1
    for x in range(2, n):
        total *= x
    return total


@p.parallelize(method=p.Method.PROCESS)
def compute_factorial_process(n):
    total = 1
    for x in range(2, n):
        total *= x
    return total


@p.parallelize(method=p.Method.REMOTE)
def list_primes(n):
    """Calculates sum of all primes below given integer n"""
    ret = []
    for x in range(2, n):
        ret.append(math_utils.is_prime(x))
    return ret


@decorator_utils.timed
def driver() -> None:
    results = []
    for _ in range(20):
        results.append(compute_factorial_process(_))
    for future in smart_future.wait_any(results):
        print(f'Process: {future}')

    results = []
    for _ in range(20):
        results.append(compute_factorial_thread(_))
    smart_future.wait_all(results)
    for future in results:
        print(f'Thread: {future}')

    results = {}
    for _ in range(50):
        n = random.randint(0, 100000)
        results[n] = list_primes(n)
    tot = 0
    for _ in results[n]:
        tot += _
    print(tot)


@bootstrap.initialize
def main() -> None:
    print(driver())
    pexecutor = executors.DefaultExecutors().process_pool()
    pexecutor.shutdown()
    texecutor = executors.DefaultExecutors().thread_pool()
    texecutor.shutdown()
    rexecutor = executors.DefaultExecutors().remote_pool()
    rexecutor.shutdown()
    sys.exit(0)


if __name__ == '__main__':
    main()

# print """Usage: python sum_primes.py [ncpus]
#     [ncpus] - the number of workers to run in parallel,
#     if omitted it will be set to the number of processors in the system
# """

# # tuple of all parallel python servers to connect with
# ppservers = ()
# #ppservers = ("10.0.0.1",)

# if len(sys.argv) > 1:
#     ncpus = int(sys.argv[1])
#     # Creates jobserver with ncpus workers
# job_server = pp.Server(ncpus, ppservers=ppservers)
# else:
#     # Creates jobserver with automatically detected number of workers
# job_server = pp.Server(ppservers=ppservers)

# print "Starting pp with", job_server.get_ncpus(), "workers"

# # Submit a job of calulating sum_primes(100) for execution.
# # sum_primes - the function
# # (100,) - tuple with arguments for sum_primes
# # (isprime,) - tuple with functions on which function sum_primes depends
# # ("math",) - tuple with module names which must be imported before sum_primes execution
# # Execution starts as soon as one of the workers will become available
# job1 = job_server.submit(sum_primes, (100,), (isprime,), ("math",))

# # Retrieves the result calculated by job1
# # The value of job1() is the same as sum_primes(100)
# # If the job has not been finished yet, execution will wait here until result is available
# result = job1()

# print "Sum of primes below 100 is", result

# start_time = time.time()

# # The following submits 8 jobs and then retrieves the results
# inputs = (100000, 100100, 100200, 100300, 100400, 100500, 100600, 100700)
# jobs = [(input, job_server.submit(sum_primes,(input,), (isprime,), ("math",))) for input in inputs]
# for input, job in jobs:
#     print "Sum of primes below", input, "is", job()

# print "Time elapsed: ", time.time() - start_time, "s"
# job_server.print_stats()

# # Parallel Python Software: http://www.parallelpython.com