import random

class RealTimeProcess:
    def __init__(self, deadline, polozenie):
        self.deadline = deadline
        self.polozenie = polozenie
    def __str__(self):
        return str(self.deadline)

class FCFS:
        pamiec = []
        suma = 0
        iterator = 0
        next = 0

        def __init__(self, Lista):

            self.pamiec = Lista[:]
            self.next = self.pamiec[0]


        def Symulacja(self, start):

                ilosc = random.randint(5,20)
               # ilosc = 5

                real_time = []

                l = str(start)
                prev = start

                isEmpty = lambda List: len(List) is 0
                print 'Pozycja startowa: ' + str(start)
                while True:
                        try:
                            if(ilosc > 0):
                               if((self.iterator % random.randint(1,1)) == 0): ### if((self.iterator % random.randint(2,5)) == 0):
                                   real_time.append(RealTimeProcess(random.randint(1,4), random.randint(1,179)))
                                   #real_time.sort(key=lambda app: app.deadline)
                                   ilosc -= 1
                            if(not isEmpty(real_time)):
                               self.pamiec.insert(self.iterator, real_time[0].polozenie)
                               #print str(real_time[0].polozenie) + " " + str( real_time[0].deadline)
                               l += " --real time-"
                               prev = self.next
                               self.next = self.pamiec[self.iterator]
                               del real_time[0]

                            self.suma += abs(self.next - prev)
                            l += "---> " + str(self.pamiec[self.iterator])
                            prev = self.next
                            self.next = self.pamiec[self.iterator]
                            self.iterator += 1




                        except IndexError:
                                print l
                                print self.suma
                                break



class SSTF:

    Lista_blokow = []
    Sciezka = 0







    def NajkrotszaSciezka(self, Lista, elem):

        najkrotsza = 361
        elem_min = Lista[0]
        odleglosc = 0

        for e in Lista:
            wynik = abs(elem-e)
            if(wynik < najkrotsza):
                najkrotsza = wynik
                elem_min = e
        self.Sciezka = najkrotsza
        return elem_min


    def __init__(self, Lista):
        self.Lista_blokow = Lista

    def Symulacja(self, start):
        wynik = 0
        l = str(start)
        prev = start
        ilosc = random.randint(5,20)
        isEmpty = lambda List: len(List) is 0

        real_time = []

        while True:
            try:
                if(ilosc > 0):
                   if((1 % random.randint(1,1)) == 0): ### if((self.iterator % random.randint(2,5)) == 0):
                           real_time.append(RealTimeProcess(random.randint(1,4), random.randint(1,179)))
                           #real_time.sort(key=lambda app: app.deadline)
                           ilosc -= 1
                   if(not isEmpty(real_time)):
                           self.Lista_blokow.insert(0, real_time[0].polozenie)
                           #print str(real_time[0].polozenie) + " " + str( real_time[0].deadline)
                           l += " --real time-"
                           prev = self.NajkrotszaSciezka(self.Lista_blokow, start)
                           del real_time[0]
                wynik += abs(start - self.NajkrotszaSciezka(self.Lista_blokow, start))
                prev = self.NajkrotszaSciezka(self.Lista_blokow, start)
                l += "--" + str(self.Sciezka) + "--> " + str(self.NajkrotszaSciezka(self.Lista_blokow, start))
                start = self.NajkrotszaSciezka(self.Lista_blokow, start)
                del self.Lista_blokow[self.Lista_blokow.index(start)]

            except IndexError:
                print l
                print "Wynik: " + str(wynik)
                break



class SCAN:

    def CzyRealTime(self):
        if random.choice(True, False):
            return random.randint(1,180)

    def Symulacja(self, start, Lista):

        Bloki_malejace = [bl for bl in Lista if bl < start]
        Bloki_rosnace = [bl for bl in Lista if bl > start]





        prev1 = 0
        prev2 = 0

        wynik = 0

        odrzucone = []

        l = str(start)
        l2 = str(0)

        Posortuj = lambda Lista : Lista.sort()
        ZwrocElem = lambda (Lista, x) : Lista[Lista.indeks(x)]

        poczatek = 0

        for bl in reversed(Bloki_malejace[poczatek:]):
            wynik += abs(prev1 - bl)
            if self.CzyRealTime:
                if self.CzyRealTime < prev1:
                    Bloki_malejace.append(self.CzyRealTime)
                    Posortuj(Bloki_malejace)
                else:
                    odrzucone.append(CzyRealTime)
            l += "---> " + str(bl)
            prev1 = bl
            del Bloki_malejace[Zwroc
        for bl in Bloki_rosnace:
            wynik += abs(prev2 - bl)
            if self.CzyRealTime:
                if self.CzyRealTime < prev2:
                    Bloki_rosnace.append(self.CzyRealTime)
                    Posortuj(Bloki_malejace)
                else:
                    odrzucone.append(CzyRealTime)
            l2 += "---> " + str(bl)
            prev2 = bl
        print l + "---> " + l2
        print wynik

class C_SCAN:
     def Symulacja(self, start, Lista):
        Bloki = Lista
        Bloki.sort()
        Bloki.reverse()
        l = str(start)
        l2 = ""
        prev = start
        prev1 = Bloki[0]
        wynik = 0

        for bl in Bloki:
            if(bl < start):
                wynik += abs(prev - bl)
                l += "---> " + str(bl)
                prev = bl
            if(bl > start):
                wynik += abs(prev1 - bl)
                l2 += "---> " + str(bl)
                prev1 = bl
        print l + l2
        print wynik








Lista = []
start = 54
for i in range(10):
    liczba = random.randint(1,179)
    if liczba not in Lista and liczba != start:
        Lista.append(liczba)
    else:
        i -= 1

print "Lista: ", Lista

#
x = SSTF(Lista)
x.Symulacja(start)

#x = FCFS(Lista)
#x.Symulacja(25)

#y = SCAN()
#y.Symulacja(start, Lista)

#y = C_SCAN()
#y.Symulacja(start, Lista)