from sympy.solvers import solve
from sympy import Symbol
import numpy as np
import matplotlib.pyplot as plt

def maksymalnaWysokosc(voy, g):
    hmax = (voy**2)/(2*g)

    return round(hmax, 3)

def czasCalkowity(voy, g):
    tC = (2 * voy) / g

    return tC

def czasLotu(pkX, vox, dzialo):
    czasLotu = (pkX - dzialo[0])/vox

    return czasLotu

def wyznaczKierunekStrzalu(vox):
    if vox >= 0:
        kierunekStrzalu = 'prawo'
    else:
        kierunekStrzalu = 'lewo'

    return kierunekStrzalu

def polozeniaPociskuOdCzasu(tL, czasy, dzialo, vox, voy, g):
    polozeniaPocisku = []
    for t in czasy:
        if t<=tL:
            pociskX = vox*t + dzialo[0]
            pociskY = voy*t - (g*t**2)/2 + dzialo[1]
            polozeniaPocisku.append((round(pociskX, 3), round(pociskY, 3)))
        else:
            polozeniaPocisku.append((0, 0))

    return polozeniaPocisku

def predkosciPociskuodCzasu(tL, tC, czasy, vox, voy, g):
    predkosciPocisku = []
    for t in czasy:
        if t<=tL:
            if t <= 0.5 * tC:
                vX = vox
                vY = -g * t + voy
            else:
                vX = vox
                vY = g * (t - 0.5 * tC)
            predkosciPocisku.append((round(vX, 3), round(vY, 3)))
        else:
            predkosciPocisku.append((0, 0))

    return predkosciPocisku

def czyPociskTrafiłWCel(polozenieKoncowePocisku, cel):
    if abs(polozenieKoncowePocisku[0] - cel[0]) <= 0.05 and abs(polozenieKoncowePocisku[1] - cel[1]) <= 0.05:
        return 1
    else:
        return 0

def rozkladFunkcjiTerenu(terenString):
    terenString = terenString.split()

    if terenString[0][0] != "-":
        terenString.insert(0, "+")

    indeks = 0
    wyrazenie = []
    znak = []
    for tekst in terenString:
        if indeks%2 != 0:
            wyrazenie.append(tekst)
        else:
            znak.append(tekst)
        indeks += 1

    terenPodzielony = []
    for numer, wyraz in enumerate(wyrazenie):
        wyraz = wyraz.split("x")

        # sytuacja x^0
        if len(wyraz) == 1:
            wyraz.append('^0')

        # sytuacja x^1
        if wyraz[0] == '':
            wyraz[0] = '1.0'

        # sytaucja a * x^1
        if len(wyraz) == 2:
            if wyraz[1] == '':
                wyraz[1] = '^1'

        rozdzielonyWyraz = ([znak[numer], wyraz[0], wyraz[1][1]])
        terenPodzielony.append(rozdzielonyWyraz)

    return terenPodzielony

def zmianaTypuFunkcjiTerenu(terenPodzielony):
    x = Symbol('x', real=True)
    terenRownanie = 0
    for wyraz in terenPodzielony:

        wyraz[1] = float(wyraz[1])
        wyraz[2] = int(wyraz[2])

        if wyraz[0] == '-':
            wyraz[1] *= (-1)

        terenRownanie += wyraz[1] * x**wyraz[2]

    return terenRownanie

def wyznaczRownaniePolozeniaPocisku(vox, voy, g, dzialo):
    x = Symbol('x', real=True)
    rownaniePolozeniaPocisku = (voy/vox)*(x - dzialo[0]) - (g/(2*vox**2))*(x - dzialo[0])**2 + dzialo[1]

    return rownaniePolozeniaPocisku

def polozenieKoncowePociskuX(rownaniePolozeniaPocisku, terenRownanie, kierunekStrzalu):
    x = Symbol('x', real=True)
    PolozeniaKoncowegoPociskuX = solve(rownaniePolozeniaPocisku - terenRownanie, x)
    if kierunekStrzalu == 'prawo':
        return PolozeniaKoncowegoPociskuX[1]
    else:
        return PolozeniaKoncowegoPociskuX[-2]

def polozenieKoncowePocisku(pkX, vox, voy, g, dzialo):
    polozenieKoncowePociskuY = (voy/vox) * (pkX - dzialo[0]) - (g/(2*vox**2))*(pkX - dzialo[0])**2 + dzialo[1]

    return pkX, polozenieKoncowePociskuY

def zmianaFormatuDanych(wyraz):
    wyraz = wyraz.split(', ')
    wyraz1 = wyraz[0][1:]
    wyraz2 = wyraz[1][:-1]

    return float(wyraz1), float(wyraz2)

def pobranieDanych(linia):
    linia = linia.split('; ')

    # współrzędne działa
    dzialo = zmianaFormatuDanych(linia[0])
    # print("Działo: ", dzialo[0], dzialo[1])

    # współrzędne celu
    cel = zmianaFormatuDanych(linia[1])
    # print("Cel: ", cel[0], cel[1])

    # wektor prędkości początkowej
    voox, vooy = zmianaFormatuDanych(linia[2])
    # print("Prędkość początkowa: ", voox, vooy)

    # wiatr
    wx, wy = zmianaFormatuDanych(linia[3])
    # print("Wiatr: ", wx, wy)

    # czasy
    czasy = []
    czasy.append(float(linia[4]))
    czasy.append(float(linia[5]))
    czasy.append(float(linia[6]))
    # print("Czasy: ", czasy)

    # funkcja definiująca ukształtowanie terenu
    terenString = linia[7]
    # print("funkcja definiująca ukształtowanie terenu: ", terenString)

    return dzialo, cel, voox, vooy, wx, wy, czasy, terenString

def punktyNaWykresie(dzialo, cel, pkPocisku):
    plt.plot(dzialo[0], dzialo[1], "*", markerfacecolor="#f20068", markeredgecolor="#990064",
             markersize=15, zorder=10, label="Działo")
    plt.plot(cel[0], cel[1], "^", markerfacecolor="#ff0000", markeredgecolor="#ab0000", markersize=15, zorder=10, label="Cel")

    plt.plot(pkPocisku[0], pkPocisku[1], "*", markerfacecolor="#abbf00", markeredgecolor="#6eb503", markersize=20, zorder=10, label="Punkt uderzenia")

def trajektoriaLotuNaWykresie(dzialo, vox, voy, g, pkPocisku, hmax):
    x = np.arange(dzialo[0], pkPocisku[0], 0.001)
    rownanie = (voy/vox)*(x - dzialo[0]) - (g/(2*vox**2))*(x - dzialo[0])**2 + dzialo[1]
    plt.plot(x, rownanie)


def terenNaWykresie(dzialo, cel, pkPocisku, terenString):
    x = np.arange(dzialo[0]-0.2, max(cel[0], pkPocisku[0])+0.2, 0.001)
    # zawał
    terenPodzielony = rozkladFunkcjiTerenu(terenString)
    terenRownanie = zmianaTypuFunkcjiTerenu(terenPodzielony)

    plt.plot(x, 0.3*x**4 + 0.2*x**3 - 0.3*x**2 + 0.2)
    # plt.plot(x, terenRownanie)
    # przerwa w zawale

def wizualizacjaWykresow(dzialo, cel, pkPocisku, vox, voy, g, hmax, terenString):

    punktyNaWykresie(dzialo, cel, pkPocisku)
    trajektoriaLotuNaWykresie(dzialo, vox, voy, g, pkPocisku, hmax)
    terenNaWykresie(dzialo, cel, pkPocisku, terenString)

    plt.ylim(top=1.5 * hmax)

    xlimMAX =  round(max(cel[0], pkPocisku[0])+0.2, 2)
    plt.xlim(dzialo[0]-0.2, xlimMAX)

    OX = plt.gca()
    OX.legend()

    plt.show()




def przygotujDaneWyjsciowe(pkPocisku, hmax, predkosciPocisku, hit):
    liniaWyjsciowa = ""

    liniaWyjsciowa += "(" + str(round(pkPocisku[0], 3)) + ", " + str(round(pkPocisku[1], 3)) + "); "
    liniaWyjsciowa += str(hmax) + "; "
    liniaWyjsciowa += "("

    for i in range(0, 3):
        liniaWyjsciowa += "[" + str(predkosciPocisku[i][0]) + ", " + str(predkosciPocisku[i][1]) + "]"
        if i != 2:
            liniaWyjsciowa += ", "
    liniaWyjsciowa += "); " + str(hit) + "\n"
    return liniaWyjsciowa

def main():
    g = 9.81

    with open("input.txt", "r") as plik_input:
        with open("output.txt", "w+") as plik_output:
            for linia in plik_input:
                dzialo, cel, voox, vooy, wx, wy, czasy, terenString = pobranieDanych(linia)

                vox, voy = voox + wx, vooy + wy
                kierunekStrzalu = wyznaczKierunekStrzalu(vox)

                rownaniePolozeniaPocisku = wyznaczRownaniePolozeniaPocisku(vox, voy, g, dzialo)
                terenPodzielony = rozkladFunkcjiTerenu(terenString)
                terenRownanie = zmianaTypuFunkcjiTerenu(terenPodzielony)

                pkX = polozenieKoncowePociskuX(rownaniePolozeniaPocisku, terenRownanie, kierunekStrzalu)
                tC = czasCalkowity(voy, g)
                tL = czasLotu(pkX, vox, dzialo)
                hmax = maksymalnaWysokosc(voy, g)
                predkosciPocisku = predkosciPociskuodCzasu(tL, tC, czasy, vox, voy, g)
                pkPocisku = polozenieKoncowePocisku(pkX, vox, voy, g, dzialo)
                hit = czyPociskTrafiłWCel(pkPocisku, cel)



                # punktyNaWykresie(dzialo, cel, pkPocisku)
                # trajektoriaLotuNaWykresie(dzialo, vox, voy, g, pkPocisku, hmax)
                # terenNaWykresie(dzialo, pkPocisku, terenString)
                # plt.show()

                wyjciowaLinia = przygotujDaneWyjsciowe(pkPocisku, hmax, predkosciPocisku, hit)
                # print(wyjciowaLinia)
                # plik_output.write

                wizualizacjaWykresow(dzialo, cel, pkPocisku, vox, voy, g, hmax, terenString)



main()