import sys
from abc import ABC, abstractmethod
from math import cos, sin, pi

import pygame

aqua      = (  0, 255, 255)   # морская волна
black     = (  0,   0,   0)   # черный
blue      = (  0,   0, 255)   # синий
fuchsia   = (255,   0, 255)   # фуксия
gray      = (128, 128, 128)   # серый
green     = (  0, 128,   0)   # зеленый
lime      = (  0, 255,   0)   # цвет лайма
maroon    = (128,   0,   0)   # темно-бордовый
navy_blue = (  0,   0, 128)   # темно-синий
olive     = (128, 128,   0)   # оливковый
purple    = (128,   0, 128)   # фиолетовый
red       = (255,   0,   0)   # красный
silver    = (192, 192, 192)   # серебряный
teal      = (  0, 128, 128)   # зелено-голубой
white     = (255, 255, 255)   # белый
yellow    = (255, 255,   0)   # желтый

class Color:
    RED = (255, 0, 0)
    GREEN = (0, 255, 0)


class PG:
    _instance = None

    def __init__(self, width=500, height=400):
        if PG._instance is not None:  # singleton implementation
            raise ReferenceError('Tying to create singleton object twice')
        else:
            PG._instance = self
        pygame.init()
        self.screen = pygame.display.set_mode((width, height))
        self.width = width
        self.height = height

    @staticmethod
    def get():
        if not PG._instance:
            PG()
        return PG._instance


class PGScene(ABC):
    bgcolor = (0, 0, 0)

    def __init__(self):
        self.screen = PG.get().screen
        self.sceneover = False
        self.objects = []

    def draw(self):
        self.screen.fill(self.bgcolor)
        for item in self.objects:
            item.draw()

    def process_events(self):
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                self.sceneover = True
            self.process_event(event)

    def process_event(self, event):
        pass


    @abstractmethod
    def process_logic(self):
        for item in self.objects:
            item.logic()

    def main_loop(self):
        while not self.sceneover:
            self.process_events()
            self.process_logic()
            self.draw()
            pygame.display.flip()
            pygame.time.wait(10)


class Command(ABC):
    def __init__(self, scene):
        self.scene = scene

    @abstractmethod
    def execute(self, scene):
        pass


class UpCommand(Command):
    def execute(self, scene):
        self.scene.panzer.moveForward()
        self.scene.buttons['up'].set_enabled(True)
        self.scene.buttons['down'].set_enabled(False)
        scene.text.text = "движение вперёд"



class DownCommand(Command):
    def execute(self, scene):
        self.scene.panzer.moveBackwards()
        self.scene.buttons['down'].set_enabled(True)
        self.scene.buttons['up'].set_enabled(False)
        scene.text.text = "движение назад"


class LeftCommand(Command):
    def execute(self, scene):
        self.scene.panzer.rotate(-0.05)
        self.scene.buttons['left'].set_enabled(True)
        self.scene.buttons['right'].set_enabled(False)
        scene.text.text = "поворот влево"


class RightCommand(Command):
    def execute(self, scene):
        self.scene.panzer.rotate(0.05)
        self.scene.buttons['right'].set_enabled(True)
        self.scene.buttons['left'].set_enabled(False)
        scene.text.text = "поворот вправо"

class UpCommandReleased(Command):
    def execute(self, scene):
        self.scene.panzer.stop()
        self.scene.buttons['up'].set_enabled(False)
        scene.text.text = "нет движения"


class DownCommandReleased(Command):
    def execute(self, scene):
        self.scene.panzer.stop()
        self.scene.buttons['down'].set_enabled(False)
        scene.text.text = "нет движения"


class LeftCommandReleased(Command):
    def execute(self, scene):
        self.scene.panzer.stop_rotation()
        self.scene.buttons['left'].set_enabled(False)
        scene.text.text = "нет движения"


class RightCommandReleased(Command):
    def execute(self, scene):
        self.scene.panzer.stop_rotation()
        self.scene.buttons['right'].set_enabled(False)
        scene.text.text = "нет движения"


class GameScene(PGScene):
    keydown_events = {
        pygame.K_w: UpCommand,
        pygame.K_s: DownCommand,
        pygame.K_a: LeftCommand,
        pygame.K_d: RightCommand,
    }

    keyup_events = {
        pygame.K_w: UpCommandReleased,
        pygame.K_s: DownCommandReleased,
        pygame.K_a: LeftCommandReleased,
        pygame.K_d: RightCommandReleased,
    }

    def __init__(self):
        super().__init__()
        self.panzer = Panzer(200, 200)
        self.text = Text('нет движения', 50, 480)
        self.buttons = {
            'up': StateRect(100, 500, 20, 20, Color.GREEN, Color.RED),
            'down': StateRect(100, 530, 20, 20, Color.GREEN, Color.RED),
            'left': StateRect(70, 530, 20, 20, Color.GREEN, Color.RED),
            'right': StateRect(130, 530, 20, 20, Color.GREEN, Color.RED),
        }
        self.objects.append(self.panzer)
        self.objects.append(self.text)
        self.objects += self.buttons.values()

    def process_logic(self):
        super().process_logic()

    def process_event(self, event):
        if event.type == pygame.KEYDOWN and event.key in GameScene.keydown_events.keys():
            GameScene.keydown_events[event.key](self).execute(self)
        if event.type == pygame.KEYUP and event.key in GameScene.keyup_events.keys():
            GameScene.keyup_events[event.key](self).execute(self)


class PGObject(ABC):
    def __init__(self):
        self.screen = PG.get().screen

    @abstractmethod
    def draw(self):
        pass

    def logic(self):
        pass


class Panzer(PGObject):
    def __init__(self, x, y):
        super().__init__()
        self.rotated_image = self.image = pygame.image.load("panzer.png")
        self.rotated_rect = self.rect = self.image.get_rect()
        self.x = x
        self.y = y
        self.direction = 0
        self.speed = 0
        self.max_speed = 1
        self.rotation_angle = 0

    def draw(self):
        self.rect.x = self.x - self.rect.width // 2
        self.rect.y = self.y - self.rect.height // 2
        self.rotated_rect = self.rotated_image.get_rect(center=self.rect.center)
        self.screen.blit(self.rotated_image, self.rotated_rect)

    def moveForward(self):
        self.speed = self.max_speed

    def moveBackwards(self):
        self.speed = -self.max_speed

    def stop(self):
        self.speed = 0

    def step(self):
        self.x += cos(self.direction) * self.speed
        self.y += sin(self.direction) * self.speed
        self.direction += self.rotation_angle
        self.rotated_image = pygame.transform.rotate(self.image, -self.direction / pi * 180)
        self.rotated_rect = self.rotated_image.get_rect(center=self.rect.center)

    def rotate(self, angle):
        self.rotation_angle = angle

    def stop_rotation(self):
        self.rotation_angle = 0

    def logic(self):
        self.step()


class StateRect(PGObject):
    def __init__(self, x, y, width, height, color_enabled, color_disabled):
        super().__init__()
        self.rect = (x, y, width, height)
        self.color_enabled = color_enabled
        self.color_disabled = color_disabled
        self.enabled = False

    def draw(self):
        color = self.color_enabled if self.enabled else self.color_disabled,
        pygame.draw.rect(self.screen, color, self.rect, 0)

    def set_enabled(self, enabled):
        self.enabled = enabled

class Text(PGObject):
    def __init__(self, text, x, y):
        super().__init__()
        self.x = x
        self.y = y
        self.text = text

    def draw(self):
        font = pygame.font.Font(None, 20)
        text = font.render(self.text, True, white)
        self.screen.blit(text, [self.x,self.y])


if __name__ == "__main__":
    PG(800, 600)
    gs = GameScene()
    gs.main_loop()
    sys.exit()