#!/usr/bin/env python
import numpy as np
from collections import defaultdict 

class Car(object):
    def __init__(self, path, data):
        self.__path = path
        self.__data = data

    def getCurrentSem(self):
        """
            name, intersection
        """
        if len(self.__path) == 1:
            return None
        else:
            currentStr, nextStr = self.__path[0:2]
            for street, inter, _ in self.__data[currentStr]:
                if street == nextStr:
                    return (currentStr, inter)

    def getCurrentStreet(self):
        return self.__path[0]

    def getNextStreet(self):
        return self.__path[1]

    def moveCar(self):
        self.__path = self.__path[1:]
    
    def canElimitate(self):
        if len(self.__path) == 0:
            return True
        return False

class Intersection(object):
    def __init__(self, data):
        self.__data = data
    
    def lastStreetGreen(self):
        for street, status in self.__data:
            if status == True:
                return street
        return None
    
    def makeGreen(self, name):
        for i in range(len(self.__data)):
            street, status = self.__data[i]
            if status == True:
                self.__data[i][1] = False
            if street == name:
                self.__data[i][1] = True

class Data(object):
    
    def __init__(self, fileName = 'data.in'):
        content = open(fileName, 'r').read()
        self.__parseData(content)


    def __parseData(self, content) -> object:
        """
            Parsarea pentru valorile de input. Ca sigur trebuie facute ceva siruri, etc.
        """
        content = content.split('\n')
        self.duration, self.__numberIntersection, self.__numberStreets, self.__numberCars, self.__bonusPoints = map(int, content[0].split(' '))
        content = content[1:]

        self.__mapIntEnter = defaultdict(lambda: [])
        self.__mapIntLeave = defaultdict(lambda: [])
        self.mapAdiacent = defaultdict(lambda: [])
        self.__streetTime = {}
        for street in content[:self.__numberStreets]:
            street = street.split(' ')
            intStart, intFinish, name, time = int(street[0]), int(street[1]), str(street[2]), int(street[3])
            self.__mapIntLeave[intStart].append((name, time, intStart))
            self.__mapIntEnter[intFinish].append((name, time, intFinish))
            self.__streetTime[name] = time
        
        # create intersection list
        self.interSectionList = []
        for i in range(len(self.__mapIntEnter)):
            intValue = list(map(lambda x: (x[0], False), self.__mapIntEnter[i]))
            self.interSectionList.append(Intersection(intValue))

        for k in self.__mapIntEnter.keys():
            for kName, _, intLeave in self.__mapIntEnter[k]:
                for vLeave in self.__mapIntLeave[intLeave]:
                    vName, _, _ = vLeave
                    # numele strazii, intersectia in care intra, status
                    self.mapAdiacent[kName].append((vName, intLeave, False))
        content = content[self.__numberStreets:]

        self.carList = []
        for car in content[:self.__numberCars]:
            print(list(map(str, car.split(' ')[1:])))
            car = Car(list(map(str, car.split(' ')[1:])), self.mapAdiacent)
            self.carList.append(car)

    def flushInFile(self, fileOutput = 'data.out') -> None:
        with open(fileOutput, 'w') as ofile:
            ofile.write(len(self.__schedules))
            for key, value in self.__schedules.items():
                ofile.write(key)
                ofile.write(len(value))
                for tup in value:
                     ofile.write(tup[0], tup[1])