from dataclasses import dataclass
from typing import *

@dataclass
class Len:
    px: int = 0
    perc: int = 0
    
    def __add__(self, other):
        return Len(self.px + other.px, self.perc + other.perc)
        
@dataclass
class Pos:
    x: int = 0
    y: int = 0
    
    def __add__(self, other):
        return Pos(self.x + other.x, self.y + other.y)
        
@dataclass
class Trans:
    base: Pos = Pos()
    delta: Pos = Pos()
    size: Pos = Pos()
    scale: Pos = Pos(1, 1)
    
    def get_size(self, x, y):
        x = (x.perc * self.size.x)/100 + x.px
        y = (y.perc * self.size.y)/100 + y.px
        return x * self.scale.x, y * self.scale.y
        
    def get_local(self, x, y):
        x, y = self.get_size(x, y)
        return x + self.delta.x, y + self.delta.y
        
    def get_global(self, x, y):
        x, y = self.get_local(x, y)
        return x + self.base.x, y + self.base.y
        
class Graphics:
    def __post_init__(self):
        self.border = None
        self.trans = Trans()
        
    def render(self, render, local = False):
        pos = self.to_local() if local else self.to_global()
        method = getattr(render, type(self).__name__)
        method(pos=pos, col=self.color, border=self.border)
    
    def mouse_at(self, x, y, mouse_type):
        name = f"on_{mouse_type}"
        if not self.is_inside(x, y):
            name = f"{name}_out"
        if hasattr(self, name):
            getattr(self, name)(x, y)
            
    def key_at(self, key, key_type):
        if hasattr(self, f"on_key_{key_type}"):
            getattr(self, f"on_key_{key_type}")(key)
        if hasattr(self, f"on_{key}_{key_type}"):
            getattr(self, f"on_{key}_{key_type}")()
      
@dataclass
class Rect(Graphics):
    x: int
    y: int
    width: int
    height: int
    color: str
    
    def move(self, x, y):
        self.x = self.x + x
        self.y = self.y + y
        
    def addsize(self, width, height):
        self.width = self.width + width
        self.height = self.height + height
        
    def to_local(self):
        pos = self.trans.get_local(self.x, self.y)
        size = self.trans.get_size(self.width, self.height)
        return [pos, size]
        
    def to_global(self):
        pos = self.trans.get_global(self.x, self.y)
        size = self.trans.get_size(self.width, self.height)
        return [pos, size]
        
    def is_inside(self, x, y):
        pos = self.to_global()
        x_proj = pos[0][0] <= x <= pos[0][0] + pos[1][0]
        y_proj = pos[0][1] <= y <= pos[0][1] + pos[1][1]
        return x_proj and y_proj
        
@dataclass
class Line(Graphics):
    pos: List[Pos]
    color: str
    
    def move_point(self, i, x, y):
        self.pos[i] = self.pos[i] + Pos(x, y)
        
    def move(self, x, y):
        for i in range(len(self.pos)):
            self.move_point(i, x, y)
            
    def to_local(self):
        result = []
        for pos in self.pos:
            result.append(self.trans.get_local(pos.x, pos.y))
        return result
        
    def to_global(self):
        result = []
        for pos in self.pos:
            result.append(self.trans.get_global(pos.x, pos.y))
        return result
        
    def cross(x1, y1, x2, y2, x, y):
        return (x-x1)*abs(y2-y1) - (y-y1)*abs(x2-x1)
        
    def incross(x1, y1, x2, y2, x, y):
        return -600 < Line.cross(x1, y1, x2, y2, x, y) < 600
        
    def is_inside(self, x, y):
        pos = self.to_global()
        for i in range(len(pos) - 1):
            x1, y1 = pos[i]
            x2, y2 = pos[i+1]
            if Line.incross(x1, y1, x2, y2, x, y) and x1 < x < x2 and y1 < y < y2:
              return True
        return False

@dataclass
class Ellipse(Rect):
    def is_inside(self, x, y):
        (x_pos, y_pos), (width, height) = self.to_global()
        rad_x = 1/2*width
        rad_y = 1/2*height
        return (x-(x_pos+rad_x))**2/rad_x + (y-(y_pos+rad_y))**2/rad_y <= 1
        
@dataclass
class Polygon(Line):
    pass
        
@dataclass
class ContentShape(Rect):
    src: str
    
    def __post_init__(self):
        super().__post_init__()
        self.content = None
        
class Handler:
    def on_mouse_move(self, x, y):
        print("MyLine inside", x, y)
        
    def on_mouse_move_out(self, x, y):
        print("MyRect/Line Out", x, y)
        
    def on_key_down(self, key):
        print("onclicked", key)
        
    def on_a_down(self):
        print("on a down")
        
class MyRect(Rect, Handler):
    pass
  
class MyLine(Line, Handler):
    pass
        
class ConsoleRender:
    def unload(self, **kwargs):
        return kwargs["pos"], kwargs["col"], kwargs["border"]
      
    def Rect(self, **kwargs):
        print("Rect: ", *self.unload(**kwargs))
        
    def Line(self, **kwargs):
        print("Line: ", *self.unload(**kwargs))
        
    def Ellipse(self, **kwargs):
        print("Ellipse: ", *self.unload(**kwargs))
        
    def Polygon(self, **kwargs):
        print("Polygon: ", *self.unload(**kwargs))
      
c = ConsoleRender()
g = Line([Pos(Len(3, 2), Len(11, 2)), Pos(Len(8, 7), Len(3, 9)), Pos(Len(12, 7), Len(22, 3))], "purple")
g.trans = Trans(Pos(2, 8), Pos(3, 2), Pos(197, 136), Pos(3, 2))
print(g.to_local())
print(g.to_global())
g.render(c)
print(g.is_inside(50, 40))
print(Line.cross(25.82, 37.44, 82.37, 62.16, 70, 50))
print(Line.cross(35.4, 249.64, 44.6, 110.92, 35.4, 249.64))