import bpy
from .libs.replication.constants import *
from .libs import debug
from . import operators, utils
from .bl_types.bl_user import BlUser

class Delayable():
    def register(self):
        raise NotImplementedError

    def execute(self):
        raise NotImplementedError

    def unregister(self):
        raise NotImplementedError

class Timer(Delayable):
    """Timer binder interface for blender

    Run a bpy.app.Timer in the background looping at the given rate
    """
    def __init__(self, duration=1):
        self._timeout = duration

    def register(self):
        """Register the timer into the blender timer system
        """
        bpy.app.timers.register(self.execute)

    def execute(self):
        """Main timer loop
        """
        return self._timeout

    def unregister(self):
        """Unnegister the timer of the blender timer system
        """
        try:
            bpy.app.timers.unregister(self.execute)
        except:
            print("timer already unregistered")

class ApplyTimer(Timer):
    def __init__(self, timout=1,target_type=None):
        self._type = target_type
        super().__init__(timout)

    def execute(self):
        if operators.client:
            nodes = operators.client.list(filter=self._type)

            for node in nodes:
                node_ref = operators.client.get(node)

                if node_ref.state == FETCHED:
                    operators.client.apply(uuid=node)

        return self._timeout

class Draw(Delayable):
    def __init__(self):
        self._handler = None

    def register(self):
        self._handler = bpy.types.SpaceView3D.draw_handler_add(
            self.execute,(), 'WINDOW', 'POST_VIEW')
    
    def execute(self):
        raise NotImplementedError()
    
    def unregister(self):
        try:
            bpy.types.SpaceView3D.draw_handler_remove(
                    self._handler, "WINDOW")
        except:
            print("draw already unregistered")
            
class ClientUpdate(Draw):
    def __init__(self, client_uuid=None):
        assert(client_uuid)
        self._client_uuid = client_uuid
        super().__init__()

    def execute(self):
        if hasattr(operators,"client"):
            client = operators.client.get(self._client_uuid)

            if client:
                client.pointer.update_location()
            
                
class DrawClients(Draw):
    def __init__(self):
        super().__init__()
        self._camera_lines = []

    def execute(self):
        if operators.client:
            users = operators.client.list(filter=BlUser)
            try:    
                self.clear_camera()
            except:
                pass

            for u in users:
                cli =  operators.client.get(u)
                if cli:
                    loc = cli.buffer['location']
                    self.draw_camera(loc)
                    
    def clear_camera(self):
        for line in self._camera_lines:
            line.clear()
        
        self._camera_lines.clear()

    def draw_camera(self, loc):
        self._camera_lines.append(debug.draw_line(a=loc[0],b=loc[2]))
        self._camera_lines.append(debug.draw_line(a=loc[1],b=loc[2]))
        self._camera_lines.append(debug.draw_line(a=loc[3],b=loc[1]))
        self._camera_lines.append(debug.draw_line(a=loc[3],b=loc[0]))

        self._camera_lines.append(debug.draw_line(a=loc[0],b=loc[6]))
        self._camera_lines.append(debug.draw_line(a=loc[1],b=loc[6]))
        self._camera_lines.append(debug.draw_line(a=loc[2],b=loc[6]))
        self._camera_lines.append(debug.draw_line(a=loc[3],b=loc[6]))
        
        self._camera_lines.append(debug.draw_line(a=loc[4],b=loc[5]))