__author__ = 'Viacheslav Demeshko'

import threading

# Cafe multi-threading logic with BlockingQueue.


class Client(threading.Thread):
    def __init__(self, queue_soup, queue_cake, queue_coffee, mutex_soup, mutex_cake, mutex_coffee):
        super().__init__()
        self.queue_soup = queue_soup
        self.queue_cake = queue_cake
        self.queue_coffee = queue_coffee
        self.mutex_soup = mutex_soup
        self.mutex_cake = mutex_cake
        self.mutex_coffee = mutex_coffee

    def soup_queue(self):
        self.mutex_soup.acquire()
        while len(self.queue_soup) == 0:
            self.mutex_soup.wait()
        print("client takes a soup. Soup queue size is ", len(self.queue_soup))
        self.queue_soup.pop(0)
        self.mutex_soup.notify()
        self.mutex_soup.release()

    def cake_queue(self):
        self.mutex_cake.acquire()
        while len(self.queue_cake) == 0:
            self.mutex_cake.wait()
        print("client takes a cake. Cake queue size is ", len(self.queue_soup))
        self.queue_cake.pop(0)
        self.mutex_cake.notify()
        self.mutex_cake.release()

    def coffee_queue(self):
        self.mutex_coffee.acquire()
        while len(self.queue_coffee) == 0:
            self.mutex_coffee.wait()
        print("client takes a coffee. Coffee queue size is ", len(self.queue_soup))
        self.queue_coffee.pop(0)
        self.mutex_coffee.notify()
        self.mutex_coffee.release()

    def run(self):
        self.soup_queue()
        self.cake_queue()
        self.coffee_queue()


class SoupChief(threading.Thread):
    def __init__(self, queue_soup, mutex_soup):
        super().__init__()
        self.queue_soup = queue_soup
        self.mutex_soup = mutex_soup

    def soup_mutex(self):
        self.mutex_soup.acquire()
        while len(self.queue_soup) >= 10:
            self.mutex_soup.wait()
        print("SoupChief makes the soup. Coffee queue size is ", len(self.queue_soup))
        self.queue_soup.append(10)
        self.mutex_soup.notify()
        self.mutex_soup.release()

    def run(self):
        while True:
            self.soup_mutex()


class CakeChief(threading.Thread):
    def __init__(self, queue_cake, mutex_cake):
        super().__init__()
        self.queue_cake = queue_cake
        self.mutex_cake = mutex_cake

    def cake_mutex(self):
        self.mutex_cake.acquire()
        while len(self.queue_cake) >= 10:
            self.mutex_cake.wait()
        print("CakeChief makes the cake. Cake queue size is ", len(self.queue_cake))
        self.queue_cake.append(10)
        self.mutex_cake.notify()
        self.mutex_cake.release()

    def run(self):
        while True:
            self.cake_mutex()


class CoffeeChief(threading.Thread):
    def __init__(self, queue_coffee, mutex_coffee):
        super().__init__()
        self.queue_coffee = queue_coffee
        self.mutex_coffee = mutex_coffee

    def coffee_mutex(self):
        self.mutex_coffee.acquire()
        while len(self.queue_coffee) >= 10:
            self.mutex_coffee.wait()
        print("CoffeeChief makes the coffee. Coffee queue size is ", len(self.queue_coffee))
        self.queue_coffee.append(10)
        self.mutex_coffee.notify()
        self.mutex_coffee.release()

    def run(self):
        while True:
            self.coffee_mutex()


class Order():
    def __init__(self, order):
        self.order_number = order
        queue_cake, queue_coffee, queue_soup = queue_init()
        mutex_cake, mutex_coffee, mutex_soup = mutex_thread_init()
        cake_chief, coffee_chief, soup_chief = chief_init(mutex_coffee, queue_cake, queue_coffee, queue_soup)
        chief_threads_start(cake_chief, coffee_chief, soup_chief)
        Client(queue_soup, queue_cake, queue_coffee, mutex_soup, mutex_cake, mutex_coffee).start()


def queue_init():
    queue_soup = []
    queue_cake = []
    queue_coffee = []
    return queue_cake, queue_coffee, queue_soup


def mutex_thread_init():
    mutex_soup = threading.Condition()
    mutex_cake = threading.Condition()
    mutex_coffee = threading.Condition()
    return mutex_cake, mutex_coffee, mutex_soup


def chief_init(mutex_coffee, queue_cake, queue_coffee, queue_soup):
    soup_chief = SoupChief(queue_soup, mutex_coffee)
    cake_chief = CakeChief(queue_cake, mutex_coffee)
    coffee_chief = CoffeeChief(queue_coffee, mutex_coffee)
    return cake_chief, coffee_chief, soup_chief


def chief_threads_start(cake_chief, coffee_chief, soup_chief):
    soup_chief.start()
    cake_chief.start()
    coffee_chief.start()


def main():

    for orders in range(0, 30):
        Order(orders)
main()