import random
import math
import numpy as np


hist22 = "0,1".split(',')
print([int(i) for i in hist22])

#Timer for second game:
#time spent for game 1 includes time spent for adding numbers tasks:
#after game 1, data I have is: e.g. 2 interruptions happened
gap_history = [12, 34, 28] #this is time taken for interruption tasks
interruption_time1 = [585, 580, 565, 400, 300] #this is the time when interruption tasks interrupt
time_spent = 130 #this is time spent including interruption tasks for game 1
#calculate time spent on Nonogram, timer for game 2 and interruption time for game 2
#should be 56s, 544s, and [400, 300]


def time_spent_nono():
    length = len(gap_history)
    interruption_time2 = interruption_time1[length:6]
    time_spent1 = time_spent - np.sum(gap_history[0:])
    timer_game2 = 600 - time_spent1
    return time_spent1, timer_game2, interruption_time2

time_spent_nono = time_spent_nono()

print(time_spent_nono[0])
print(time_spent_nono[1])
print(time_spent_nono[2])















#loop through interruption time:
#if time spent for first game < (600 - interruption time[i]), then timer for second game = 600 - (np.sum(gap history[0:i-1]),
#and interruption time for second game = interruption_time[i:5]


inter_game1 = [595, 590, 585, 580, 565]
gap_history1 = [5, 10, 15, 20, 25]

time_spent1 = 18
timer_game1 = 600

def timer():
    total_gap = []
    start = True
    for i in range(0, 5):
        if start == True:
            print("=========")
            print("i=: \t\t\t\t\t", i)
            print("time_spent: \t\t\t\t", time_spent1)
            print("600 - inter[i]: \t\t\t", 600 - inter_game1[i])
            print("time_spent < 600 - inter[i]: \t\t", time_spent < 600 - inter_game1[i])
            print(start)
            print("=========")
            if time_spent < 600 - inter_game1[i]:
                total_gap = np.sum(gap_history1[0:i])
                start = False
    return total_gap

timer = timer()
print(timer)



def timer_game2():
    total_gap = []
    start = True
    for i in range(0, 5):
        if start == True:
            if time_spent < 600 - inter_game1[i]:
                total_gap = np.sum(gap_history[0:i])
                start = False
    return total_gap


def inter_game2():
    new_inter = []
    for i in range(0, 5):
        if time_spent < 600 - inter_game1[i]:
            new_inter = inter_game1[i:]
    return new_inter


total_gap1 = timer_game2()
timer_game2 = 600 - timer_game2() - time_spent
inter_game2 = inter_game2()

print(total_gap1)
print(timer_game2)
print(inter_game2)
#should print 523


def interruption_time():
    inter = np.sort(np.random.randint(10, 590, size=8))
    this_number = inter[0:7]
    next_number = inter[1:8]
    difference = next_number-this_number
    while np.all(difference > 10) == False:
        inter = np.sort(np.random.randint(10, 590, size=8))
        this_number = inter[0:7]
        next_number = inter[1:8]
        difference = next_number - this_number

    inter = -np.sort(-inter)
    inter = np.ndarray.tolist(inter)
    #inter_string = "["
    #for i in range(0, 8):
        #inter_string = inter_string + str(inter[i]) + ","
    #inter_string = inter_string[:-1] + "]"

    #inter = np.array2string(inter, separator=',')
    return inter


interruption_time = interruption_time()



print(interruption_time)
print(type(interruption_time))

a=[595, 590, 585, 580, 575]
print(type(a))



difficulty = 3
specification = 5


def nonogram():
    candidate = np.random.randint(2, size=(specification, specification))
    candidate_t = candidate.transpose()

    sums = []
    for i in range(0, specification):
        sums = sums + [np.sum(candidate[i][j:j + difficulty + 1]) for j in range(0, difficulty)] + [np.sum(candidate_t[i][j:j + difficulty + 1]) for j in range(0, difficulty)]

    if max(sums) == difficulty + 1 or min(sums) == 0:
        candidate = nonogram()

    return candidate


nonogram = nonogram()

print(nonogram)

#Method 1:d
def ones_counter(row):
    for i in range(0, specification-1):
        if row[i] > 0 and row[i + 1] > 0:
            row[i + 1] = row[i + 1] + row[i]
            row[i] = 0
    relevant_numbers = row[np.where(row > 0)]
    return ' '.join(str(j) for j in relevant_numbers)


print("Now rows:")
output_row = [ones_counter(nonogram.copy()[h]) for h in range(0, specification)]
row_string = "["

for i in range(0, len(output_row)):
    row_string = row_string + "\"" + output_row[i] + "\","

row_string = row_string[:-1] + "]"
print(row_string)


print("Now columns:")
nonogram_t = nonogram.copy().transpose()
output_col = [ones_counter(nonogram_t[h]) for h in range(0, specification)]

col_string = "["

for i in range(0, len(output_col)):
    col_string = col_string + "\"" + output_col[i] + "\","

col_string = col_string[:-1] + "]"

print(col_string)




#Method 2:
print("Now rows:")

row_list = []

for j in range(0, specification):
    my_row_j = nonogram.copy()[j]

    for i in range(0, 9):
        if my_row_j[i] > 0 and my_row_j[i + 1] > 0:
            my_row_j[i + 1] = my_row_j[i + 1] + my_row_j[i]
            my_row_j[i] = 0

    new_list_j = np.array([my_row_j[np.where(my_row_j > 0)]])
    print(new_list_j[0])

    col_list = row_list + [list(new_list_j)]




print("Now columns:")
col_list = []
nonogram_t = nonogram.transpose()

for j in range(0, specification):
    my_col_j = nonogram_t.copy()[j]

    for i in range(0, 9):
        if my_col_j[i] > 0 and my_col_j[i + 1] > 0:
            my_col_j[i + 1] = my_col_j[i + 1] + my_col_j[i]
            my_col_j[i] = 0

    new_list_j = np.array([my_col_j[np.where(my_col_j > 0)]])
    print(new_list_j[0])

    col_list = col_list + [list(new_list_j)]