from graphics import Canvas
from karel_asset import *   # https://git.h0v1n8.nl/Stanford/karel_asset
from time import sleep
import asyncio

# Constants    
CANVAS_WIDTH = 400
CANVAS_HEIGHT = 400
canvas = Canvas(CANVAS_WIDTH, CANVAS_HEIGHT)

""" This causes too much flashing, as the Karels are not drawn in sync, and overlap differently on updates.
async def slide_karel(canvas, delay):
    await asyncio.sleep(delay)

    karel = generate_outofbounds_random_karel(canvas, "left")
        
    asyncio.sleep(1)

    # Slide Karels out of the canvas
    if canvas.width < canvas.height:
        size = random.randint(1, canvas.width)
    else:
        size = random.randint(1, canvas.height)

    for i in range(int(CANVAS_WIDTH + size * 2.5)):
        karel = relative_move_asset(karel, x=+1)
        await asyncio.sleep(0.01)
        
    erase_asset(karel)
"""

#async def main():
def main():
    while True: # Loop forever
        background = generate_random_background(canvas)
        sleep(0.5)

        """ See too much flashing comment above
        # Multple simultanious jobs
        await asyncio.gather(
            slide_karel(canvas, 0),
            slide_karel(canvas, 3),
            slide_karel(canvas, 7),
            slide_karel(canvas, 9),
            slide_karel(canvas, 12)
        )
        sleep(0.5)
        """

        """ Not random enough, looks a lot better than async Karels.
        # Create Karels
        karel0 = generate_outofbounds_random_karel(canvas, "left")
        karel1 = generate_outofbounds_random_karel(canvas, "left")
        karel2 = generate_outofbounds_random_karel(canvas, "left")
        karel3 = generate_outofbounds_random_karel(canvas, "left")
        karel4 = generate_outofbounds_random_karel(canvas, "left")

        # Slide Karels
        for i in range(random.randint(1, canvas.width)):
            karel0 = relative_move_asset(karel0, x=+random.randint(1, 2))
            sleep(0.01)
        for i in range(random.randint(1, int(canvas.width / 2))):
            karel0 = relative_move_asset(karel0, x=+random.randint(1, 2))
            karel1 = relative_move_asset(karel1, x=+2)
            sleep(0.01)
        for i in range(random.randint(1, int(canvas.width / 3))):
            karel0 = relative_move_asset(karel0, x=+random.randint(1, 2))
            karel1 = relative_move_asset(karel1, x=+2)
            karel2 = relative_move_asset(karel2, x=+random.randint(1, 7))
            sleep(0.01)
        for i in range(random.randint(1, int(canvas.width / 3))):
            karel0 = relative_move_asset(karel0, x=+random.randint(1, 2))
            karel1 = relative_move_asset(karel1, x=+2)
            karel2 = relative_move_asset(karel2, x=+random.randint(1, 7))
            karel3 = relative_move_asset(karel3, x=+3)
            sleep(0.01)
        for i in range(canvas.width):
            karel0 = relative_move_asset(karel0, x=+random.randint(1, 2))
            karel1 = relative_move_asset(karel1, x=+2)
            karel2 = relative_move_asset(karel2, x=+random.randint(1, 7))
            karel3 = relative_move_asset(karel3, x=+3)
            karel4 = relative_move_asset(karel4, x=+4)
            sleep(0.01)
        
        # Erase Karels
        erase_asset(karel0)
        erase_asset(karel1)
        erase_asset(karel2)
        erase_asset(karel3)
        erase_asset(karel4)
        """

        # Set up asset stack
        amount = random.randint(3, 10)  # Pick random amount of assets
        stack = {}  # Create stack dictionary
        for _ in range(amount): # Create the amount of assets
            asset = generate_outofbounds_random_asset(canvas, "left", karel_prevelance=6)   # Generate asset
            delay = random.randint(0, int(canvas.width * 2))    # Set random delay of a maximum of two canvas widths
            speed = random.choice((1, 2, 3))  # Set random speed
            name = "karel_" + str(_)    # Set dictionary key
            stack.update({name: [asset, delay, speed]}) # Append entry to dictionary
        
        # Slide assets 
        for i in range(canvas.width * 3):   # Slide for three canvas widths
            for key, value in stack.items():    # Loop over asset dictionary
                if value[1] < i:    # If delay has passed
                    asset = relative_move_asset(value[0], x=+value[2]) # Move the Karel
                    stack.update({key: [asset, value[1], value[2]]})    # Update the dictionary
            sleep(0.01) # Wait shortly so the sliding is not CPU speed based
        
        # Erase assets in asset stack
        for value in stack.values():
            erase_asset(value[0])

        # Erase background for in the next loop a new one will be created
        canvas.delete(background)


if __name__ == '__main__':
    #await (main())
    main()