"""
TIE-02100 Johdatus ohjelmointiin
Valtteri Vuorio, 268084
[email protected]
polynomilaskin
Ohjelmalle annetaan tekstitiedostossa polynomeja ja niitä voi laskea yhteen,
vähentää toisistaan ja kertoa toisillaan antamalla laskimelle komentoja.
"""


"""
Polynomi -luokka tallentaa polynomin termit sanakirjaan, jossa avaimina on
eksponentit ja arvoina kerroin. Luodessa annetaan kaksi parametria.
:param eksponentti: Ensimmäisen termin eksponentti. Tallennetaan avaimena
sanakirjaan self.__polynomi
:param kerroin: Ensimmäisen termin kerroin. Tallennetaan arvona sanakirjaan.
:return: None.
"""


class Polynomi:
    def __init__(self, eksponentti, kerroin):
        self.__polynomi = {}
        self.__polynomi[eksponentti] = kerroin

    """
    Metodi lisää uuden termin olion sanakirjaan.
    :param eksponentti: Ensimmäisen termin eksponentti. Tallennetaan avaimena
    sanakirjaan.
    :param kerroin: Ensimmäisen termin kerroin. Tallennetaan arvona sanakirjaan
    :return: None.
    """

    def lisää_termi(self, eksponentti, kerroin):
        self.__polynomi[eksponentti] = kerroin

    """
    Tulostaa olion halutussa muodosa.
    :param muistipaikka: Käytetään tulosteessa. Jos parametriksi annetaan "-1",
    tulosteesta poistetaan muistipaikka -osuus.
    :return: None.
    """

    def tulosta(self, muistipaikka):
        tuloste = ""
        for eksponentti in sorted(self.__polynomi):
            if tuloste == "":
                if int(self.__polynomi[eksponentti]) == 0:
                    pass
                else:
                    tuloste += "{}x^{}".format(self.__polynomi[eksponentti],
                                               eksponentti)
            else:
                if int(self.__polynomi[eksponentti]) == 0:
                    pass
                else:
                    tuloste = "{}x^{} + ".format(self.__polynomi[eksponentti],
                                                 eksponentti) + tuloste
        if tuloste == "":
            tuloste = "0"

        if muistipaikka != "x":
            print("Memory location {}:".format(muistipaikka), tuloste)
        else:
            print("The simplified result:")
            if tuloste == "":
                print("0")
            else:
                print(tuloste)

    """
    Hakee kertoimen tietyn eksponentin termille.
    :param eksponentti: Kertoo minkä termin kerroin palauttaa
    :return: kerroin int -muodossa
    """

    def hae_kerroin(self, eksponentti):
        if eksponentti not in self.__polynomi:
            return 0
        else:
            kerroin = int(self.__polynomi[eksponentti])
            return kerroin

    """
    Hakee olion kaikkien termien eksponentit.
    :return: Lista, jossa kaikki olion termien eksponentit.
    """

    def hae_eksponentit(self):
        eksponentit = []
        for eksponentti in self.__polynomi:
            eksponentit.append(eksponentti)
        return eksponentit


"""
Lukee tekstitiedostosta polynomit. Käy läpi tiedoston rivi kerrallaan ja luo
uusia polynomi -olioita tarvittaessa
:param nimi: Käyttäjän antama tiedoston nimi.
:return: None.
"""


def lue_tiedosto(nimi):
    polynomit = []
    tiedosto = open(nimi, 'r')
    k = 0
    for rivi in tiedosto:
        rivi = rivi.rstrip()
        termit = rivi.split(';')
        i = 1
        for luku in termit:
            luku = luku.split(" ")
            kerroin = luku[0]
            eksponentti = luku[1]
            if i == 1:
                polynomit.append(Polynomi(eksponentti, kerroin))
                i += 1
            else:
                polynomit[k].lisää_termi(eksponentti, kerroin)
        k += 1
    return polynomit


"""
Laskee yhteen kaksi polynomia. Käy läpi ensimmäisen polynomin eksponentit ja
lisää niihin toisesta polynomista löytyvät saman asteen termit. Jos toisesta
polynomista ei löydy samanasteista termiä toisen polynomin kerroin siirtyy
ratkaisuun.
:param eka: Ensimmäisen polynomin muistipaikka. Käytetään polynomi -olion
löytämiseen.
:param toka: Toisen polynomin muistipaikka.
:return: Polynomi -olio, jossa tallennettuna tulos.
"""


def lisää(eka, toka):
    ekan_eksponentit = eka.hae_eksponentit()
    tokan_eksponentit = toka.hae_eksponentit()
    l = 1
    for eksponentti in ekan_eksponentit:
        if eksponentti in tokan_eksponentit:
            kerroin1 = eka.hae_kerroin(eksponentti)
            kerroin2 = toka.hae_kerroin(eksponentti)
            kerroin = kerroin1 + kerroin2
        else:
            kerroin = eka.hae_kerroin(eksponentti)

        if l == 1:
            tulos = Polynomi(eksponentti, kerroin)
            l += 1
        else:
            tulos.lisää_termi(eksponentti, kerroin)
    tuloksen_eksponentit = tulos.hae_eksponentit()
    for eksponentti in tokan_eksponentit:
        if eksponentti not in tuloksen_eksponentit:
            kerroin = toka.hae_kerroin(eksponentti)
            tulos.lisää_termi(eksponentti, kerroin)
    return tulos


"""
Vähentää kaksi polynomia toisistaan. Toimii vastaavasti lisää -funktion kanssa,
mutta vähennyslaskuun muokattuna.
:param eka: Ensimmäisen polynomin muistipaikka. Käytetään polynomi -olion
löytämiseen.
:param toka: Toisen polynomin muistipaikka.
:return: Polynomi -olio, jossa tallennettuna tulos.
"""


def vähennä(eka, toka):
    ekan_eksponentit = eka.hae_eksponentit()
    tokan_eksponentit = toka.hae_eksponentit()
    l = 1
    for eksponentti in ekan_eksponentit:
        if eksponentti in tokan_eksponentit:
            kerroin1 = eka.hae_kerroin(eksponentti)
            kerroin2 = toka.hae_kerroin(eksponentti)
            kerroin = kerroin1 - kerroin2
        else:
            kerroin = eka.hae_kerroin(eksponentti)

        if l == 1:
            tulos = Polynomi(eksponentti, kerroin)
            l += 1
        else:
            tulos.lisää_termi(eksponentti, kerroin)

    tuloksen_eksponentit = tulos.hae_eksponentit()
    for eksponentti in tokan_eksponentit:
        if eksponentti not in tuloksen_eksponentit:
            kerroin = -1 * toka.hae_kerroin(eksponentti)
            tulos.lisää_termi(eksponentti, kerroin)
    return tulos


"""
Kertoo kaksi polynomia toisillaan. Käy läpi ensimmäisen polynomin termit
kertoen niillä kaikki toisen polynomin termit. Jos kerrottaessa syntyy useita
saman eksponentin termejä, ne yhdistetään.
:param eka: Ensimmäisen polynomin muistipaikka. Käytetään polynomi -olion
löytämiseen.
:param toka: Toisen polynomin muistipaikka.
:return: Polynomi -olio, jossa tallennettuna tulos.
"""


def kerro(eka, toka):
    ekan_eksponentit = eka.hae_eksponentit()
    tokan_eksponentit = toka.hae_eksponentit()
    l = 1
    for eksponentti1 in ekan_eksponentit:
        for eksponentti2 in tokan_eksponentit:
            tuloksen_eksponentti = int(eksponentti1) + int(eksponentti2)
            kerroin1 = eka.hae_kerroin(eksponentti1)
            kerroin2 = toka.hae_kerroin(eksponentti2)
            tuloksen_kerroin = kerroin1 * kerroin2
            if l == 1:
                tulos = Polynomi(tuloksen_eksponentti, tuloksen_kerroin)
                l += 1
            else:
                tuloksen_eksponentit = tulos.hae_eksponentit()
                if tuloksen_eksponentti in tuloksen_eksponentit:
                    kerroin1 = tulos.hae_kerroin(tuloksen_eksponentti)
                    uusi_kerroin = kerroin1 + tuloksen_kerroin
                    tulos.lisää_termi(tuloksen_eksponentti, uusi_kerroin)
                else:
                    tulos.lisää_termi(tuloksen_eksponentti, tuloksen_kerroin)
    return tulos


"""
Lukee ensin tiedostosta polynomit.
Kysyy käyttäjätä käskyä.
Käsittelee käskyn ja suorittaa halutun laskutoimituksen.
Käsittelee tarvittaessa virhetilanteet.
"""


def main():
    tiedosto_nimi = input("Enter file name: ")
    try:
        polynomit = lue_tiedosto(tiedosto_nimi)
        skip = False
    except:
        print("Error in reading the file.")
        skip = True

    while True:
        formaatti = True
        tuntematon = True
        paikat = True
        if skip:
            return

        komento = input("> ")

        if komento == "quit":
            print("Bye bye!")
            return
        try:
            komento = komento.split(" ")
            eka = int(komento[0])
            toka = int(komento[2])
            merkki = komento[1]
        except:
            print("Error: entry format is memory_location "
                  "operation memory_location.")
            formaatti = False

        if len(komento) != 3 and formaatti:
            print("Error: entry format is memory_location "
                  "operation memory_location.")
            formaatti = False

        if eka < 0 and formaatti:
            print("Error: entry format is memory_location "
                  "operation memory_location.")
            formaatti = False

        if toka < 0 and formaatti:
            print("Error: entry format is memory_location "
                  "operation memory_location.")
            formaatti = False

        if merkki != "+" and merkki != "-" and merkki != "*" and formaatti:
            print("Error: unknown operator.")
            tuntematon = False

        try:
            testi = polynomit[eka]
            testi = polynomit[toka]
        except:
            if formaatti and tuntematon:
                print("Error: the given memory location does not exist.")
            paikat = False

        if formaatti and tuntematon and paikat:
            if merkki == "+":
                polynomit[eka].tulosta(eka)
                polynomit[toka].tulosta(toka)
                tulos = lisää(polynomit[eka], polynomit[toka])
                tulos.tulosta("x")

            elif merkki == "-":
                polynomit[eka].tulosta(eka)
                polynomit[toka].tulosta(toka)
                tulos = vähennä(polynomit[eka], polynomit[toka])
                tulos.tulosta("x")

            elif merkki == "*":
                polynomit[eka].tulosta(eka)
                polynomit[toka].tulosta(toka)
                tulos = kerro(polynomit[eka], polynomit[toka])
                tulos.tulosta("x")


main()