import pygame as pg
import pymunk.pygame_util
from pygame.locals import *
from random import uniform, randrange
from sys import exit as sysexit

pymunk.pygame_util.positive_y_is_up = False

WIDTH, HEIGHT = 1280, 720
FPS = 60

# объявление всего необходимого
pg.init()

display = pg.display.set_mode((WIDTH, HEIGHT), pg.RESIZABLE)
pg.display.set_caption("Мячики с физикой на PyGame + Pymunk")
clock = pg.time.Clock()
draw_option = pymunk.pygame_util.DrawOptions(display)

space = pymunk.Space()
space.gravity = 0, 2000

""" объекты """
# платформы
segment_shape = pymunk.Segment(space.static_body, (0, HEIGHT + 35), (WIDTH + 10000, HEIGHT + 35), 50)
segment_shape.elasticity = 0.5
segment_shape.friction = 0.5
space.add(segment_shape)

verifyLimitCreation = False
temp = []


def createWindowLimits(create):
    global temp
    global verifyLimitCreation
    if create:
        temp = []
        verifyLimitCreation = True
        segment_shape = pymunk.Segment(space.static_body, (-35, 0), (-35, pg.display.get_window_size()[1]), 50)
        segment_shape.elasticity = 0.5
        segment_shape.friction = 0.5
        temp.append(segment_shape)

        segment_shape = pymunk.Segment(space.static_body, (pg.display.get_window_size()[0] + 35, 0),
                                       (pg.display.get_window_size()[0] + 35, pg.display.get_window_size()[1]), 50)
        segment_shape.elasticity = 0.5
        segment_shape.friction = 0.5
        temp.append(segment_shape)

        segment_shape = pymunk.Segment(space.static_body, (0, 0 - 35), (pg.display.get_window_size()[0], 0 - 35), 50)
        segment_shape.elasticity = 0.5
        segment_shape.friction = 0.5
        temp.append(segment_shape)
        for i in temp:
            space.add(i)
    else:
        for i in temp:
            space.remove(i)
        verifyLimitCreation = False


# создать мячик
ball_arr = []
ball_size = 10
ballSize_font = pg.font.SysFont('serif', 18)
ballSize_fontRender = ballSize_font.render(f"Размер мячиков: {ball_size}(↑ or ↓)", True, (0, 0, 0))
placePos_ballSizeFont = ballSize_fontRender.get_rect(topleft=(5, 18))

ball_elasticity = 0.5
ballElasticity_font = pg.font.SysFont('serif', 18)
ballElasticity_fontRender = ballElasticity_font.render(f"Коэф. упругости мячиков: {ball_elasticity}(F1 or F2)", True,
                                                       (0, 0, 0))
placePos_ballElasticityFont = ballElasticity_fontRender.get_rect(topleft=(5, 36))

ball_friction = 0.5
ballFriction_font = pg.font.SysFont('serif', 18)
ballFriction_fontRender = ballFriction_font.render(f"Трение мячиков: {ball_friction}(F3 or F4)", True, (0, 0, 0))
placePos_ballFrictionFont = ballFriction_fontRender.get_rect(topleft=(5, 54))

ball_mass = 1
ballMass_font = pg.font.SysFont('serif', 18)
ballMass_fontRender = ballMass_font.render(f"Масса мячиков: {ball_mass}(F5 or F6)", True, (0, 0, 0))
placePos_ballMassFont = ballMass_fontRender.get_rect(topleft=(5, 72))


def createBall(mass, radius, position, elasticity, friction, color):
    ball_mass, ball_radius = mass, radius
    ball_moment = pymunk.moment_for_circle(ball_mass, 0, ball_radius)
    ball_body = pymunk.Body(ball_mass, ball_moment)
    ball_body.position = position
    ball_shape = pymunk.Circle(ball_body, ball_radius)
    ball_shape.elasticity = elasticity
    ball_shape.friction = friction
    ball_shape.color = color
    space.add(ball_body, ball_shape)
    ball_arr.append(ball_body)
    ball_arr.append(ball_shape)


# статическая линия для рисования платформ
painter_line_arr = []
# painter_line_arrTemp - нужен для запоминания удалённых объектов для их возвращения на сцену
painter_line_arrTemp = []
painter_line_size = 10
painter_line_font = pg.font.SysFont('serif', 18)
painter_line_fontRender = painter_line_font.render(f"Размер кисти препятствий: {painter_line_size}(→ or ←)", True,
                                                   (0, 0, 0))
placePos_painter_ballFont = painter_line_fontRender.get_rect(topleft=(5, 0))

# вот тут вот я РАНЬШЕ не понимал, в чём проблема и как заставить это работать(сейчас это работает)
lastMousePos = None
mousePressed = False


def createPainterLine(radius, singleClickVerify):
    if singleClickVerify == False:
        segment_shape = pymunk.Segment(space.static_body, lastMousePos,
                                       (pg.mouse.get_pos()[0], pg.mouse.get_pos()[1]), radius)
        segment_shape.elasticity = 0.4
        segment_shape.friction = 0.5
        space.add(segment_shape)
        painter_line_arr.append(segment_shape)
    else:
        segment_shape = pymunk.Segment(space.static_body, lastMousePos,
                                       (pg.mouse.get_pos()[0] + 1, pg.mouse.get_pos()[1] + 1), radius)
        segment_shape.elasticity = 0.4
        segment_shape.friction = 0.5
        space.add(segment_shape)
        painter_line_arr.append(segment_shape)


def deletePainterLine():
    for i in range(0, len(painter_line_arr)):
        space.remove(painter_line_arr[i])
    painter_line_arr.clear()


def deleteBalls():
    for i in range(0, len(ball_arr)):
        space.remove(ball_arr[i])
    ball_arr.clear()


def deleteRectangles():
    for i in range(0, len(rectangle_arr)):
        space.remove(rectangle_arr[i])
    rectangle_arr.clear()


# надпись с FPS
fps_font = pg.font.SysFont('serif', 18)
fps_fontRender = fps_font.render(f"FPS = {round(clock.get_fps(), 2)}", True, (0, 0, 0))
display_rect = display.get_rect()
placePos_fps_font = painter_line_fontRender.get_rect(topright=(pg.display.get_window_size()[0] + 220, 0))

# создать прямоугольник
rectangle_arr = []
rectangle_mass = 1
rectangle_width = 30
rectangle_height = 30
rectangle_elasticity = 0.5
rectangle_friction = 0.5

rect_font = pg.font.SysFont('serif', 18)
rectWidth_fontRender = rect_font.render(f"Ширина прямоугольников: {rectangle_width}(F7 or F8)", True, (0, 0, 0))
placePos_rectWidthFont = rectWidth_fontRender.get_rect(topleft=(320, 0))

rect_font = pg.font.SysFont('serif', 18)
rectHeight_fontRender = rect_font.render(f"Высота прямоугольников: {rectangle_height}(F9 or F10)", True, (0, 0, 0))
placePos_rectHeightFont = ballSize_fontRender.get_rect(topleft=(320, 18))


def CreateRectangle(rectangle_mass, pos, rectangle_height, rectagle_width, rectangle_elasticity, rectangle_friction):
    square_mass, square_size = rectangle_mass, (rectagle_width, rectangle_height)
    square_moment = pymunk.moment_for_box(square_mass, square_size)
    square_body = pymunk.Body(square_mass, square_moment)
    square_body.position = pos
    square_shape = pymunk.Poly.create_box(square_body, square_size)
    square_shape.elasticity = rectangle_elasticity
    square_shape.friction = rectangle_friction
    square_shape.color = [randrange(256) for i in range(4)]
    rectangle_arr.append(square_shape)
    space.add(square_body, square_shape)

# надпись гравитации
gravity = True
gravity_font = pg.font.SysFont('serif', 18)
gravity_fontRender = rect_font.render(f"Гравитация: {gravity}(G)", True, (0, 0, 0))
placePos_Gravityfont = gravity_fontRender.get_rect(topright=(pg.display.get_window_size()[0] - 5, 18))


while True:
    display.fill((0, 160, 90))

    mouseKeys = pg.mouse.get_pressed()
    keyboardKeys = pg.key.get_pressed()

    for event in pg.event.get():
        if event.type == pg.QUIT:
            sysexit()
        elif event.type == pg.MOUSEBUTTONUP:
            mousePressed = False
            f1pressed = False
        elif event.type == pg.MOUSEBUTTONDOWN:
            if event.button == 1:
                createBall(ball_mass, ball_size, pg.mouse.get_pos(), ball_elasticity, ball_friction,
                           [uniform(0, 255) for i in range(4)])
            elif event.button == 3:
                singleClickVerify = True
                lastMousePos = pg.mouse.get_pos()
                createPainterLine(painter_line_size, singleClickVerify)
                mousePressed = True
            elif event.button == 2:
                deletePainterLine()
                deleteBalls()
                deleteRectangles()
        elif event.type == pg.MOUSEMOTION:
            if mousePressed == True:
                singleClickVerify = False
                createPainterLine(painter_line_size, singleClickVerify)
                lastMousePos = pg.mouse.get_pos()
        elif event.type == pg.WINDOWSIZECHANGED:
            placePos_Gravityfont = gravity_fontRender.get_rect(topright=(pg.display.get_window_size()[0] - 5, 18))
            placePos_fps_font = painter_line_fontRender.get_rect(topright=(pg.display.get_window_size()[0] + 220, 0))
            space.remove(segment_shape)
            segment_shape = pymunk.Segment(space.static_body, (1, pg.display.get_window_size()[1] + 35),
                                           (pg.display.get_window_size()[0], pg.display.get_window_size()[1] + 35), 50)
            segment_shape.elasticity = 0.5
            segment_shape.friction = 0.5
            space.add(segment_shape)

            if verifyLimitCreation:
                for i in temp:
                    space.remove(i)
                createWindowLimits(True)
        elif event.type == pg.KEYDOWN:
            if event.key == pg.K_RIGHT:

                painter_line_size += 1
                painter_line_fontRender = painter_line_font.render(
                    f"Размер кисти препятствий: {painter_line_size}(→ or ←)", True,
                    (0, 0, 0))

            elif event.key == K_LEFT:
                painter_line_size -= 1
                painter_line_fontRender = painter_line_font.render(
                    f"Размер кисти препятствий: {painter_line_size}(→ or ←)", True,
                    (0, 0, 0))

            elif event.key == K_UP:
                ball_size += 1
                ballSize_fontRender = ballSize_font.render(f"Размер мячиков: {ball_size}(↑ or ↓)", True, (0, 0, 0))
            elif event.key == K_DOWN:
                ball_size -= 1
                ballSize_fontRender = ballSize_font.render(f"Размер мячиков: {ball_size}(↑ or ↓)", True, (0, 0, 0))
            elif event.key == K_F1:
                f1pressed = True
                temp_elasticity = ball_elasticity
                temp_elasticity += 0.1
                ball_elasticity = round(temp_elasticity, 2)
                ballElasticity_fontRender = ballElasticity_font.render(
                    f"Коэф. упругости мячиков: {ball_elasticity}(F1 or F2)", True, (0, 0, 0))
            elif event.key == K_F2:
                temp_elasticity = ball_elasticity
                temp_elasticity -= 0.1
                ball_elasticity = round(temp_elasticity, 2)
                ballElasticity_fontRender = ballElasticity_font.render(
                    f"Коэф. упругости мячиков: {ball_elasticity}(F1 or F2)", True, (0, 0, 0))
                del temp_elasticity
            elif event.key == K_F5:
                temp_mass = ball_mass
                temp_mass += 0.1
                ball_mass = round(temp_mass, 2)
                ballMass_fontRender = ballMass_font.render(f"Масса мячиков: {ball_mass}(F5 or F6)", True,
                                                           (0, 0, 0))
                del temp_mass
            elif event.key == K_F6:
                temp_mass = ball_mass
                if temp_mass != 0.1:
                    temp_mass -= 0.1
                    ball_mass = round(temp_mass, 2)
                    ballMass_fontRender = ballMass_font.render(f"Масса мячиков: {ball_mass}(F5 or F6)", True,
                                                               (0, 0, 0))
                    del temp_mass
                else:
                    pass
            elif event.key == K_F3:
                temp_friction = ball_friction
                temp_friction += 0.1
                ball_friction = round(temp_friction, 2)
                ballFriction_fontRender = ballFriction_font.render(f"Трение мячиков: {ball_friction}(F3 or F4)", True,
                                                                   (0, 0, 0))
                del temp_friction
            elif event.key == K_F4:
                temp_friction = ball_friction
                temp_friction -= 0.1
                ball_friction = round(temp_friction, 2)
                ballFriction_fontRender = ballFriction_font.render(f"Трение мячиков: {ball_friction}(F3 or F4)", True,
                                                                   (0, 0, 0))
                del temp_friction
            elif event.key == K_F7:
                rectangle_width += 1
                rectWidth_fontRender = rect_font.render(f"Ширина прямоугольников: {rectangle_width}(F7 or F8)", True,
                                                        (0, 0, 0))
            elif event.key == K_F8:
                rectangle_width -= 1
                rectWidth_fontRender = rect_font.render(f"Ширина прямоугольников: {rectangle_width}(F7 or F8)", True,
                                                        (0, 0, 0))
            elif event.key == K_F9:
                rectangle_height += 1
                rectHeight_fontRender = rect_font.render(f"Высота прямоугольников: {rectangle_height}(F9 or F10)", True,
                                                         (0, 0, 0))
            elif event.key == K_F10:
                rectangle_height -= 1
                rectHeight_fontRender = rect_font.render(f"Высота прямоугольников: {rectangle_height}(F9 or F10)", True,
                                                         (0, 0, 0))
            elif event.key == K_l:
                if verifyLimitCreation == False:
                    createWindowLimits(True)
                else:
                    createWindowLimits(False)
            elif event.key == K_r:
                CreateRectangle(rectangle_mass, pg.mouse.get_pos(), rectangle_height, rectangle_width, ball_elasticity, ball_friction)
            elif event.key == K_g:
                if gravity:
                    space.gravity = 0, 0
                    gravity = False
                    gravity_fontRender = rect_font.render(f"Гравитация: {gravity}(G)", True, (0, 0, 0))
                else:
                    space.gravity = 0, 2000
                    gravity = True
                    gravity_fontRender = rect_font.render(f"Гравитация: {gravity}(G)", True, (0, 0, 0))

    if mouseKeys[0] and keyboardKeys[K_LSHIFT]:
        createBall(ball_mass, ball_size, pg.mouse.get_pos(), ball_elasticity, ball_friction,
                   [uniform(0, 255) for i in range(4)])

    elif keyboardKeys[K_r] and keyboardKeys[K_LSHIFT]:
        pass
    if keyboardKeys[K_LCTRL] and keyboardKeys[K_z] and not keyboardKeys[K_LSHIFT]:
        try:
            space.remove(painter_line_arr[-1])
            painter_line_arrTemp.append(painter_line_arr[-1])
            painter_line_arr.pop(-1)
        except IndexError:
            painter_line_arrTemp.clear()
            pass
    if keyboardKeys[K_LCTRL] and keyboardKeys[K_z] and keyboardKeys[K_LSHIFT]:
        try:
            space.add(painter_line_arrTemp[-1])
            painter_line_arr.append(painter_line_arrTemp[-1])
            painter_line_arrTemp.pop(-1)
        except:
            pass
    space.step(1 / FPS)
    space.debug_draw(draw_option)

    display.blit(rectWidth_fontRender, placePos_rectWidthFont)
    display.blit(rectHeight_fontRender, placePos_rectHeightFont)

    display.blit(painter_line_fontRender, placePos_painter_ballFont)
    display.blit(ballSize_fontRender, placePos_ballSizeFont)
    display.blit(ballElasticity_fontRender, placePos_ballElasticityFont)
    display.blit(ballMass_fontRender, placePos_ballMassFont)
    display.blit(ballFriction_fontRender, placePos_ballFrictionFont)

    display.blit(fps_fontRender, placePos_fps_font)
    display.blit(gravity_fontRender, placePos_Gravityfont)

    pg.display.flip()
    clock.tick(FPS)

    fps_fontRender = fps_font.render(f"FPS: {round(clock.get_fps(), 2)}", True, (0, 0, 0))