import os,sys
from Figura import *
korisnik = True

pomocniRecnik = {}
pomocniRecnik["a"] = 1
pomocniRecnik["b"] = 2
pomocniRecnik["c"] = 3
pomocniRecnik["d"] = 4
pomocniRecnik["e"] = 5
pomocniRecnik["f"] = 6
pomocniRecnik["g"] = 7
pomocniRecnik["h"] = 8

recnikZaJelo = {}           #Sadrzi polja figura koja su ostvarila uslov da pojedu
recnikMogucihPoteza = {}    #Sadrzi polja svih dostupnih poteza

def dodavanjeFigura():
    global tabla
    tabla = {}
    tabla["a"] = {}
    tabla["b"] = {}
    tabla["c"] = {}
    tabla["d"] = {}
    tabla["e"] = {}
    tabla["f"] = {}
    tabla["g"] = {}
    tabla["h"] = {}
    for i in range(8):
        tabla["a"][i + 1] = None
        tabla["b"][i + 1] = None
        tabla["c"][i + 1] = None
        tabla["d"][i + 1] = None
        tabla["e"][i + 1] = None
        tabla["f"][i + 1] = None
        tabla["g"][i + 1] = None
        tabla["h"][i + 1] = None
    for i in range(8):
        if i % 2 != 0:
            tabla["a"][i + 1] = Figura("a",i+1,"c",False)
            tabla["c"][i + 1] = Figura("c",i+1,"c",False)
            tabla["g"][i + 1] = Figura("g",i+1,"b",False)
        else:
            tabla["b"][i + 1] = Figura("b",i+1,"c",False)
            tabla["f"][i + 1] = Figura("f",i+1,"b",False)
            tabla["h"][i + 1] = Figura("h",i+1,"b",False)
    tabla["e"][2] = Figura("e",2,"c",False)
    tabla["e"][6] = Figura("e",6,"c",False)
    tabla["d"][1] = Figura("d",1,"c",False)
    iscrtavanjeTable()

def iscrtavanjeTable():
    global tabla
    flag = 0
    print("  1   2   3   4   5   6   7   8")
    print("|-------------------------------|")
    #for red in tabla
    for k,v in tabla.items():
        #for kolona in red
        for k2,v2 in v.items():
            print("|",end="")
            if v2 == None:
                print("   ",end="")
            else:
                if v2.get_boja() == "b":
                    print(" b ",end="")
                #moze da se izbrise velika slova
                elif v2.get_boja() == "B":
                    print(" B ", end="")
                elif v2.get_boja() == "c":
                    print(" c ",end="")
                else:
                    print(" C ", end="")
            flag += 1
            if flag == 8:
                print("|  "+k, end="")
                flag = 0
        print()
        if k != "h":
            print("|---+---+---+---+---+---+---+---|")
    print("|-------------------------------|")
    if korisnik == True:
        gameOn()
    else:
        potezRacunara()

def clearPrompt():
    """
    Cisti se command prompt
    """
    clear = lambda: os.system('cls')
    clear()


def validanBroj(broj):
    """
    Proverava da li je broj ispravan.
    """
    if broj>0 and broj <= 8:
        return True
    return False

def validnoSlovo(slovo):
    """
    Proverava da li je slovo ispravno.
    """
    if slovo == "a" or slovo == "b" or slovo == "c" or slovo == "d" \
            or slovo == "e" or slovo == "f" or slovo == "g" or slovo == "h":
        return True
    return False

def validanUpisPoteza(potez):
    """
    Proverava da li je duzina upisa tacna,
    da li je prvi karakter slovo i drugi broj.
    """
    if len(potez) == 2:
        slovo = potez[0]
        broj = potez[1]
        try:

            str(slovo) and int(broj)

            return True
        except:
            return False
    return False

def ispisFiguraSaUslovomZaJelo():
    """
    Ispisuje sve figure koje su ostvarile uslov
    da pojedu i one se moraju pomeriti.
    """

    #ISPISUJE MI POZICIJE NA KOJIMA CES BITI KAD POJEDES

    #for k, v in recnikZaJelo.items():
    #    for k2,v2 in v.items():
    #        for broj in v2:
    #            polje = k2 + str(v2)
    #print("Na polje ",polje," ces stati kad pojedes")
    print("nebitno")

def praznoPolje(slovo,broj):
    """
    Proverava da li je polje prazno.
    """
    for k,v in tabla.items():
        if slovo == k:
            for k2,v2 in v.items():
                if broj == k2:
                    if v2 == None:
                        return True
                    return False

def proveraBojeSvojeFigure(slovo,broj):
    """
    Proverava boju izabrane figure
    """
    for k,v in tabla.items():
        if k == slovo:
            for k2,v2 in v.items():
                if k2 == broj:
                    if v2.get_boja() == "b":
                        return True
                    return False

def ispravanUnosPocetnogPoteza(pocetniPotez):
    """
    Proverava ispravnost prvog poteza.
    """
    if validanUpisPoteza(pocetniPotez):
        slovo = pocetniPotez[0]
        broj = int(pocetniPotez[1])
        if validnoSlovo(slovo) and validanBroj(broj) and not praznoPolje(slovo,broj) \
                        and proveraBojeSvojeFigure(slovo,broj):
            return True
        else:
            return False
    return False

def ispravanUnosKrajnjegPoteza(krajnjiPotez):
    """
    Proverava ispravnost krajnjeg poteza.
    """
    print("dal udje")

    if validanUpisPoteza(krajnjiPotez):
        slovo = krajnjiPotez[0]
        broj = int(krajnjiPotez[1])
        if  validnoSlovo(slovo) and validanBroj(broj) and praznoPolje(slovo,broj):
            print("usao1")
            return True
        return False
    return False


def proveraJela():
    """
    Proverava dijagonalno polje da li sadrzi protivnicku
    figuru,ukoliko da,proverava dijagonalno polje od te
    figure da li je prazno.
    """
    #za red a
    #k = a,b,c,d,e,f,g,h, k je slovo
    #v = {1:None, 2:Figura, 3:none, 4:figura....do 8}
    #k2 = 1,2,3,4,5, k2 je broj
    #v2 = none,figura,none,figura

    for k, v in tabla.items():
        for k2, v2 in v.items():
            if v2 != None:
                if v2.get_boja() == "b":
                    recnikZaJelo[v2] = {}
                    recnikZaJelo[v2][v2.get_redIznad2()] = []
                    if k2 == 1:
                        fDesno = tabla[v2.get_redIznad()][v2.get_kolonaDesno()]
                        if fDesno != None:
                            if (fDesno.get_boja() == "c" and praznoPolje(v2.get_redIznad2(), v2.get_kolonaDesno2())):

                                recnikZaJelo[v2][v2.get_redIznad2()].append(v2.get_kolonaDesno2())

                    elif k2 == 8:  # proveri samo za levu kolonu
                        fLevo = tabla[v2.get_redIznad()][v2.get_kolonaLevo()]
                        if fLevo != None:
                            if (fLevo.get_boja() == "c" and praznoPolje(v2.get_redIznad2(), v2.get_kolonaLevo2())):
                                recnikZaJelo[v2][v2.get_redIznad2()].append(v2.get_kolonaLevo2())

                    else:
                        # proveri i zalevu i za desnu
                        fDesno = tabla[v2.get_redIznad()][v2.get_kolonaDesno()]
                        fLevo = tabla[v2.get_redIznad()][v2.get_kolonaLevo()]
                        if fDesno != None:
                            if fDesno.get_boja() == "c":
                                if praznoPolje(v2.get_redIznad2(),v2.get_kolonaDesno2()):
                                    recnikZaJelo[v2][v2.get_redIznad2()].append(v2.get_kolonaDesno2())

                        if fLevo != None:
                            if fLevo.get_boja() == "c":
                                if praznoPolje(v2.get_redIznad2(), v2.get_kolonaLevo2()):
                                    recnikZaJelo[v2][v2.get_redIznad2()].append(v2.get_kolonaLevo2())

def dostupniPotezi():
    """
    Trazi sva moguca polja koja su dostupna za igru.
    """
    global recnikMogucihPoteza,pomocniRecnik
    #ovde counter treba da uhvati velicinu recnika i onda na kraju proveravamo dal se promenio

    for k,v in tabla.items():
        for k2,v2 in v.items():
            if v2 != None and v2.get_boja() == "b":
                # v2.set_kolona(k2)
                # v2.set_red(k)
                # ovo ne treba
                #praznoPolje(k,k2)
                recnikMogucihPoteza[v2] = {}
                recnikMogucihPoteza[v2][v2.get_redIznad()] = []
                if praznoPolje(v2.get_redIznad(),v2.get_kolonaDesno()):
                    #pravilno resenje je mapa, gde ce figura biti kljuc, a vrednost ce biti lista torki(a1,b3,f2....), tj lista mogucih poteza

                    recnikMogucihPoteza[v2][v2.get_redIznad()].append(v2.get_kolonaDesno())

                  # counter+=1
                if praznoPolje(v2.get_redIznad(),v2.get_kolonaLevo()):
                    recnikMogucihPoteza[v2][v2.get_redIznad()].append(v2.get_kolonaLevo())

    #if counter > 0:
    #    return True

    #else:

    #    return False

def ispisDostupnihPoljaZaIgru():
    """
    Ispisuje sva polja figura koja su ostvarile
    uslov za skok.
    """
    print("Dostupna polja za igru: ")
    for k,v in recnikMogucihPoteza.items():
        for k2,v2 in v.items():
            polje = k2+str(v2)
            print(polje+" ",end="")
    print()


def nevazeciPotez():
    """
    Vraca ispis.
    """
    print("Nevazeci potez.Probajte opet.\n")

def pomeranjeFigure(slovo, broj, slovo2, broj2):
    """
    Vrednost starog polja se postavlja na None,
    figura se postavlja na novo polje koje preuzima
    njene osobine.
    """
    global recnikZaJelo, recnikMogucihPoteza, uslovZaJelo, pomocniRecnik
    # tabla[slovo][broj] = None
    for k, v in tabla.items():
        print(v)
        if slovo == k:
            print("ovo je slovo", slovo)
            # slovo1 je f, slovo2 je d
            for k2, v2 in v.items():
                if k2 == broj:
                    razlika = broj2 - broj
                    print("ovo je razlika",razlika)

                    if razlika == 1:
    #
                        tabla[v2.get_red()][v2.get_kolona()] = None
                        v2.set_red(slovo2)
        #                    print("ovo je slovo2", slovo2)
                        v2.set_kolona(broj2)
                        if v2.get_red() == "a":
                            v2.set_dama(True)
                            v2.set_boja("B")
                        red = v2.get_red()
                        kolona = v2.get_kolona()
                        tabla[red][kolona] = Figura(red, kolona, v2.get_boja(), v2.get_dama())

                        recnikZaJelo.clear()
                        recnikMogucihPoteza.clear()
                        clearPrompt()

                    else:
                        #ZAVISI DAL SKACES LEVO ILI DESNO
                        #v2
                        print("ovo je reeed",v2.get_red())

                        f = tabla[v2.get_red()][v2.get_kolona()]
                        #OVO JE FIGURICA SAD.
                        kolonaLevo = v2.get_kolonaLevo()
                        kolonaDesno = v2.get_kolonaDesno()
                        iznad = v2.get_redIznad()
                        tabla[v2.get_red()][v2.get_kolona()] = None
                        v2.set_red(slovo2)
                        #                    print("ovo je slovo2", slovo2)
                        v2.set_kolona(broj2)
                        if v2.get_red() == "a":
                            v2.set_dama(True)
                            v2.set_boja("B")
                        red = v2.get_red()
                        kolona = v2.get_kolona()

                        kolonaLevo2 = v2.get_kolonaLevo()
                        kolonaDesno2 = v2.get_kolonaDesno()

                        print("ovo su kolonice")
                        print(kolonaLevo)
                        print(kolonaDesno)
                        print(kolonaLevo2)
                        print(kolonaDesno2)

                        if kolonaLevo == kolonaDesno2:
                            tabla[iznad][kolonaLevo] = None
                        elif kolonaDesno == kolonaLevo2:
                            tabla[iznad][kolonaDesno] = None

                        #red i kolona su sadasnji
                        tabla[red][kolona] = Figura(red, kolona, v2.get_boja(), v2.get_dama())

                        recnikZaJelo.clear()
                        recnikMogucihPoteza.clear()
                        clearPrompt()
    #                else:
    #                    v2.set_red(slovo2)
    #                    v2.set_kolona(broj2)
    #                    if v2.get_red() == "a":
    #                        v2.set_dama(True)
    #                        v2.set_boja("B")
    #                    red = v2.get_red()
    #                    kolona = v2.get_kolona()
    #                    print("ovde")
    #                    print(red, kolona, v2.get_red(), v2.get_kolona())
    #                    tabla[red][kolona] = Figura(red, kolona, v2.get_boja(), v2.get_dama())
    #                    print(tabla[red][kolona], "OVDE")
    #                    tabla[slovo][broj] = None

                        # SAMO STAVI NONE TAMO GDE JE BILA FIGURA
    #                    recnikZaJelo.clear()
    #                    recnikMogucihPoteza.clear()
    #                    clearPrompt()
    iscrtavanjeTable()

def mogucnostKretanja(pocetniPotez):
    counter = 0
    #return True
    #proveri da li uopste moze da se krece tj da li si izabrao dobrog igraca
    slovo = pocetniPotez[0]
    broj = int(pocetniPotez[1])
    for k, v in tabla.items():
        if slovo == k:
            for k2,v2 in v.items():
                if k2 == broj:

                    #RESI OVDE PROBLEM SA NONE
                    if praznoPolje(v2.get_redIznad(), v2.get_kolonaLevo()) or praznoPolje(v2.get_redIznad(), v2.get_kolonaDesno()):
                        counter +=1
                    else: #ako nije prazno polje proveri da li je crni gore
                        if k2 == 1:
                            fDesno = tabla[v2.get_redIznad()][v2.get_kolonaDesno()]
                            if(fDesno.get_boja() == "c" and praznoPolje(v2.get_redIznad2(), v2.get_kolonaDesno2())):
                                counter += 1

                        elif k2 == 8:  # proveri samo za levu kolonu
                            fLevo = tabla[v2.get_redIznad()][v2.get_kolonaLevo()]
                            if(fLevo.get_boja() == "c" and praznoPolje(v2.get_redIznad2(), v2.get_kolonaLevo2())):
                                counter += 1
                        else:
                            # proveri i zalevu i za desnu
                            fDesno = tabla[v2.get_redIznad()][v2.get_kolonaDesno()]
                            fLevo = tabla[v2.get_redIznad()][v2.get_kolonaLevo()]
                            if(fLevo.get_boja() == "c" or fDesno.get_boja() == "c"):
                                if praznoPolje(v2.get_redIznad2(), v2.get_kolonaLevo2()) or praznoPolje(v2.get_redIznad2(), v2.get_kolonaDesno2()):
                                    counter += 1

    if counter > 0:
        return True

    else:

       return False


                    #if k2 == 1:
                    #    print("k2    ", k2)
                    #    print("v2    ", v2)
                        #proveri samo desno dole
                    #    slovo_ispod = v2.get_redIspod()
                    #    print(slovo_ispod)
                    #elif k2 == 8:
                    #    slovo_ispod = v2.get_redIspod()
                    #    print(slovo_ispod)
                    #else:
                    #    slovo_ispod = v2.get_redIspod()
                    #    print(slovo_ispod)

    #samo da mi ispise ako korisnik unese polje koje je ispod da ne moze


def krajnjiPotez():
    global slovo, broj#, uslovZaJelo
    while True:

        kranjiPotez = \
            input("Unesite poooziciju na koju zelite da pomerite figuru[npr: a1]: ").lower()
        if validanUpisPoteza(kranjiPotez):

            slovo_ispod = ""

            for k, v in tabla.items():
                if slovo == k:
                    for k2, v2 in v.items():
                        if k2 == broj:
                            if slovo != "h":
                                slovo_ispod = v2.get_redIspod()

            slovo2 = kranjiPotez[0]
            broj2 = int(kranjiPotez[1])
            if slovo_ispod == slovo2:
                nevazeciPotez()
                return

            for k, v in recnikMogucihPoteza.items():
                for k2, v2 in v.items():
                    for brojVrednost in v2:
                        if slovo2 == k2 and broj2 == brojVrednost:
                            if ispravanUnosKrajnjegPoteza(kranjiPotez):
                            #    and pravilnoKretanje(slovo,broj,slovo2,broj2):

                                pomeranjeFigure(slovo, broj, slovo2, broj2)



            for k, v in recnikZaJelo.items():
                for k2, v2 in v.items():
                    for brojic in v2:
                        if slovo2 == k2 and broj2 == brojic:
                            # k2 je d, a v2 je lista
                            # if slovo2 == k2 and broj2 == v2:
                            # if ispravanUnosKrajnjegPoteza(kranjiPotez) \
                            #    and pravilnoKretanje(slovo, broj, slovo2, broj2):
                            #        pomeranjeFigure(slovo, broj, slovo2, broj2)
                            if ispravanUnosKrajnjegPoteza(kranjiPotez):
                                # if pravilnoKretanje(slovo,broj,slovo2,broj2):
                                #    print("srecica")
                                pomeranjeFigure(slovo, broj, slovo2, broj2)
                            else:
                                nevazeciPotez()
        else:
            nevazeciPotez()

#TAMO GDE JE BIO UZMI RED IZNAD KOLONU I LEVO I DESNO, I TAMO GDE JE SAD UZMI RED ISPOD LEVO I DESNO
#I STA SE POKLOPI TAMO JE CRNI!!!

def gameOn():
    global korisnik, recnikMogucihPoteza, uslovZaJelo, slovo, broj
    a = False
    while True:
        proveraJela()
        ispisFiguraSaUslovomZaJelo()
        pocetniPotez = input("Unesite poziciju sa koje pomerate figuru[npr: a1]: ").lower()

        if ispravanUnosPocetnogPoteza(pocetniPotez):
            if mogucnostKretanja(pocetniPotez):
                slovo = pocetniPotez[0]
                broj = int(pocetniPotez[1])
                #ispisFiguraSaUslovomZaJelo()
                dostupniPotezi()
                ispisDostupnihPoljaZaIgru()
                krajnjiPotez()


if __name__ == "__main__":
    dodavanjeFigura()