import itertools

# Number of running programs
progs = 5

# Number of facilities per node
fac_num = (1, 1, 1, 1, 1)

# Number of nodes
nodes = len(fac_num)

# Tuple with omega coefficients (probability of entering node).
# Were calculated manually
w = (0.5, 0.125, 0.125, 0.125, 0.125)

# Servicing intensity
m1 = 100
m2 = m1*0.2
m3 = m1*0.2
m4 = m1*0.2
m5 = m1*0.2

# Tuple with servicing intensity coefficients
m = (m1, m2, m3, m4, m5)

# Compose all possible permutations with repetitions
# of 5 elements from 6 possible numbers (Cartesian product)
states = itertools.product(range(progs + 1), repeat=nodes)
# Filter out all permutations with total sum of tuple members
# not equal to 5 to get all possible states
states = set(filter(lambda pwr: sum(pwr) == progs, states))

# Calculate normalizing constant
g = 0
# Go through all states
for state in states:
    # Form product for each state
    product = 1
    # Each product has number of members equal to number
    # of nodes
    for node in range(nodes):
        product *= (w[node] / m[node]) ** state[node]
    # Add calculated product to constant
    g += product

# Assign probability to states
state_prob_map = {}
for state in states:
    # Start calculating product from neutral number
    product = 1
    # Multiply it by (w/m)^n for each node
    for node in range(nodes):
        product *= (w[node] / m[node]) ** state[node]
    # Calculate probability
    probability = product/g
    # Add everything to the map
    state_prob_map[state] = probability

# List for average number of requests in node
rq_total_node = []
# Calculate expected value using our state map
for node in range(nodes):
    sum = 0
    for state in state_prob_map:
        rq_num = state[node]
        prob = state_prob_map[state]
        sum += rq_num * prob
    rq_total_node.append(sum)

# List for average number of requests in queue in node
rq_queued_node = []
# Calculate expected value using our state map
for node in range(nodes):
    sum = 0
    for state in state_prob_map:
        rq_num = state[node]
        facilities = fac_num[node]
        if rq_num > facilities:
            prob = state_prob_map[state]
            sum += (rq_num - facilities) * prob
    rq_queued_node.append(sum)

# List for average number of requests in service in node
rq_serviced_node = []
for node in range(nodes):
    sum = 0
    for state in state_prob_map:
        rq_num = state[node]
        facilities = fac_num[node]
        if rq_num <= facilities:
            prob = state_prob_map[state]
            sum += rq_num * prob
        else:
            prob = state_prob_map[state]
            sum += facilities * prob
    rq_serviced_node.append(sum)

for node in range(nodes):
    print("Node {}, total: {}, queued: {}, serviced: {}, diff: {}".format(node + 1, round(rq_total_node[node], 5), round(rq_queued_node[node], 5), round(rq_serviced_node[node], 5), round(rq_total_node[node] - rq_queued_node[node] - rq_serviced_node[node], 10)))