# Endringer i flyttmetoden i Sjakkbrett
class Brikke:
    def __init__(self, sym):
        self._symbol = sym

    def hentSymbol(self):
        return self._symbol

    def hentFelt(self, brett):
        # brett er et sjakkbrett med feltobjekter
        for rad in brett:
            for felt in rad:
                brikke = felt.hentBrikke()
                if brikke == self:
                    return felt.hentFelt()
        return None

class Felt:
    def __init__(self, rad, kolonne, brikke):

        self._rad = rad         # 0 ... 7
        self._kolonne = kolonne # 0 ... 7
        self._felt = sjakkoordinater[rad][kolonne]
        # mod blir 0 hvis rad+kolonne er et partall (delelig med 2)
        mod = (rad + kolonne) % 2
        # Dette bestemmer feltets farge
        if mod == 0:
            self._farge = 'hvit'
        else:
            self._farge = 'svart'
        self._brikke = brikke   # referanse til brikkeobjekt hvis
                                # brikke p? feltet; None hvis tomt

    def hentFelt(self):
        return self._felt

    def hentBrikke(self):
        return self._brikke

    def nyBrikke(self, ny):
        self._brikke = ny

    def koordinater(self):
        return '['+str(self._rad)+']'+'['+str(self._kolonne)+']'

    def __str__(self):
        if self._brikke == None:
            if self._farge == 'hvit':
                tegn = '.'
            else:
                tegn = ':'
        else:
            tegn = self._brikke.hentSymbol()
        return tegn

class Sjakkbrett:

    def __init__(self, ordbok):
        #  self._brett vil bli en 8 x 8 matrise av feltobjekter
        self._brett = []
        #  self._brikker vil bli ei liste av brikkeobjektene p? brettet
        self._brikker = []
        r = 0
        for rad in [8, 7, 6, 5, 4, 3, 2, 1]:
            self._brett.append([])
            k = 0
            for kol in ['a','b','c','d','e','f','g','h']:
                felt = kol + str(rad)
                # felt = 'a8', 'b8', 'c8', ... 'g1', 'h1'
                if felt in ordbok:
                    # Brikken med symbol ordbok[felt] st?r p? felt
                    brikke = Brikke(ordbok[felt])
                    self._brikker.append(brikke)
                else:
                    brikke = None
                # Feltet er bestemt og vi legger det til
                # p? brettet i rad r og kolonne k
                self._brett[r].append(Felt(r,k,brikke))
                k = k+1 # neste kolonne i denne raden
            r = r+1 # neste rad

    def flyttBrikke(self, fra, til):
        # fra, til er sjakkoordinater, f.eks. 'g5', 'f7'
        # finner f?rst de to feltobjektene
        for rad in sjakkoordinater:
            if fra in rad:
                frai = sjakkoordinater.index(rad)
                fraj = rad.index(fra)
            if til in rad:
                tili = sjakkoordinater.index(rad)
                tilj = rad.index(til)
        fraFelt = self._brett[frai][fraj]
        tilFelt = self._brett[tili][tilj]

        tilFelt.nyBrikke(fraFelt.hentBrikke())
        # NB hentBrikke fjerner ikke brikken
        fraFelt.nyBrikke(None)

        # Her kan vi legge inn mye logikk som ? kontrollere at
        # trekket (flyttingen) er lovlig i f?lge reglene

    def skrivBrettTilFil(self, utfil):
        fil = open(utfil, 'w')
        for rad in self._brett:
            linje = ''
            for kol in rad:
                linje = linje + str(kol)
            fil.write(linje+'\n')
        fil.close()

    def lesBrettFraFil(self, innfil):
        fil = open(innfil)
        brett = []
        r = 0
        for linje in fil:
            brett.append([])
            for tegn in linje.strip():
                brett[r].append(tegn)
            r = r+1
        ordbok = {}
        for i in range(8):
            for j in range(8):
                tegn = brett[i][j]
                if tegn not in ['.',':']:
                    ordbok[sjakkoordinater[i][j]] = tegn
        self.__init__(ordbok)

    def skriv(self):
        for rad in self._brett:
            linje1 = ''
            linje2 = '   '
            linje3 = '   '
            for kol in rad:
                linje1 = linje1 + '  ' + kol.koordinater()
                linje2 = linje2 + str(kol) + '       '
                linje3 = linje3 + kol.hentFelt() + '      '
            print('\n'+linje1)
            print(linje2)
            print(linje3)

    def antBrikker(self):
        return len(self._brikker)

# slutt class Sjakkbrett

def itererNedoverFra(fom, tom): # fra og med, til og med
    liste = []
    while (fom >= tom):
        liste.append(fom)
        fom = fom - 1
    return liste

# Konstanter for sjakkoordinater

rader =  ['a','b','c','d','e','f','g','h']
linjer = [ 8,
           7,
           6,
           5,
           4,
           3,
           2,
           1 ]

sjakkoordinater = [[ 'a8', 'b8', 'c8', 'd8', 'e8', 'f8', 'g8', 'h8'],
                   [ 'a7', 'b7', 'c7', 'd7', 'e7', 'f7', 'g7', 'h7'],
                   [ 'a6', 'b6', 'c6', 'd6', 'e6', 'f6', 'g6', 'h6'],
                   [ 'a5', 'b5', 'c5', 'd5', 'e5', 'f5', 'g5', 'h5'],
                   [ 'a4', 'b4', 'c4', 'd4', 'e4', 'f4', 'g4', 'h4'],
                   [ 'a3', 'b3', 'c3', 'd3', 'e3', 'f3', 'g3', 'h3'],
                   [ 'a2', 'b2', 'c2', 'd2', 'e2', 'f2', 'g2', 'h2'],
                   [ 'a1', 'b1', 'c1', 'd1', 'e1', 'f1', 'g1', 'h1']]

stillingA = {'a2':'b', 'c2':'l', 'd2':'k', 'f2':'b', 'g2':'b',
             'c3':'b', 'e3':'l',
             'c4':'b', 'g4':'t',
             'a5':'B', 'c5':'B', 'e5':'b', 'h5':'t',
             'b6':'B', 'c6':'L', 'e6':'B', 'g6':'S', 'h6':'B',
             'b7':'K', 'f7':'B',
             'g8':'T', 'h8':'T'
            }

def testprogA():
    brettA = Sjakkbrett(stillingA)
    brettA.skriv()
    print("Antall brikker p? brettet:", brettA.antBrikker())
    input()
    sjakkbrettNr7 = Sjakkbrett({})
    sjakkbrettNr7.lesBrettFraFil('startstilling.txt')


    brettA.skriv()
    print("Antall brikker p? brettet:", brettA.antBrikker())
    input()
    sjakkbrettNr7.skriv()
    print("Antall brikker p? brettet:", sjakkbrettNr7.antBrikker())
    input()
    sjakkbrettNr7.flyttBrikke('f2', 'f3')
    sjakkbrettNr7.skriv()
    print("Antall brikker p? brettet:", sjakkbrettNr7.antBrikker())
    input()

def testprogB():
    brett = Sjakkbrett({})
    brett.skriv()
    print("Antall brikker p? brettet:", brett.antBrikker())
    print("\n\n")

testprogA()
testprogB()