import copy
import pickle

with open(r'*********************************', "rb") as f:
    total_nearest_cell_generate_trip_nested_list=pickle.load(f)
with open(r'**********************************', "rb") as f:
    OD_cell=pickle.load(f)


from collections import deque
from operator import itemgetter
def is_ordered_sublist(sublst, lst):
    sublst = deque(sublst)
    for x in lst:
        if not sublst:
            # return True early if the stack is empty
            return True

        if x == sublst[0]:
            sublst.popleft()

    return not sublst




import threading
import time
thread_time=time.time()
class thread_by_thread (threading.Thread):
    def __init__(self,n):
        threading.Thread.__init__(self)
        self.n = n-1
        self.period_time_i = total_nearest_cell_generate_trip_nested_list[self.n]
        self.total_nearest_cell_generate_trip_nested_list_new=[]
    def run(self):
        period_time = self.period_time_i[0][6]
        total_nearest_cell_generate_trip_nested_list_2=copy.deepcopy(total_nearest_cell_generate_trip_nested_list)
        del total_nearest_cell_generate_trip_nested_list_2[self.n]
        total_nearest_cell_generate_trip_nested_list_2_other_flatten=[subsublist for sublist in total_nearest_cell_generate_trip_nested_list_2 for subsublist in sublist ]
        for cell in  OD_cell:
            #OD_cell_deepcopy=copy.deepcopy(OD_cell)
            another_cells=[x for x in OD_cell if x !=cell]
            for another_cell in another_cells:
                ## generate_missing_trips_A
                O_trip=cell
                D_trip= another_cell
                OD_trip=[O_trip,D_trip]
                index_time=time.time()
                indices = [i for i, l in enumerate(self.period_time_i) if is_ordered_sublist(OD_trip, l)]
                indices_other = [i for i, l in enumerate(total_nearest_cell_generate_trip_nested_list_2_other_flatten) if is_ordered_sublist(OD_trip, l)]
                OD_trip_revrese=[D_trip,O_trip]
                indices_reverse = [i for i, l in enumerate(self.period_time_i) if is_ordered_sublist(OD_trip_revrese, l)]
                indices_other_reverse = [i for i, l in enumerate(total_nearest_cell_generate_trip_nested_list_2_other_flatten) if is_ordered_sublist(OD_trip_revrese, l)]
                if len(indices) > 0:
                    trip_or_inf=OD_trip
                    self.total_nearest_cell_generate_trip_nested_list_new +=[self.period_time_i[indices[0]]]
                elif len(indices_other) > 0:
                    trip_or_inf=OD_trip
                    OD_trip_from_another_period=[]
                    period_time_x_list=[]
                    for i in indices_other :
                        trip_index=[]
                        trip_x= copy.deepcopy(total_nearest_cell_generate_trip_nested_list_2_other_flatten[i])
                        period_time_x=trip_x[6]
                        trip_index.append(period_time_x)
                        trip_index.append(i)
                        period_time_x_list.append(trip_index)
                        OD_trip_from_another_period+=[trip_x]
                    period_time_x_list.sort(key=itemgetter(0))
                    closest_trip_index=min(period_time_x_list, key=lambda x:abs(x[0]-period_time))
                    closest_trip_period_time_trip=copy.deepcopy(total_nearest_cell_generate_trip_nested_list_2_other_flatten[closest_trip_index[1]])
                    closest_trip_period_time_trip[2]=0
                    closest_trip_period_time_trip[6]=period_time
                    closest_trip_period_time_trip[7]=period_time
                    closest_trip_period_time_trip[8]='existed_another_period_'+str(closest_trip_index[0])
                    closest_trip_period_time_trip[9]= 3
                    self.total_nearest_cell_generate_trip_nested_list_new +=[closest_trip_period_time_trip]
                elif len(indices_reverse) > 0:
                    trip_r_inf=OD_trip_revrese
                    reverse_trip= self.period_time_i[indices_reverse[0]]
                    trip_x= copy.deepcopy(reverse_trip)
                    trip_x[0]=O_trip
                    trip_x[1]=D_trip
                    trip_x[2]=0
                    trip_x[8]= 'existed_reverse'
                    trip_x[9]= 4
                    self.total_nearest_cell_generate_trip_nested_list_new +=[trip_x]
                elif len(indices_other_reverse) > 0:
                    trip_r_inf=OD_trip_revrese
                    OD_trip_from_another_period=[]
                    period_time_x_list=[]
                    for i in indices_other_reverse :
                        trip_index=[]
                        trip_x= copy.deepcopy(total_nearest_cell_generate_trip_nested_list_2_other_flatten[i])
                        period_time_x=trip_x[6]
                        trip_index.append(period_time_x)
                        trip_index.append(i)
                        period_time_x_list.append(trip_index)
                        OD_trip_from_another_period+=[trip_x]
                    period_time_x_list.sort(key=itemgetter(0))
                    closest_trip_index=min(period_time_x_list, key=lambda x:abs(x[0]-period_time))
                    closest_trip_period_time_trip=copy.deepcopy(total_nearest_cell_generate_trip_nested_list_2_other_flatten[closest_trip_index[1]])
                    closest_trip_period_time_trip[0]=O_trip
                    closest_trip_period_time_trip[1]=D_trip
                    closest_trip_period_time_trip[2]=0
                    closest_trip_period_time_trip[6]=period_time
                    closest_trip_period_time_trip[7]=period_time
                    closest_trip_period_time_trip[8]='existed_reverse_another_period_'+str(closest_trip_index[0])
                    closest_trip_period_time_trip[9]= 5
                    self.total_nearest_cell_generate_trip_nested_list_new +=[closest_trip_period_time_trip]
        print(time.time()-thread_time)

#
thread1 = thread_by_thread(1)
thread2 = thread_by_thread(2)
thread3 = thread_by_thread(3)
thread4 = thread_by_thread(4)
thread5 = thread_by_thread(5)
thread6 = thread_by_thread(6)
thread7 = thread_by_thread(7)
thread8 = thread_by_thread(8)
thread9 = thread_by_thread(9)
thread10 = thread_by_thread(10)
thread11 = thread_by_thread(11)
thread12 = thread_by_thread(12)
thread13 = thread_by_thread(13)
thread14 = thread_by_thread(14)
thread15 = thread_by_thread(15)
thread16 = thread_by_thread(16)
thread17 = thread_by_thread(17)
thread18 = thread_by_thread(18)
thread19 = thread_by_thread(19)
thread20 = thread_by_thread(20)
thread21 = thread_by_thread(21)
thread22 = thread_by_thread(22)
thread23 = thread_by_thread(23)
thread24 = thread_by_thread(24)

thread1.start()
thread2.start()
thread3.start()
thread4.start()
thread5.start()
thread6.start()
thread7.start()
thread8.start()
thread9.start()
thread10.start()
thread11.start()
thread12.start()
thread13.start()
thread14.start()
thread15.start()
thread16.start()
thread17.start()
thread18.start()
thread19.start()
thread20.start()
thread21.start()
thread22.start()
thread23.start()
thread24.start()

thread1 = thread_by_thread(1)
thread2 = thread_by_thread(2)
thread3 = thread_by_thread(3)
...

threads = [thread_by_thread(i+1) for i in range(24)]
for thread in threads:
    thread.start()

trip_r_inf=OD_trip_revrese

closest_trip_period_time_trip=copy.deepcopy(total_nearest_cell_generate_trip_nested_list_2_other_flatten[closest_trip_index[1]])