import myinterval

def binarySearch(list_intervals, new_interval):
        if len(list_intervals) == 0:
            return []
        else:
            midpoint = len(list_intervals)//2
            current_interval = myinterval.list_to_interval([list_intervals[midpoint]])
            if current_interval.sth_common(new_interval):
                res = [midpoint,midpoint]
                i = midpoint+1
                j = midpoint-1
                while i<len(list_intervals):
                    aux_interval = myinterval.list_to_interval([list_intervals[i]])
                    if aux_interval.sth_common(new_interval):
                        res[1]+=1
                    else:
                        break
                    i+=1
                while j>=0:
                    aux_interval = myinterval.list_to_interval([list_intervals[j]])
                    if aux_interval.sth_common(new_interval):
                        res[0]-=1
                    else:
                        break
                    j-=1
                return res
            else:
                if list(new_interval)[0]._lower_value < list_intervals[midpoint][0]:
                    fromto = binarySearch(list_intervals[:midpoint],new_interval)

                else:
                    fromto = binarySearch(list_intervals[midpoint+1:],new_interval)
                    if(len(fromto)!=0):
                        fromto[0]+=midpoint+1
                        fromto[1]+=midpoint+1
                return fromto

class Reserva(object):
    def __init__(self, llista_temps,llista_ocupacio):
        self.temps = llista_temps
        self.ocupacions = llista_ocupacio


    def __add__(self, new_interval):
        A = self.intersection(new_interval)
        B = new_interval.intersection(self.opened_complement())
        C = self.intersection(new_interval.opened_complement())
        return (A.union(B)).union(C)


# pot_reservarse: ens diu si un element es pot reservar. Els seus inputs són l'objecte i un interval. Si l'objecte es pot reservar retorna True, en cas contrari, retorna una tupla amb l'interval en que es troba reservat i el seu estat 0/1.
    def pot_reservarse(self, interval):
        interval = myinterval.list_to_interval([interval])
        return binarySearch(self.temps,interval)