class Polynomi:
    """
    Tämä on olio johon tallennetaan sanakirja, jossa ovat potenssit ja
    kertoimet. Tätä oliota ja sen methodeja kätetään sitten erilaisiin
    toimintoihin.
    """

    def __init__(self, arvosanakirja):
        self.__arvosanakirja = arvosanakirja

    def tulosta(self):
        """
        Tämä methdoi palauttaa tulostuksen, joka tehtävän annossa haluttiin
        kohtaan, jossa printataan tietyissä muistilokeroissa olevia polynomeja
        :return: palautus eli merkkijono, jossa polynomi
        """

        polynomilista = []
        for z in sorted(self.__arvosanakirja):
            if self.__arvosanakirja[z] == 0:
                pass
            else:
                asd = str(self.__arvosanakirja[z]) + "x^" + str(z)
                polynomilista.append(asd)
        polynomilista = polynomilista[::-1]
        if polynomilista == []:
            polynomilista.append("0")
        palautus = " + ".join(polynomilista)
        return palautus

    def plussa(self, toinensanakirja):
        """
        Tämä methodi lisää yhteen kaksi haluttua polynomia hyödyntäen uutta
        sanakirjaa sekä listaa.
        :param toinensanakirja:
        :return: palautus1, Eli palauttaa uuden polynomin
        """
        uusisanakirja = {}
        for x in toinensanakirja.__arvosanakirja:
            if x in self.__arvosanakirja:
                uusiarvo = int(self.__arvosanakirja[x]) + int(toinensanakirja.__arvosanakirja[x])
                uusisanakirja[x] = int(uusiarvo)
            else:
                uusisanakirja[x] = toinensanakirja.__arvosanakirja[x]
        for y in self.__arvosanakirja:
            if y in uusisanakirja:
                pass
            else:
                uusisanakirja[y] = self.__arvosanakirja[y]

        lista1 = []
        for z in sorted(uusisanakirja):
            if uusisanakirja[z] == 0:
                pass
            else:
                asd = str(uusisanakirja[z]) + "x^" + str(z)
                lista1.append(asd)
        if lista1 == []:
            lista1.append("0")

        lista1 = lista1[::-1]
        palautus1 = " + ".join(lista1)

        return palautus1

    def miinus(self, toinensanakirja):
        """
        Tämä methodi vähentää kaksi haluttua polynomia toisistaan samalla
        tavalla kuin plussa methodi.
        :param toinensanakirja:
        :return: palautus2, eli uusi polynomi
        """

        uusisanakirja1 = {}
        for x in toinensanakirja.__arvosanakirja:
            if x in self.__arvosanakirja:
                uusi = int(self.__arvosanakirja[x]) - \
                       int(toinensanakirja.__arvosanakirja[x])
                uusisanakirja1[x] = int(uusi)
            else:
                uusisanakirja1[x] = (-1) * toinensanakirja.__arvosanakirja[x]
        for y in self.__arvosanakirja:
            if y in uusisanakirja1:
                pass
            else:
                uusisanakirja1[y] = self.__arvosanakirja[y]

        lista1 = []
        for z in sorted(uusisanakirja1):
            if uusisanakirja1[z] == 0:
                pass
            else:
                asd = str(uusisanakirja1[z]) + "x^" + str(z)
                lista1.append(asd)
        if lista1 == []:
            lista1.append("0")

        lista1 = lista1[::-1]
        palautus2 = " + ".join(lista1)
        return palautus2


    def kerto(self,toka):
        """
        Tämä methodi kertoo kaksi haluttua polynomia keskenään. Käyttää hyväksi
        sanakirjoja ja listoja.
        :param toka:
        :return: palautus, eli uusi polynomi
        """
        uusisanakirja = {}
        for x in self.__arvosanakirja:
            for y in toka.__arvosanakirja:
                uusi_potenssi = int(x) + int(y)
                uusi_kerroin = int(self.__arvosanakirja[x]) * \
                               int(toka.__arvosanakirja[y])
                if uusi_kerroin == 0:
                    pass
                elif int(uusi_potenssi) in uusisanakirja:
                    uusisanakirja[int(uusi_potenssi)] =\
                        int(uusisanakirja[uusi_potenssi]) + int(uusi_kerroin)
                else:
                    uusisanakirja[int(uusi_potenssi)] = int(uusi_kerroin)

        lista1 = []
        for z in sorted(uusisanakirja):
            asd = str(uusisanakirja[z]) + "x^" + str(z)
            lista1.append(asd)
        if lista1 == []:
            lista1.append("0")

        lista1 = lista1[::-1]
        palautus = " + ".join(lista1)
        return palautus


def luku(muuttuja):
    """
    Tämä funktio lukee lähdetiedoston ja palauttaa sanakirja, jossa on sisällä
    toinen sanakirja, joka on tallennettu olioon., jos ei voi lukea palauttaa
    arvon vaara, jolla sitten kerrotaan ongelmasta.
    :param muuttuja:
    :return: sanakirja, vaara
    """
    sanakirja = {}
    try:
        i = 0
        tiedosto = open(muuttuja, "r")
        for rivi in tiedosto:
            rivi = rivi.rstrip()
            rivi1 = rivi.split(";")
            sanakirja2 = {}
            for x in rivi1:
                uusi = x.split(" ")
                sanakirja2[int(uusi[1])] = int(uusi[0])
            sanakirja[i] = Polynomi(sanakirja2)
            i += 1

        return sanakirja
    except OSError:
        print("Error in reading the file.")
        return "vaara"


def main():
    tiedoston_nimi = input("Enter file name: ")
    tiedosto = luku(tiedoston_nimi)
    if tiedosto == "vaara":
        return
    syote = ""
    while syote != "quit":
        syote = input("> ")
        syote2 = syote.split(" ")
        if syote != "quit":
            if len(syote2) == 3:
                if syote2[0].isdigit() and syote2[2].isdigit():
                    if syote2[1] in ["+", "*", "-"]:

                        if syote2[1] == "+":
                            if int(syote2[0]) >= len(tiedosto):
                                print("Error: the given memory location "
                                      "does not exist.")

                            elif int(syote2[2]) >= len(tiedosto):
                                print("Error: the given memory location does "
                                      "not exist.")

                            else:
                                print("Memory location {}:".format(syote2[0]),
                                      tiedosto[int(syote2[0])].tulosta())
                                print("Memory location {}:".format(syote2[2]),
                                      tiedosto[int(syote2[2])].tulosta())
                                summa = tiedosto[int(syote2[0])].plussa\
                                    (tiedosto[int(syote2[2])])
                                print("The simplified result:")
                                print(summa)

                        elif syote2[1] == "-":
                            if int(syote2[0]) > len(tiedosto):
                                print("Error: the given memory location does "
                                      "not exist.")

                            if int(syote2[2]) > len(tiedosto):
                                print("Error: the given memory location does "
                                      "not exist.")

                            else:
                                print("Memory location {}:".format(syote2[0]),
                                      tiedosto[int(syote2[0])].tulosta())
                                print("Memory location {}:".format(syote2[2]),
                                      tiedosto[int(syote2[2])].tulosta())
                                erotus = tiedosto[int(syote2[0])].miinus\
                                    (tiedosto[int(syote2[2])])
                                print("The simplified result:")
                                print(erotus)

                        elif syote2[1] == "*":
                            if int(syote2[0]) > len(tiedosto):
                                print("Error: the given memory location does "
                                      "not exist.")

                            if int(syote2[2]) > len(tiedosto):
                                print("Error: the given memory location does "
                                      "not exist.")

                            else:
                                print("Memory location {}:".format(syote2[0]),
                                      tiedosto[int(syote2[0])].tulosta())
                                print("Memory location {}:".format(syote2[2]),
                                      tiedosto[int(syote2[2])].tulosta())
                                tulo = tiedosto[int(syote2[0])].\
                                    kerto(tiedosto[int(syote2[2])])
                                print("The simplified result:")
                                print(tulo)

                        else:
                            print("Error: entry format is memory_location "
                                  "operation memory_location.")
                    else:
                        print("Error: unknown operator.")
                else:
                    print("Error: entry format is memory_location "
                          "operation memory_location.")
            else:
                print("Error: entry format is memory_location "
                      "operation memory_location.")

    print("Bye bye!")


main()