import os
import random

import pygame

from enumy_i_slowniki import *

#
okno = pygame.display.set_mode((SZEROKOSC_OKNA, WYSOKOSC_OKNA))
#
droga_A = [[False, w, 7] for w in range(LICZBA_POL_W_PIONIE)]
swiatlo_A = Swiatlo.CZERWONE
pole_postojowe_A = (9, 7)
sygnalizator_A = ((10, 9), (11, 9), (12, 9))
indeks_petli_A = None
for i in range(len(droga_A)):
    x = droga_A[i]
    if x[1] == pole_postojowe_A[0] and x[2] == pole_postojowe_A[1]:
        indeks_petli_A = i
#
droga_B = [[False, w, 7] for w in range(0, 7)] + [[False, 7, k] for k in range(7, LICZBA_POL_W_POZIOMIE)]
swiatlo_B = Swiatlo.ZIELONE
pole_postojowe_B = (7, 8)
sygnalizator_B = ((3, 10), (4, 10), (5, 10))
indeks_petli_B = None
for i in range(len(droga_B)):
    x = droga_B[i]
    if x[1] == pole_postojowe_B[0] and x[2] == pole_postojowe_B[1]:
        indeks_petli_B = i
#
krata = [[_ for _ in range(LICZBA_POL_W_POZIOMIE)] for _ in range(LICZBA_POL_W_PIONIE)]
#
for w in range(LICZBA_POL_W_PIONIE):
    for k in range(LICZBA_POL_W_POZIOMIE):
        krata[w][k] = ZawartoscPola.SCIANA2
#
for w in range(LICZBA_POL_W_PIONIE):
    krata[w][5] = ZawartoscPola.SCIANA
    krata[w][6] = ZawartoscPola.PUSTE
    krata[w][7] = ZawartoscPola.PUSTE
    krata[w][8] = ZawartoscPola.SCIANA
#
krata[7][8] = ZawartoscPola.PUSTE
krata[8][8] = ZawartoscPola.PUSTE
#
for w in [7, 8]:
    for k in range(8, LICZBA_POL_W_POZIOMIE):
        krata[w][k] = ZawartoscPola.PUSTE
#
for k in range(8, LICZBA_POL_W_POZIOMIE):
    krata[6][k] = ZawartoscPola.SCIANA
for k in range(8, LICZBA_POL_W_POZIOMIE):
    krata[9][k] = ZawartoscPola.SCIANA


def wyswietl_okno():
    pygame.time.Clock().tick(FPS)
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            # print("Użytkownik spróbował zamknąć okno.")
            pygame.quit()
    narysuj_krate()
    narysuj_pojazdy()
    pygame.display.update()


def narysuj_krate():
    okno.fill(SZARY)
    for wiersz in range(LICZBA_POL_W_PIONIE):
        for kolumna in range(LICZBA_POL_W_POZIOMIE):
            start = (ODSTEP_MIEDZY_POLAMI + BOK_POLA) * kolumna + ODSTEP_MIEDZY_POLAMI
            gora = (ODSTEP_MIEDZY_POLAMI + BOK_POLA) * wiersz + ODSTEP_MIEDZY_POLAMI
            kolor_pola = ZawartoscPolaNaKolorPola[krata[wiersz][kolumna]]
            pygame.draw.rect(okno, kolor_pola, [start, gora, BOK_POLA, BOK_POLA])


def narysuj_pojazdy():
    ikona = pygame.transform.scale(pygame.image.load(os.path.join('Ikony', 'auto.png')), (BOK_AGENTA, BOK_AGENTA))
    for x in droga_A:
        if x[0]:
            okno.blit(ikona, ((BOK_POLA + ODSTEP_MIEDZY_POLAMI) * x[2] + ODSTEP_MIEDZY_POLAMI,
                              (BOK_POLA + ODSTEP_MIEDZY_POLAMI) * x[1] + ODSTEP_MIEDZY_POLAMI))
    ikona = pygame.transform.scale(pygame.image.load(os.path.join('Ikony', 'auto2.png')), (BOK_AGENTA, BOK_AGENTA))
    for x in droga_B:
        if x[0]:
            okno.blit(ikona, ((BOK_POLA + ODSTEP_MIEDZY_POLAMI) * x[2] + ODSTEP_MIEDZY_POLAMI,
                              (BOK_POLA + ODSTEP_MIEDZY_POLAMI) * x[1] + ODSTEP_MIEDZY_POLAMI))


def rusz_pojazdy_na_drodze(droga, pole_postojowe, swiatlo):
    nowa_droga = [[False, x[1], x[2]] for x in droga]
    for i in range(len(droga) - 1, 0, -1):
        x = droga[i]
        if x[0]:
            if x[1] == pole_postojowe[0] and x[2] == pole_postojowe[1] and swiatlo != Swiatlo.ZIELONE:
                nowa_droga[i][0] = True
            else:
                if not droga[i - 1][0]:
                    nowa_droga[i][0] = False
                    nowa_droga[i - 1][0] = True
                else:
                    nowa_droga[i][0] = True
    return nowa_droga


def ustaw_czerwone(sygnalizator):
    krata[sygnalizator[0][0]][sygnalizator[0][1]] = ZawartoscPola.SYGNALIZATOR_CZERWONY
    krata[sygnalizator[1][0]][sygnalizator[1][1]] = ZawartoscPola.SCIANA2
    krata[sygnalizator[2][0]][sygnalizator[2][1]] = ZawartoscPola.SCIANA2


def ustaw_czerwone_z_zoltym(sygnalizator):
    krata[sygnalizator[0][0]][sygnalizator[0][1]] = ZawartoscPola.SYGNALIZATOR_CZERWONY
    krata[sygnalizator[1][0]][sygnalizator[1][1]] = ZawartoscPola.SYGNALIZATOR_ZOLTY
    krata[sygnalizator[2][0]][sygnalizator[2][1]] = ZawartoscPola.SCIANA2


def ustaw_zolte(sygnalizator):
    krata[sygnalizator[0][0]][sygnalizator[0][1]] = ZawartoscPola.SCIANA2
    krata[sygnalizator[1][0]][sygnalizator[1][1]] = ZawartoscPola.SYGNALIZATOR_ZOLTY
    krata[sygnalizator[2][0]][sygnalizator[2][1]] = ZawartoscPola.SCIANA2


def ustaw_zielone(sygnalizator):
    krata[sygnalizator[0][0]][sygnalizator[0][1]] = ZawartoscPola.SCIANA2
    krata[sygnalizator[1][0]][sygnalizator[1][1]] = ZawartoscPola.SCIANA2
    krata[sygnalizator[2][0]][sygnalizator[2][1]] = ZawartoscPola.SYGNALIZATOR_ZIELONY


def Czerwone_Czerwone_do_Zielone_Czerwone():
    return swiatlo_A == Swiatlo.CZERWONE and swiatlo_B == Swiatlo.CZERWONE and poprzednio == "B"


def Czerwone_Czerwone_do_Czerwone_Zielone():
    return swiatlo_A == Swiatlo.CZERWONE and swiatlo_B == Swiatlo.CZERWONE and poprzednio == "A"


def CzerwoneZZoltym_Czerwone():
    return swiatlo_A == Swiatlo.CZERWONE_Z_ZOLTYM and swiatlo_B == Swiatlo.CZERWONE


def Zielone_Czerwone_1():
    return swiatlo_A == Swiatlo.ZIELONE and swiatlo_B == Swiatlo.CZERWONE and poprzednio == "B"


def Zielone_Czerwone_2():
    return swiatlo_A == Swiatlo.ZIELONE and swiatlo_B == Swiatlo.CZERWONE and poprzednio == "A"


def Zolte_Czerwone():
    return swiatlo_A == Swiatlo.ZOLTE and swiatlo_B == Swiatlo.CZERWONE


def Czerwone_CzerwoneZZoltym():
    return swiatlo_A == Swiatlo.CZERWONE and swiatlo_B == Swiatlo.CZERWONE_Z_ZOLTYM


def Czerwone_Zielone():
    return swiatlo_A == Swiatlo.CZERWONE and swiatlo_B == Swiatlo.ZIELONE


def Czerwone_Zolte():
    return swiatlo_A == Swiatlo.CZERWONE and swiatlo_B == Swiatlo.ZOLTE


def O_O():
    return (not droga_A[indeks_petli_A][0]) and (not droga_B[indeks_petli_B][0])


def A_O():
    return (droga_A[indeks_petli_A][0]) and (not droga_B[indeks_petli_B][0])


def O_B():
    return (not droga_A[indeks_petli_A][0]) and (droga_B[indeks_petli_B][0])


def A_B():
    return (droga_A[indeks_petli_A][0]) and (droga_B[indeks_petli_B][0])


def ustaw_Czerwone_Czerwone_do_Czerwone_Zielone():
    global swiatlo_A
    swiatlo_A = Swiatlo.CZERWONE
    ustaw_czerwone(sygnalizator_A)
    global swiatlo_B
    swiatlo_B = Swiatlo.CZERWONE
    ustaw_czerwone(sygnalizator_B)
    global poprzednio
    poprzednio = "A"


def ustaw_Czerwone_Czerwone_do_Zielone_Czerwone():
    global swiatlo_A
    swiatlo_A = Swiatlo.CZERWONE
    ustaw_czerwone(sygnalizator_A)
    global swiatlo_B
    swiatlo_B = Swiatlo.CZERWONE
    ustaw_czerwone(sygnalizator_B)
    global poprzednio
    poprzednio = "B"


def ustaw_CzerwoneZZoltym_Czerwone():
    global swiatlo_A
    swiatlo_A = Swiatlo.CZERWONE_Z_ZOLTYM
    ustaw_czerwone_z_zoltym(sygnalizator_A)
    global swiatlo_B
    swiatlo_B = Swiatlo.CZERWONE
    ustaw_czerwone(sygnalizator_B)


def ustaw_Zielone_Czerwone_1():
    global swiatlo_A
    swiatlo_A = Swiatlo.ZIELONE
    ustaw_zielone(sygnalizator_A)
    global swiatlo_B
    swiatlo_B = Swiatlo.CZERWONE
    ustaw_czerwone(sygnalizator_B)
    global poprzednio
    poprzednio = "B"


def ustaw_Zielone_Czerwone_2():
    global swiatlo_A
    swiatlo_A = Swiatlo.ZIELONE
    ustaw_zielone(sygnalizator_A)
    global swiatlo_B
    swiatlo_B = Swiatlo.CZERWONE
    ustaw_czerwone(sygnalizator_B)
    global poprzednio
    poprzednio = "A"


def ustaw_Zolte_Czerwone():
    global swiatlo_A
    swiatlo_A = Swiatlo.ZOLTE
    ustaw_zolte(sygnalizator_A)
    global swiatlo_B
    swiatlo_B = Swiatlo.CZERWONE
    ustaw_czerwone(sygnalizator_B)


def ustaw_Czerwone_CzerwoneZZoltym():
    global swiatlo_A
    swiatlo_A = Swiatlo.CZERWONE
    ustaw_czerwone(sygnalizator_A)
    global swiatlo_B
    swiatlo_B = Swiatlo.CZERWONE_Z_ZOLTYM
    ustaw_czerwone_z_zoltym(sygnalizator_B)


def ustaw_Czerwone_Zielone():
    global swiatlo_A
    swiatlo_A = Swiatlo.CZERWONE
    ustaw_czerwone(sygnalizator_A)
    global swiatlo_B
    swiatlo_B = Swiatlo.ZIELONE
    ustaw_zielone(sygnalizator_B)


def ustaw_Czerwone_Zolte():
    global swiatlo_A
    swiatlo_A = Swiatlo.CZERWONE
    ustaw_czerwone(sygnalizator_A)
    global swiatlo_B
    swiatlo_B = Swiatlo.ZOLTE
    ustaw_zolte(sygnalizator_B)


droga_A[14][0] = True
droga_A[12][0] = True
droga_A[10][0] = True
droga_A[9][0] = True
droga_B[len(droga_B) - 1][0] = True
droga_B[len(droga_B) - 2][0] = True
droga_B[len(droga_B) - 6][0] = True
droga_B[5][0] = True

czas_ostatniej_zmiany_swiatel = pygame.time.get_ticks()
ustaw_Czerwone_Czerwone_do_Zielone_Czerwone()
poprzednio = "B"

while True:
    # print(droga_A[indeks_petli_A][0],droga_B[indeks_petli_B][0])
    if O_O():
        print("O - O")
    elif A_O():
        print("A - O")
    elif A_B():
        print("A - B")
    elif O_B():
        print("O - B")
    czas_od_ostatniej_zmiany_swiatel = pygame.time.get_ticks() - czas_ostatniej_zmiany_swiatel
    if Czerwone_Czerwone_do_Zielone_Czerwone():
        print("Czerwone - Czerwone do Zielone - Czerwone")
        if czas_od_ostatniej_zmiany_swiatel >= CZAS_ZMIANY_NA_SYGNALIZATORZE:
            czas_ostatniej_zmiany_swiatel = pygame.time.get_ticks()
            if O_O() or A_O() or A_B():
                ustaw_CzerwoneZZoltym_Czerwone()
            elif O_B():
                ustaw_Czerwone_CzerwoneZZoltym()
    elif CzerwoneZZoltym_Czerwone():
        print("Czerwone z Zoltym - Czerwone")
        if czas_od_ostatniej_zmiany_swiatel >= CZAS_ZMIANY_NA_SYGNALIZATORZE:
            ustaw_Zielone_Czerwone_1()
    elif Zielone_Czerwone_1():
        print("Zielone - Czerwone 1")
        if czas_od_ostatniej_zmiany_swiatel >= CZAS_CYKLU:
            czas_ostatniej_zmiany_swiatel = pygame.time.get_ticks()
            if O_O() or A_O() or A_B():
                ustaw_Zielone_Czerwone_2()
            elif O_B():
                ustaw_Zolte_Czerwone()
    elif Zielone_Czerwone_2():
        print("Zielone - Czerwone 2")
        if czas_od_ostatniej_zmiany_swiatel >= CZAS_CYKLU:
            czas_ostatniej_zmiany_swiatel = pygame.time.get_ticks()
            if O_O() or A_O():
                pass
            elif O_B() or A_B():
                ustaw_Zolte_Czerwone()
    elif Zolte_Czerwone():
        print("Zolte - Czerwone")
        if czas_od_ostatniej_zmiany_swiatel >= CZAS_ZMIANY_NA_SYGNALIZATORZE:
            czas_ostatniej_zmiany_swiatel = pygame.time.get_ticks()
            ustaw_Czerwone_Czerwone_do_Czerwone_Zielone()
    elif Czerwone_CzerwoneZZoltym():
        print("Czerwone  - Czerwone z Zoltym")
        if czas_od_ostatniej_zmiany_swiatel >= CZAS_ZMIANY_NA_SYGNALIZATORZE:
            ustaw_Czerwone_Zielone()
    elif Czerwone_Zielone():
        print("Czerwone - Zielone")
        if czas_od_ostatniej_zmiany_swiatel >= CZAS_CYKLU:
            czas_ostatniej_zmiany_swiatel = pygame.time.get_ticks()
            if O_B():
                pass
            elif O_O() or A_O() or A_B():
                ustaw_Czerwone_Zolte()
    elif Czerwone_Zolte():
        print("Czerwone - Zolte")
        if czas_od_ostatniej_zmiany_swiatel >= CZAS_ZMIANY_NA_SYGNALIZATORZE:
            czas_ostatniej_zmiany_swiatel = pygame.time.get_ticks()
            ustaw_Czerwone_Czerwone_do_Zielone_Czerwone()
    elif Czerwone_Czerwone_do_Czerwone_Zielone():
        print("Czerwone - Czerwone do Czerwone - Zielone")
        if czas_od_ostatniej_zmiany_swiatel >= CZAS_ZMIANY_NA_SYGNALIZATORZE:
            czas_ostatniej_zmiany_swiatel = pygame.time.get_ticks()
            if A_O():
                ustaw_CzerwoneZZoltym_Czerwone()
            elif O_O() or O_B() or A_B():
                ustaw_Czerwone_CzerwoneZZoltym()
    #
    wyswietl_okno()
    droga_A = rusz_pojazdy_na_drodze(droga_A, pole_postojowe_A, swiatlo_A)
    droga_B = rusz_pojazdy_na_drodze(droga_B, pole_postojowe_B, swiatlo_B)
    #
    los = random.random()
    liczba_samochodow = len([x for x in droga_A if x[0]])
    maks_samochodow = 7
    szansa = (maks_samochodow - liczba_samochodow) / maks_samochodow -0.7
    if los < szansa:
        droga_A[len(droga_A) - 1][0] = True
    #
    liczba_samochodow = len([x for x in droga_B if x[0]])
    maks_samochodow = 6
    szansa = (maks_samochodow - liczba_samochodow) / maks_samochodow - 0.4
    if los < szansa:
        droga_B[len(droga_B) - 1][0] = True