import pygame as pg
import math
from random import randint

pg.init()
pg.font.init()

valge       = [255, 255, 255]
hall        = [189, 195, 199]
tume_sinine = [52, 73, 94]
must        = [44, 62, 80]
sinine      = [52, 152, 219]
punane      = [231, 76, 60]
kollane     = [241, 196, 15]
roheline    = [46, 204, 113]
oranž       = [230, 126, 34]
ametüst     = [155, 89, 182]

ekr_x = 30**2
ekr_y = 2**9
ekr = pg.display.set_mode([ekr_x, ekr_y])
pg.display.set_caption("ruutfunktsioonid")
font = pg.font.SysFont("arial", 28)
väike_font = pg.font.SysFont("arial", 12)

# pikslites
ruudustiku_vahe = 10

class input_kast:
    def __init__(self, x, y, w, h, kirjeldus):
        self.kast = pg.Rect(x, y, w, h)
        self.värv = hall
        self.kirjeldus = kirjeldus + ":"
        self.kirjelduse_pind = font.render(self.kirjeldus, True, self.värv)
        self.tekst = ""
        self.teksti_pind = font.render(self.tekst, True, self.värv)
        self.aktiivne = False

    def uuenda_teksti_pindu(self):
        # säti teksti pinnad, et hiljem joonistada
        self.kirjelduse_pind = font.render(self.kirjeldus, True, self.värv if self.aktiivne else hall)
        self.teksti_pind = font.render(self.tekst, True, self.värv if self.aktiivne else hall)

    def käsitle_eventi(self, event):
        if (event.type == pg.MOUSEBUTTONDOWN):
            # kui kasti peale klikati
            if (self.kast.move(self.kirjelduse_pind.get_width() + 10, 0).collidepoint(event.pos)):
                # muuda muutujat
                self.aktiivne = not self.aktiivne
            else:
                self.aktiivne = False
            # muuda värvi
            self.värv = roheline if self.aktiivne else hall
        if (event.type == pg.KEYDOWN):
            if self.aktiivne:
                if event.key == pg.K_RETURN:
                    print(self.tekst)
                    self.tekst = ""
                elif event.key == pg.K_BACKSPACE:
                    self.tekst = self.tekst[:-1]
                else:
                    self.tekst += event.unicode

    def uuenda(self):
        self.uuenda_teksti_pindu()
        # uuenda kasti laiust
        width = max(20, self.teksti_pind.get_width() + 8)
        self.kast.w = width

    def joonista(self, ekraan):
        ekraan.blit(self.kirjelduse_pind, (self.kast.x, self.kast.y))
        ekraan.blit(self.teksti_pind, (self.kast.x + self.kirjelduse_pind.get_width() + 15, self.kast.y))
        pg.draw.rect(ekraan, self.värv, self.kast.move(self.kirjelduse_pind.get_width() + 10, 0), 2)

def lahenda(a, b, c):
    ruutjuur_ruudus = b ** 2 - 4 * a * c
    if (ruutjuur_ruudus < 0):
        return ("neg_root")

    if (ruutjuur_ruudus == 0.0):
        return ("single", -b / (2 * a))

    ruutjuur = math.sqrt(ruutjuur_ruudus)
    return (((-b - ruutjuur) / (2 * a)), ((-b + ruutjuur) / (2 * a)))

def joonista_graafik(a, b, c):
    for i in range (ekr_y):
        x = (ekr_y / 2 - i) / float(ruudustiku_vahe)
        y = a * x**2 + b * x + c
        pos1 = [ekr_y / 2 + x * ruudustiku_vahe - 6, ekr_y / 2 - y * ruudustiku_vahe - 6]
        nx = (ekr_y / 2 - (i + 1)) / float(ruudustiku_vahe)
        ny = a * nx ** 2 + b * nx + c
        pos2 = [ekr_y / 2 + nx * ruudustiku_vahe - 6, ekr_y / 2 - ny * ruudustiku_vahe - 6]
        pg.draw.line(ekr, oranž, pos1, pos2, 2)

def main():
    kell = pg.time.Clock()
    input_kastid = [
        input_kast(ekr_y + 15, 10, 140, 32, "ruutliikme kordaja"),
        input_kast(ekr_y + 15, 10 + 42, 140, 32, "lineaarliikme kordaja"),
        input_kast(ekr_y + 15, 10 + 84, 140, 32, "vabaliige")
    ]
    valmis = False

    while not valmis:
        for event in pg.event.get():
            if event.type == pg.QUIT:
                valmis = True
            for kast in input_kastid:
                kast.käsitle_eventi(event)

        for kast in input_kastid:
            kast.uuenda()

        ekr.fill(valge)

        # ruudustiku joonistamine
        for i in range(int(ekr_y / ruudustiku_vahe)):
            if (int(ekr_y / ruudustiku_vahe / 2) == i):
                pg.draw.line(ekr, must, (ruudustiku_vahe * i, 0), (ruudustiku_vahe * i, ekr_y), 1)
                pg.draw.line(ekr, must, (0, ruudustiku_vahe * i), (ekr_y, ruudustiku_vahe * i), 1)
            else:
                pg.draw.line(ekr, hall, (ruudustiku_vahe * i, 0), (ruudustiku_vahe * i, ekr_y), 1)
                pg.draw.line(ekr, hall, (0, ruudustiku_vahe * i), (ekr_y, ruudustiku_vahe * i), 1)

        for i in range(int(ekr_y / ruudustiku_vahe)):
            if (i - int(ekr_y / ruudustiku_vahe / 2)) % 3 == 0 and i - int(ekr_y / ruudustiku_vahe / 2) != 0:
                pg.draw.line(ekr, must, (ruudustiku_vahe * i, ekr_y / 2 - ruudustiku_vahe + 1), (ruudustiku_vahe * i, ekr_y / 2 - 2), 1)
                pg.draw.line(ekr, must, (ekr_y / 2 - ruudustiku_vahe + 1, ruudustiku_vahe * i), (ekr_y / 2 - 2, ruudustiku_vahe * i), 1)
                tekst = väike_font.render(str(i - int(ekr_y / ruudustiku_vahe / 2)), 1, must)
                ekr.blit(tekst, (ruudustiku_vahe * i - tekst.get_width() / 2, int(ekr_y / 2) - ruudustiku_vahe + tekst.get_height() / 2))
                tekst2 = väike_font.render(str(-i + int(ekr_y / ruudustiku_vahe / 2)), 1, must)
                ekr.blit(tekst2, (int(ekr_y / 2) - ruudustiku_vahe + 10, ruudustiku_vahe * i - tekst.get_height() / 2))
        tekst_null = väike_font.render("0", 1, must)
        ekr.blit(tekst_null, (int(ekr_y / 2) - 15, int(ekr_y / 2) - 5))

        konst = ruudustiku_vahe * int(ekr_y / ruudustiku_vahe)
        pg.draw.line(ekr, hall, (konst + 1, 0), (konst + 1, ekr_y), 2)
        pg.draw.line(ekr, hall, (0, konst), (ekr_y, konst), 2)

        for kast in input_kastid:
            kast.joonista(ekr)

        try:
            if (input_kastid[0].tekst and float(input_kastid[0].tekst) != 0.0):
                vastused = lahenda(
                    float(input_kastid[0].tekst),
                    float(input_kastid[1].tekst) if input_kastid[1].tekst else 0.0,
                    float(input_kastid[2].tekst) if input_kastid[2].tekst else 0.0
                )
                if (vastused != "neg_root"):
                    if (vastused[0] == "single"):
                        ekr.blit(font.render("lahend: " + str(vastused[1] if vastused[1] != 0.0 else str(vastused[1])[1:]), 1, sinine), (ekr_y + 15, 140))
                    else:
                        ekr.blit(font.render("1. lahend: " + str(vastused[0]), 1, sinine), (ekr_y + 15, 140))
                        ekr.blit(font.render("2. lahend: " + str(vastused[1]), 1, sinine), (ekr_y + 15, 165))
                else:
                     ekr.blit(font.render("reaalarvulised lahendid puuduvad", 1, punane), (ekr_y + 15, 140))

                joonista_graafik(
                    float(input_kastid[0].tekst),
                    float(input_kastid[1].tekst) if input_kastid[1].tekst else 0.0,
                    float(input_kastid[2].tekst) if input_kastid[2].tekst else 0.0
                )
            else:
                ekr.blit(font.render("tegemist ei ole ruutfunktsiooniga", 1, punane), (ekr_y + 15, 140))
        except ValueError:
            pass

        pg.display.flip()

        kell.tick(10)

if __name__ == "__main__":
    main()
    pg.quit()