import Algorithmia
import tensorflow as tf
import os
from .auxillary import load_model, id_to_string
import numpy as np

client = Algorithmia.client()
graph, label_index = load_model(client)

# API calls will begin at the apply() method, with the request body passed as 'input'
# For more details, see algorithmia.com/developers/algorithm-development/languages
    
def get_image(url):
    """Uses the Smart Image Downloader algorithm to format and download images from the web or other places."""
    input = {'image': str(url)}
    output_url = client.algo("util/SmartImageDownloader/0.2.x").pipe(input).result['savePath'][0]
    temp_file = client.file(output_url).getFile().name
    os.rename(temp_file, temp_file + '.' + output_url.split('.')[-1])
    return temp_file + '.' + output_url.split('.')[-1]

def do_work(image):
    """Does some computer vision work and needs a numpy array to function"""
    image_data = tf.gfile.FastGFile(image, 'rb').read()
    with tf.Session(graph=graph) as sess:
        softmax_tensor = sess.graph.get_tensor_by_name('softmax:0')
        predictions = sess.run(softmax_tensor,
                               {'DecodeJpeg/contents:0': image_data})
        predictions = np.squeeze(predictions)
        tags = []
        top_k = predictions.argsort()[-5:][::-1]

        for node_id in top_k:
            human_string = id_to_string(label_index, node_id)
            score = predictions[node_id]
            result = {}
            result['class'] = human_string
            result['confidence'] = score.item()
            tags.append(result)
        results = {}
        results['tags'] = tags
        return results

def apply(input):
    image_data = get_image(input)
    results = do_work(image_data)
    return results

...
...
import asyncio
...
...

# We've added a processor function that gets and processes an image, but is prefixed with an  'async'
# We did this, as when dealing with batch for image processing algorithms, it's common that bottleneck is http and getting
# the images from a remote resource into your system.

# You can read more about 'asyncio' here: https://docs.python.org/3/library/asyncio.html
# Bare in mind that if you're using a version of python < 3.5, you'll need to import it as a pypi package.

async def process_url(url):
    image_data = get_image(url)
    result = do_work(image_data)
    return result

def apply(input):
    loop = asyncio.get_event_loop()
    # We have a list of inputs that we're going to want to loop over
    if isinstance(input, list):
        future_images = []
        for url in input:
            async_image = asyncio.ensure_future(process_url(url))
            future_images.append(async_image)
        # Now we have a list of promises, let's loop through them until there's nothing left
        results = loop.run_until_complete(asyncio.gather(*future_images))
        return  results
    elif isinstance(input, str):
        # And if we are only processing one image at a time, lets keep the old functionality as well
        image_data = get_image(input)
        result = do_work(image_data)
        return result
    else:
        raise Exception("Invalid input, expecting a list of Urls or a single URL string.")

...
...
from multiprocessing import Manager, Pool

# API calls will begin at the apply() method, with the request body passed as 'input'
# For more details, see algorithmia.com/developers/algorithm-development/languages

ALGO_1 = "algorithmiahq/DeepFashion/1.3.0"
ALGO_2 = "algorithmiahq/multistageclassifierpetsdemo/0.1.0"
ALGO_3 = "character_recognition/tesseract/0.3.0"
# This threadpool is shared between all 3 algorithm requests, this keeps the number of active children restricted and easily controlled
# If desired, we could split this up into a dedicated threadpool for each child algorithm
THREADPOOL_SIZE = 5

client = Algorithmia.client()

def call_ALGO_1(image, errorQ):
    try:
        if errorQ.empty():
            input = {"image": image, "model": "small", "tags_only": True}
            print("running algo 1 with: {} ...".format(image))
            result = client.algo(ALGO_1).pipe(input).result
            print("finished algo 1 with: {}...".format(image))
            return {"image": image, "result": result}
        else:
            return None
    except Exception as e:
        errorQ.put(e)

def call_ALGO_2(image, errorQ):
    try:
        if errorQ.empty():
            input = image
            print("running algo 2 with: {} ...".format(image))
            result = client.algo(ALGO_2).pipe(input).result
            print("finished algo 2 with: {}...".format(image))
            return {"image": image, "result": result}
        else:
            return None
    except Exception as e:
        errorQ.put(e)

def call_ALGO_3(image, errorQ):
    try:
        if errorQ.empty():
            input = {"image": image, "language": "eng"}
            print("running algo 3 with: ...".format(image))
            result = client.algo(ALGO_3).pipe(input).result
            print("finished algo 3 with: {}...".format(image))
            return {"image": image, "result": result}
        else:
            return None
    except Exception as e:
        errorQ.put(e)

def apply(input):
    if isinstance(input, list):
        process_pool = Pool(THREADPOOL_SIZE)
        manager = Manager()
        errorQ = manager.Queue()
        threadable_inputs = [(image, errorQ) for image in input]
        algo1_c = process_pool.starmap_async(call_ALGO_1, threadable_inputs)
        algo2_c = process_pool.starmap_async(call_ALGO_2, threadable_inputs)
        algo3_c = process_pool.starmap_async(call_ALGO_3, threadable_inputs)
        algo1_results = algo1_c.get()
        algo2_results = algo2_c.get()
        algo3_results = algo3_c.get()
        if errorQ.empty():
            return {"algo_1": algo1_results, "algo_2": algo2_results, "algo_3": algo3_results}
        else:
            raise errorQ.get()
    else:
        raise Exception("Input must be a list of image urls")

...
...
from multiprocessing import Manager, Pool
...
...

# In this example we look at solving batch processing problems with algorithm recursion and pipelining.

client = Algorithmia.client()
graph, label_index = load_model(client)

#-- IMPORANT --# be aware of the algorithm version you're calling, as this is self-referential while you're doing development you may need to replace this variable with a version hash.
THIS_ALGO = "zeryx/recursive_image_example/0.1.x"
# The number of recursive requests that will be open at any time, this keeps us from overwelming the development environment by constraining our resources to some reasonable maximum.
NUM_PARALLEL_REQUESTS = 10
# The maximum amount of work each algorithm will request will handle before recursing
MAX_WORK_PER_REQUEST = 8

...
...

def algorithm_recursion_(input, errorQ):
    """This function will create a threadpool and make parallel calls to _algo, and return a callback.
    As you can see, we limit the pool size by some value to ensure we don't overload anthing.
    Besides that, we also blend the errorQ object into each chunk of data that we're passing into _algo.

    If desired, a pool.starmap() can simplify this process."""
    pool = Pool(NUM_PARALLEL_REQUESTS)
    chunks = _chunks(input, MAX_WORK_PER_REQUEST)
    process_data = [(chunk, errorQ) for chunk in chunks]
    async_ops = pool.starmap_async(_algo, process_data)
    return async_ops

def _chunks(l, n):
    """Yield successive n-sized chunks from l."""
    for i in range(0, len(l), n):
        yield l[i:i + n]

def _algo(algo_data, errorQ):
    """The primary working algorithm for our parallel threads, makes parallel requests and checks if errors exist"""
    try:
        if errorQ.empty():
            print("processing chunk..")
            response = client.algo(THIS_ALGO).pipe(algo_data).result
            print("finished chunk..")
            return response
        else:
            return None

    except Exception as e:
        errorQ.put(e)

def batch_apply(input):
    """Simple sequential small batch processing, can be made parallel if necessary"""
    results = []
    for image in input:
        results.append(apply(image))
    return results

def apply(input):
    if isinstance(input, str):
        image = get_image(input)
        results = {"image": input, "results": do_work(image)}
    elif isinstance(input, dict) and "image" in input:
        image = get_image(input['image'])
        results = {"image": input['image'], "results": do_work(image)}
    elif isinstance(input, list):
        # If we do have a small list, it doesn't make sense to send off each request to a different machine,
        # it might just be easier to process it here.
        if len(input) < MAX_WORK_PER_REQUEST:
            results = batch_apply(input)
        else:
            # Lets take some work for this algorithm to work on, before we pass the remainder to our recursively
            # called algorithms
            input_for_this_worker = input[:MAX_WORK_PER_REQUEST]
            remaining_work = input[MAX_WORK_PER_REQUEST:]
            # This object allows us to pass error messages and exceptions between threads, which can be very useful
            # when things don't go as planned
            manager = Manager()
            errorQ = manager.Queue()
            # We spin off the recursive / threading components of the algorithm to a separate thread so that we can
            # process this algorithm's batch of work concurrently
            eventual_remote_results = algorithm_recursion_(remaining_work, errorQ)
            local_results = batch_apply(input_for_this_worker)
            concurrent_results = eventual_remote_results.get()
            # Make sure to check your error Q before returning a result, if it has errors we should return them as
            # something went wrong
            if errorQ.empty():
                results = local_results + concurrent_results
            else:
                raise errorQ.get()
    else:
        raise Exception("Input format invalid")
    return results