multi-user/multi_user/operators.py

# ##### BEGIN GPL LICENSE BLOCK #####
#
#   This program is free software: you can redistribute it and/or modify
#   it under the terms of the GNU General Public License as published by
#   the Free Software Foundation, either version 3 of the License, or
#   (at your option) any later version.
#
#   This program is distributed in the hope that it will be useful,
#   but WITHOUT ANY WARRANTY; without even the implied warranty of
#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#   GNU General Public License for more details.
#
#   You should have received a copy of the GNU General Public License
#   along with this program.  If not, see <https://www.gnu.org/licenses/>.
#
# ##### END GPL LICENSE BLOCK #####


import asyncio
import copy
import gzip
import logging
from multi_user.preferences import ServerPreset
import os
import queue
import random
import shutil
import string
import sys
import time
import traceback
from uuid import uuid4
from datetime import datetime
from operator import itemgetter
from pathlib import Path
from queue import Queue
from time import gmtime, strftime
from numpy import interp

from bpy.props import FloatProperty
import bmesh

try:
    import _pickle as pickle
except ImportError:
    import pickle

import bpy
import mathutils
from bpy.app.handlers import persistent
from bpy_extras.io_utils import ExportHelper, ImportHelper
from replication import porcelain
from replication.constants import (COMMITED, FETCHED, RP_COMMON, STATE_ACTIVE,
                                   STATE_INITIAL, STATE_SYNCING, UP)
from replication.exception import ContextError, NonAuthorizedOperationError
from replication.interface import session
from replication.objects import Node
from replication.protocol import DataTranslationProtocol
from replication.repository import Repository

from . import bl_types, environment, shared_data, timers, ui, utils
from .handlers import on_scene_update, sanitize_deps_graph
from .presence import SessionStatusWidget, renderer, view3d_find, refresh_sidebar_view, bbox_from_obj
from .timers import registry

background_execution_queue = Queue()
deleyables = []
stop_modal_executor = False


CLEARED_DATABLOCKS = ['actions', 'armatures', 'cache_files', 'cameras',
                     'collections', 'curves', 'fonts',
                     'grease_pencils', 'images', 'lattices', 'libraries',
                     'lightprobes', 'lights', 'linestyles', 'masks',
                     'materials', 'meshes', 'metaballs', 'movieclips',
                     'node_groups', 'objects', 'paint_curves', 'particles',
                     'scenes', 'shape_keys', 'sounds', 'speakers', 'texts',
                     'textures', 'volumes', 'worlds']

PERSISTENT_DATABLOCKS = ['LineStyle', 'Dots Stroke', 'replay_action']

def clean_scene(ignored_datablocks: list = None):
    """ 
        Delete all datablock of the scene except PERSISTENT_DATABLOCKS and ignored
        ones in ignored_datablocks.
    """
    PERSISTENT_DATABLOCKS.extend(ignored_datablocks)
    # Avoid to trigger a runtime error by keeping the last scene
    PERSISTENT_DATABLOCKS.append(bpy.data.scenes[0].name)

    for type_name in CLEARED_DATABLOCKS:
        type_collection = getattr(bpy.data, type_name)
        for datablock in type_collection:
            if datablock.name in PERSISTENT_DATABLOCKS:
                logging.debug(f"Skipping {datablock.name}")
                continue
            else:
                logging.debug(f"Removing {datablock.name}")
                type_collection.remove(datablock)

    # Clear sequencer
    bpy.context.scene.sequence_editor_clear()


def draw_user(username, metadata, radius=0.01, intensity=10.0):
    """ 
        Generate a mesh representation of a given user frustum and 
        sight of view.
    """
    view_corners =  metadata.get('view_corners')
    color =  metadata.get('color', (1,1,1,0))
    objects = metadata.get('selected_objects', None)
    scene = metadata.get('scene_current', bpy.context.scene.name)

    user_collection = bpy.data.collections.new(username)
    # User Color
    user_mat = bpy.data.materials.new(username)
    user_mat.use_nodes = True
    nodes = user_mat.node_tree.nodes
    nodes.remove(nodes['Principled BSDF'])
    emission_node = nodes.new('ShaderNodeEmission')
    emission_node.inputs['Color'].default_value = color
    emission_node.inputs['Strength'].default_value = intensity

    output_node = nodes['Material Output']
    user_mat.node_tree.links.new(
        emission_node.outputs['Emission'], output_node.inputs['Surface'])

    # Generate camera mesh
    camera_vertices = view_corners[:4]
    camera_vertices.append(view_corners[6])
    camera_mesh = bpy.data.meshes.new(f"{username}_camera")
    camera_obj = bpy.data.objects.new(f"{username}_camera", camera_mesh)
    frustum_bm = bmesh.new()
    frustum_bm.from_mesh(camera_mesh)

    for p in camera_vertices:
        frustum_bm.verts.new(p)
    frustum_bm.verts.ensure_lookup_table()

    frustum_bm.edges.new((frustum_bm.verts[0], frustum_bm.verts[2]))
    frustum_bm.edges.new((frustum_bm.verts[2], frustum_bm.verts[1]))
    frustum_bm.edges.new((frustum_bm.verts[1], frustum_bm.verts[3]))
    frustum_bm.edges.new((frustum_bm.verts[3], frustum_bm.verts[0]))

    frustum_bm.edges.new((frustum_bm.verts[0], frustum_bm.verts[4]))
    frustum_bm.edges.new((frustum_bm.verts[2], frustum_bm.verts[4]))
    frustum_bm.edges.new((frustum_bm.verts[1], frustum_bm.verts[4]))
    frustum_bm.edges.new((frustum_bm.verts[3], frustum_bm.verts[4]))
    frustum_bm.edges.ensure_lookup_table()

    frustum_bm.to_mesh(camera_mesh)
    frustum_bm.free()  # free and prevent further access

    camera_obj.modifiers.new("wireframe", "SKIN")
    camera_obj.data.skin_vertices[0].data[0].use_root = True
    for v in camera_obj.data.skin_vertices[0].data:
        v.radius = [radius, radius]

    camera_mesh.materials.append(user_mat)
    user_collection.objects.link(camera_obj)

    # Generate sight mesh
    sight_mesh = bpy.data.meshes.new(f"{username}_sight")
    sight_obj = bpy.data.objects.new(f"{username}_sight", sight_mesh)
    sight_verts = view_corners[4:6]
    sight_bm = bmesh.new()
    sight_bm.from_mesh(sight_mesh)

    for p in sight_verts:
        sight_bm.verts.new(p)
    sight_bm.verts.ensure_lookup_table()

    sight_bm.edges.new((sight_bm.verts[0], sight_bm.verts[1]))
    sight_bm.edges.ensure_lookup_table()
    sight_bm.to_mesh(sight_mesh)
    sight_bm.free()

    sight_obj.modifiers.new("wireframe", "SKIN")
    sight_obj.data.skin_vertices[0].data[0].use_root = True
    for v in sight_mesh.skin_vertices[0].data:
        v.radius = [radius, radius]

    sight_mesh.materials.append(user_mat)
    user_collection.objects.link(sight_obj)

    # Draw selected objects
    if objects:
        for o in list(objects):
            instance = bl_types.bl_datablock.get_datablock_from_uuid(o, None)
            if instance:
                bbox_mesh = bpy.data.meshes.new(f"{instance.name}_bbox")
                bbox_obj = bpy.data.objects.new(
                    f"{instance.name}_bbox", bbox_mesh)
                bbox_verts, bbox_ind = bbox_from_obj(instance, index=0)
                bbox_bm = bmesh.new()
                bbox_bm.from_mesh(bbox_mesh)

                for p in bbox_verts:
                    bbox_bm.verts.new(p)
                bbox_bm.verts.ensure_lookup_table()

                for e in bbox_ind:
                    bbox_bm.edges.new(
                        (bbox_bm.verts[e[0]], bbox_bm.verts[e[1]]))

                bbox_bm.to_mesh(bbox_mesh)
                bbox_bm.free()
                bpy.data.collections[username].objects.link(bbox_obj)

                bbox_obj.modifiers.new("wireframe", "SKIN")
                bbox_obj.data.skin_vertices[0].data[0].use_root = True
                for v in bbox_mesh.skin_vertices[0].data:
                    v.radius = [radius, radius]

                bbox_mesh.materials.append(user_mat)

    bpy.data.scenes[scene].collection.children.link(user_collection)


def session_callback(name):
    """ Session callback wrapper

    This allow to encapsulate session callbacks to background_execution_queue.
    By doing this way callback are executed from the main thread. 
    """
    def func_wrapper(func):
        @session.register(name)
        def add_background_task(**kwargs):
            background_execution_queue.put((func, kwargs))
        return add_background_task
    return func_wrapper


@session_callback('on_connection')
def initialize_session():
    """Session connection init hander 
    """
    runtime_settings = bpy.context.window_manager.session

    if not runtime_settings.is_host:
        logging.info("Intializing the scene")
        # Step 1: Constrect nodes
        logging.info("Instantiating nodes")
        for node in session.repository.index_sorted:
            node_ref = session.repository.graph.get(node)
            if node_ref is None:
                logging.error(f"Can't construct node {node}")
            elif node_ref.state == FETCHED:
                node_ref.instance = session.repository.rdp.resolve(node_ref.data)
                if node_ref.instance is None:
                    node_ref.instance = session.repository.rdp.construct(node_ref.data)
                    node_ref.instance.uuid = node_ref.uuid

        # Step 2: Load nodes
        logging.info("Applying nodes")
        for node in session.repository.heads:
            porcelain.apply(session.repository, node)

    logging.info("Registering timers")
    # Step 4: Register blender timers
    for d in deleyables:
        d.register()

    # Step 5: Clearing history
    utils.flush_history()

    # Step 6: Launch deps graph update handling
    bpy.app.handlers.depsgraph_update_post.append(on_scene_update)


@session_callback('on_exit')
def on_connection_end(reason="none"):
    """Session connection finished handler 
    """
    global deleyables, stop_modal_executor
    settings = utils.get_preferences()

    # Step 1: Unregister blender timers
    for d in deleyables:
        try:
            d.unregister()
        except:
            continue
    deleyables.clear()

    stop_modal_executor = True

    if on_scene_update in bpy.app.handlers.depsgraph_update_post:
        bpy.app.handlers.depsgraph_update_post.remove(on_scene_update)

    # Step 3: remove file handled
    logger = logging.getLogger()
    for handler in logger.handlers:
        if isinstance(handler, logging.FileHandler):
            logger.removeHandler(handler)
    if reason != "user":
        bpy.ops.session.notify('INVOKE_DEFAULT', message=f"Disconnected from session. Reason: {reason}. ") #TODO: change op session.notify to add ui + change reason (in replication->interface)

def setup_logging():
    """ Session setup logging (host/connect)
    """
    settings = utils.get_preferences()
    logger = logging.getLogger()
    if len(logger.handlers) == 1:
        formatter = logging.Formatter(
            fmt='%(asctime)s CLIENT %(levelname)-8s %(message)s',
            datefmt='%H:%M:%S'
        )

        start_time = datetime.now().strftime('%Y_%m_%d_%H-%M-%S')
        log_directory = os.path.join(
            settings.cache_directory,
            f"multiuser_{start_time}.log")

        os.makedirs(settings.cache_directory, exist_ok=True)

        handler = logging.FileHandler(log_directory, mode='w')
        logger.addHandler(handler)

        for handler in logger.handlers:
            if isinstance(handler, logging.NullHandler):
                continue

            handler.setFormatter(formatter)

def setup_timer():
    """ Session setup timer (host/connect)
    """
    settings = utils.get_preferences()
    deleyables.append(timers.ClientUpdate())
    deleyables.append(timers.DynamicRightSelectTimer())
    deleyables.append(timers.ApplyTimer(timeout=settings.depsgraph_update_rate))

    session_update = timers.SessionStatusUpdate()
    session_user_sync = timers.SessionUserSync()
    session_background_executor = timers.MainThreadExecutor(execution_queue=background_execution_queue)
    session_listen = timers.SessionListenTimer(timeout=0.001)

    session_listen.register()
    session_update.register()
    session_user_sync.register()
    session_background_executor.register()

    deleyables.append(session_background_executor)
    deleyables.append(session_update)
    deleyables.append(session_user_sync)
    deleyables.append(session_listen)
    deleyables.append(timers.AnnotationUpdates())

def get_active_server_preset(context):
    active_index = context.window_manager.server_index
    server_presets = utils.get_preferences().server_preset

    active_index = active_index if active_index <= len(server_presets)-1 else 0

    return server_presets[active_index]

# OPERATORS
class SessionConnectOperator(bpy.types.Operator):
    bl_idname = "session.connect"
    bl_label = "connect"
    bl_description = "connect to a net server"

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        global deleyables

        settings = utils.get_preferences()
        users = bpy.data.window_managers['WinMan'].online_users
        active_server = get_active_server_preset(context)
        admin_pass = active_server.admin_password if active_server.use_admin_password else None
        server_pass = active_server.server_password if active_server.use_server_password else ''

        users.clear()
        deleyables.clear()

        setup_logging()

        bpy_protocol = bl_types.get_data_translation_protocol()

        # Check if supported_datablocks are up to date before starting the
        # the session
        for dcc_type_id in bpy_protocol.implementations.keys():
            if dcc_type_id not in settings.supported_datablocks:
                logging.info(f"{dcc_type_id} not found, \
                             regenerate type settings...")
                settings.generate_supported_types()


        if bpy.app.version >= (2,91,0):
            python_binary_path = sys.executable
        else:
            python_binary_path = bpy.app.binary_path_python

        repo = Repository(
            rdp=bpy_protocol,
            username=settings.username)
        
        # Join a session
        if not active_server.use_admin_password:
            clean_scene()

        try:
            porcelain.remote_add(
                repo,
                'origin',
                active_server.ip,
                active_server.port,
                server_password=server_pass,
                admin_password=admin_pass)
            session.connect(
                repository= repo,
                timeout=settings.connection_timeout,
                server_password=server_pass,
                admin_password=admin_pass
            )
        except Exception as e:
            self.report({'ERROR'}, str(e))
            logging.error(str(e))

        # Background client updates service
        setup_timer()

        return {"FINISHED"}


class SessionHostOperator(bpy.types.Operator):
    bl_idname = "session.host"
    bl_label = "host"
    bl_description = "host server"

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        global deleyables

        settings = utils.get_preferences()
        runtime_settings = context.window_manager.session
        users = bpy.data.window_managers['WinMan'].online_users
        admin_pass = settings.host_admin_password if settings.host_use_admin_password else None
        server_pass = settings.host_server_password if settings.host_use_server_password else ''

        users.clear()
        deleyables.clear()

        setup_logging()

        bpy_protocol = bl_types.get_data_translation_protocol()

        # Check if supported_datablocks are up to date before starting the
        # the session
        for dcc_type_id in bpy_protocol.implementations.keys():
            if dcc_type_id not in settings.supported_datablocks:
                logging.info(f"{dcc_type_id} not found, \
                             regenerate type settings...")
                settings.generate_supported_types()


        if bpy.app.version >= (2,91,0):
            python_binary_path = sys.executable
        else:
            python_binary_path = bpy.app.binary_path_python

        repo = Repository(
            rdp=bpy_protocol,
            username=settings.username)
    
        # Host a session
        if settings.init_method == 'EMPTY':
            clean_scene()

        try:
            # Init repository
            for scene in bpy.data.scenes:
                porcelain.add(repo, scene)

            porcelain.remote_add(
                repo,
                'origin',
                '127.0.0.1',
                settings.host_port,
                server_password=server_pass,
                admin_password=admin_pass)
            session.host(
                repository= repo,
                remote='origin',
                timeout=settings.connection_timeout,
                server_password=server_pass,
                admin_password=admin_pass,
                cache_directory=settings.cache_directory,
                server_log_level=logging.getLevelName(
                    logging.getLogger().level),
            )
        except Exception as e:
            self.report({'ERROR'}, repr(e))
            logging.error(f"Error: {e}")
            traceback.print_exc()

        # Background client updates service
        setup_timer()

        return {"FINISHED"}


class SessionInitOperator(bpy.types.Operator):
    bl_idname = "session.init"
    bl_label = "Init session repostitory from"
    bl_description = "Init the current session"
    bl_options = {"REGISTER"}

    init_method: bpy.props.EnumProperty(
        name='init_method',
        description='Init repo',
        items={
            ('EMPTY', 'an empty scene', 'start empty'),
            ('BLEND', 'current scenes', 'use current scenes')},
        default='BLEND')

    @classmethod
    def poll(cls, context):
        return True

    def draw(self, context):
        layout = self.layout
        col = layout.column()
        col.prop(self, 'init_method', text="")

    def invoke(self, context, event):
        wm = context.window_manager
        return wm.invoke_props_dialog(self)

    def execute(self, context):
        if self.init_method == 'EMPTY':
            clean_scene()

        for scene in bpy.data.scenes:
            porcelain.add(session.repository, scene)

        session.init()
        context.window_manager.session.is_host = True

        return {"FINISHED"}


class SessionStopOperator(bpy.types.Operator):
    bl_idname = "session.stop"
    bl_label = "close"
    bl_description = "Exit current session"
    bl_options = {"REGISTER"}

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        global deleyables, stop_modal_executor

        if session:
            try:
                session.disconnect(reason='user')

            except Exception as e:
                self.report({'ERROR'}, repr(e))
        else:
            self.report({'WARNING'}, "No session to quit.")
            return {"FINISHED"}
        return {"FINISHED"}


class SessionKickOperator(bpy.types.Operator):
    bl_idname = "session.kick"
    bl_label = "Kick"
    bl_description = "Kick the target user"
    bl_options = {"REGISTER"}

    user: bpy.props.StringProperty()

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        global deleyables, stop_modal_executor
        assert(session)

        try:
            porcelain.kick(session.repository, self.user)
        except Exception as e:
            self.report({'ERROR'}, repr(e))

        return {"FINISHED"}

    def invoke(self, context, event):
        return context.window_manager.invoke_props_dialog(self)

    def draw(self, context):
        row = self.layout
        row.label(text=f" Do you really want to kick {self.user} ? ")


class SessionPropertyRemoveOperator(bpy.types.Operator):
    bl_idname = "session.remove_prop"
    bl_label = "Delete cache"
    bl_description = "Stop tracking modification on the target datablock." + \
        "The datablock will no longer be updated for others client. "
    bl_options = {"REGISTER"}

    property_path: bpy.props.StringProperty(default="None")

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        try:
            porcelain.rm(session.repository, self.property_path)

            return {"FINISHED"}
        except:  # NonAuthorizedOperationError:
            self.report(
                {'ERROR'},
                "Non authorized operation")
            return {"CANCELLED"}


class SessionPropertyRightOperator(bpy.types.Operator):
    bl_idname = "session.right"
    bl_label = "Change modification rights"
    bl_description = "Modify the owner of the target datablock"
    bl_options = {"REGISTER"}

    key: bpy.props.StringProperty(default="None")
    recursive: bpy.props.BoolProperty(default=True)

    @classmethod
    def poll(cls, context):
        return True

    def invoke(self, context, event):
        wm = context.window_manager
        return wm.invoke_props_dialog(self)

    def draw(self, context):
        layout = self.layout
        runtime_settings = context.window_manager.session

        row = layout.row()
        row.label(text="Give the owning rights to:")
        row.prop(runtime_settings, "clients", text="")
        row = layout.row()
        row.label(text="Affect dependencies")
        row.prop(self, "recursive", text="")

    def execute(self, context):
        runtime_settings = context.window_manager.session

        if session:
            if runtime_settings.clients == RP_COMMON:
                porcelain.unlock(session.repository,
                                 self.key,
                                 ignore_warnings=True,
                                 affect_dependencies=self.recursive)
            else:
                porcelain.lock(session.repository,
                             self.key,
                             runtime_settings.clients,
                             ignore_warnings=True,
                             affect_dependencies=self.recursive)

        return {"FINISHED"}


class SessionSnapUserOperator(bpy.types.Operator):
    bl_idname = "session.snapview"
    bl_label = "snap to user"
    bl_description = "Snap 3d view to selected user"
    bl_options = {"REGISTER"}

    _timer = None

    target_client: bpy.props.StringProperty(default="None")

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        wm = context.window_manager
        runtime_settings = context.window_manager.session

        if runtime_settings.time_snap_running:
            runtime_settings.time_snap_running = False
            return {'CANCELLED'}
        else:
            runtime_settings.time_snap_running = True

        self._timer = wm.event_timer_add(0.1, window=context.window)
        wm.modal_handler_add(self)
        return {'RUNNING_MODAL'}

    def cancel(self, context):
        wm = context.window_manager
        wm.event_timer_remove(self._timer)

    def modal(self, context, event):
        session_sessings = context.window_manager.session
        is_running = session_sessings.time_snap_running

        if event.type in {'RIGHTMOUSE', 'ESC'} or not is_running:
            self.cancel(context)
            return {'CANCELLED'}

        if event.type == 'TIMER':
            area, region, rv3d = view3d_find()

            if session:
                target_ref = session.online_users.get(self.target_client)

                if target_ref:
                    target_scene = target_ref['metadata']['scene_current']

                    # Handle client on other scenes
                    if target_scene != context.scene.name:
                        blender_scene = bpy.data.scenes.get(target_scene, None)
                        if blender_scene is None:
                            self.report(
                                {'ERROR'}, f"Scene {target_scene} doesn't exist on the local client.")
                            session_sessings.time_snap_running = False
                            return {"CANCELLED"}

                        bpy.context.window.scene = blender_scene

                    # Update client viewmatrix
                    client_vmatrix = target_ref['metadata'].get(
                        'view_matrix', None)

                    if client_vmatrix:
                        rv3d.view_matrix = mathutils.Matrix(client_vmatrix)
                    else:
                        self.report({'ERROR'}, f"Client viewport not ready.")
                        session_sessings.time_snap_running = False
                        return {"CANCELLED"}
            else:
                return {"CANCELLED"}

        return {'PASS_THROUGH'}


class SessionSnapTimeOperator(bpy.types.Operator):
    bl_idname = "session.snaptime"
    bl_label = "snap to user time"
    bl_description = "Snap time to selected user time's"
    bl_options = {"REGISTER"}

    _timer = None

    target_client: bpy.props.StringProperty(default="None")

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        runtime_settings = context.window_manager.session

        if runtime_settings.user_snap_running:
            runtime_settings.user_snap_running = False
            return {'CANCELLED'}
        else:
            runtime_settings.user_snap_running = True

        wm = context.window_manager
        self._timer = wm.event_timer_add(0.05, window=context.window)
        wm.modal_handler_add(self)
        return {'RUNNING_MODAL'}

    def cancel(self, context):
        wm = context.window_manager
        wm.event_timer_remove(self._timer)

    def modal(self, context, event):
        is_running = context.window_manager.session.user_snap_running
        if not is_running:
            self.cancel(context)
            return {'CANCELLED'}

        if event.type == 'TIMER':
            if session:
                target_ref = session.online_users.get(self.target_client)

                if target_ref:
                    context.scene.frame_current = target_ref['metadata']['frame_current']
            else:
                return {"CANCELLED"}

        return {'PASS_THROUGH'}


class SessionApply(bpy.types.Operator):
    bl_idname = "session.apply"
    bl_label = "Revert"
    bl_description = "Revert the selected datablock from his cached" + \
        " version."
    bl_options = {"REGISTER"}

    target: bpy.props.StringProperty()
    reset_dependencies: bpy.props.BoolProperty(default=False)

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        logging.debug(f"Running apply on {self.target}")
        try:
            node_ref = session.repository.graph.get(self.target)
            porcelain.apply(session.repository,
                            self.target,
                            force=True)
            impl = session.repository.rdp.get_implementation(node_ref.instance)
            # NOTE: find another way to handle child and parent automatic reloading
            if impl.bl_reload_parent:
                for parent in session.repository.graph.get_parents(self.target):
                    logging.debug(f"Refresh parent {parent}")

                    porcelain.apply(session.repository,
                                    parent.uuid,
                                    force=True)
            if hasattr(impl, 'bl_reload_child') and impl.bl_reload_child:
                for dep in node_ref.dependencies:
                    porcelain.apply(session.repository,
                                    dep,
                                    force=True)
        except Exception as e:
            self.report({'ERROR'}, repr(e))
            traceback.print_exc()
            return {"CANCELLED"}    

        return {"FINISHED"}


class SessionCommit(bpy.types.Operator):
    bl_idname = "session.commit"
    bl_label = "Force server update"
    bl_description = "Commit and push the target datablock to server"
    bl_options = {"REGISTER"}

    target: bpy.props.StringProperty()

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        try:
            porcelain.commit(session.repository, self.target)
            porcelain.push(session.repository, 'origin', self.target, force=True)
            return {"FINISHED"}
        except Exception as e:
            self.report({'ERROR'}, repr(e))
            return {"CANCELLED"}


class SessionClearCache(bpy.types.Operator):
    "Clear local session cache"
    bl_idname = "session.clear_cache"
    bl_label = "Modal Executor Operator"

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        cache_dir = utils.get_preferences().cache_directory
        try:
            for root, dirs, files in os.walk(cache_dir):
                for name in files:
                    Path(root, name).unlink()

        except Exception as e:
            self.report({'ERROR'}, repr(e))

        return {"FINISHED"}

    def invoke(self, context, event):
        return context.window_manager.invoke_props_dialog(self)

    def draw(self, context):
        row = self.layout
        row.label(text=f" Do you really want to remove local cache ? ")


class SessionPurgeOperator(bpy.types.Operator):
    "Remove node with lost references"
    bl_idname = "session.purge"
    bl_label = "Purge session data"

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        try:
            porcelain.purge_orphan_nodes(session.repository)
        except Exception as e:
            self.report({'ERROR'}, repr(e))

        return {"FINISHED"}

    def invoke(self, context, event):
        return context.window_manager.invoke_props_dialog(self)

    def draw(self, context):
        row = self.layout
        row.label(text=f" Do you really want to remove local cache ? ")


class SessionNotifyOperator(bpy.types.Operator):
    """Dialog only operator"""
    bl_idname = "session.notify"
    bl_label = "Multi-user"
    bl_description = "multiuser notification"

    message: bpy.props.StringProperty()

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        return {'FINISHED'}

    def draw(self, context):
        layout = self.layout
        layout.row().label(text=self.message)

    def invoke(self, context, event):
        return context.window_manager.invoke_props_dialog(self)


class SessionSaveBackupOperator(bpy.types.Operator, ExportHelper):
    bl_idname = "session.save"
    bl_label = "Save session data"
    bl_description = "Save a snapshot of the collaborative session"

    # ExportHelper mixin class uses this
    filename_ext = ".db"

    filter_glob: bpy.props.StringProperty(
        default="*.db",
        options={'HIDDEN'},
        maxlen=255,  # Max internal buffer length, longer would be clamped.
    )

    enable_autosave: bpy.props.BoolProperty(
        name="Auto-save",
        description="Enable session auto-save",
        default=True,
    )
    save_interval: bpy.props.FloatProperty(
        name="Auto save interval",
        description="auto-save interval (seconds)",
        default=10,
    )

    def execute(self, context):
        if self.enable_autosave:
            recorder = timers.SessionBackupTimer(
                filepath=self.filepath,
                timeout=self.save_interval)
            recorder.register()
            deleyables.append(recorder)
        else:
            session.repository.dumps(self.filepath)

        return {'FINISHED'}

    @classmethod
    def poll(cls, context):
        return session.state == STATE_ACTIVE


class SessionStopAutoSaveOperator(bpy.types.Operator):
    bl_idname = "session.cancel_autosave"
    bl_label = "Cancel auto-save"
    bl_description = "Cancel session auto-save"

    @classmethod
    def poll(cls, context):
        return (session.state == STATE_ACTIVE and 'SessionBackupTimer' in registry)

    def execute(self, context):
        autosave_timer = registry.get('SessionBackupTimer')
        autosave_timer.unregister()

        return {'FINISHED'}

class SessionLoadSaveOperator(bpy.types.Operator, ImportHelper):
    bl_idname = "session.load"
    bl_label = "Load session save"
    bl_description = "Load a Multi-user session save"
    bl_options = {'REGISTER', 'UNDO'}

    # ExportHelper mixin class uses this
    filename_ext = ".db"

    filter_glob: bpy.props.StringProperty(
        default="*.db",
        options={'HIDDEN'},
        maxlen=255,  # Max internal buffer length, longer would be clamped.
    )

    draw_users: bpy.props.BoolProperty(
        name="Load users",
        description="Draw users in the scene",
        default=False,
    )

    replay: bpy.props.BoolProperty(
        name="Replay mode",
        description="Enable replay functions",
        default=False,
    )

    user_skin_radius: bpy.props.FloatProperty(
        name="Wireframe radius",
        description="Wireframe radius",
        default=0.01,
    )
    user_color_intensity: bpy.props.FloatProperty(
        name="Shading intensity",
        description="Shading intensity",
        default=1.0,
    )

    files:  bpy.props.CollectionProperty(
        name='File paths',
        type=bpy.types.OperatorFileListElement
    )



    def draw(self, context):
        pass
    
    def execute(self, context):
        from replication.repository import Repository

        runtime_settings = context.window_manager.session

        # init the factory with supported types
        bpy_protocol = bl_types.get_data_translation_protocol()
        repo = Repository(bpy_protocol)

        try:
            repo.loads(self.filepath)
        except TypeError:
            # Load legacy snapshots
            db = pickle.load(gzip.open(self.filepath, "rb"))

            nodes = db.get("nodes")

            logging.info(f"Loading legacy {len(nodes)} node")
            repo.object_store.clear()
            for node, node_data in nodes:
                    instance = Node(
                        uuid=node,
                        data=node_data.get('data'),
                        owner=node_data.get('owner'),
                        dependencies=node_data.get('dependencies'),
                        state=FETCHED)
                    # Patch data for compatibility
                    type_id = node_data.get('str_type')[2:]
                    if type_id == "File":
                        type_id = "WindowsPath"
                    instance.data['type_id'] = type_id
                    repo.do_commit(instance)
                    instance.state = FETCHED

        # Persitstent collection 
        ignored_datablocks = []
    
        persistent_collection = bpy.data.collections.get("multiuser_timelapse")
        if self.replay and \
          runtime_settings.replay_persistent_collection and \
          persistent_collection:
            collection_repo = Repository(
                rdp=bpy_protocol,
                username="None")
            porcelain.add(collection_repo, persistent_collection)
            porcelain.commit(collection_repo, persistent_collection.uuid)
            for node in collection_repo.graph.values():
                ignored_datablocks.append(node.data.get('name'))

        clean_scene(ignored_datablocks=ignored_datablocks)

        nodes = [repo.graph.get(n) for n in repo.index_sorted]

        # Step 1: Construct nodes
        for node in nodes:
            node.instance = bpy_protocol.resolve(node.data)
            if node.instance is None:
                node.instance = bpy_protocol.construct(node.data)
                node.instance.uuid = node.uuid

        # Step 2: Load nodes
        for node in nodes:
            porcelain.apply(repo, node.uuid)
        
        if len(self.files) > 1:
            runtime_settings.replay_files.clear()
            context.scene.active_replay_file = len(self.files)-1
            directory = Path(self.filepath).parent
            file_list = [f['name'] for f in self.files]
            file_list.sort()
            for f in file_list:
                snap = runtime_settings.replay_files.add()
                snap.name = str(Path(directory, f))
                print(f)
            
            if runtime_settings.replay_mode == 'TIMELINE':
                replay_action = bpy.data.actions.get('replay_action', bpy.data.actions.new('replay_action'))

                bpy.context.scene.animation_data_create()
                bpy.context.scene.animation_data.action = replay_action
                if len(replay_action.fcurves) > 0 and replay_action.fcurves[0].data_path == 'active_replay_file':
                    replay_fcurve = replay_action.fcurves[0]
                else:
                    replay_fcurve = replay_action.fcurves.new('active_replay_file')
                
                for p in reversed(replay_fcurve.keyframe_points): 
                    replay_fcurve.keyframe_points.remove(p, fast=True)

                duration = runtime_settings.replay_duration
                file_count = len(self.files)-1
                for index in range(0, file_count):
                    frame = interp(index, [0, file_count], [bpy.context.scene.frame_start, duration])
                    replay_fcurve.keyframe_points.insert(frame, index)
                

        if self.draw_users:
            f = gzip.open(self.filepath, "rb")
            db = pickle.load(f)

            users = db.get("users")

            for username, user_data in users.items():
                metadata = user_data['metadata']

                if metadata:
                    draw_user(username, metadata, radius=self.user_skin_radius, intensity=self.user_color_intensity)

        # Relink the persistent collection
        if self.replay and persistent_collection:
                logging.info(f"Relinking {persistent_collection.name}")
                bpy.context.scene.collection.children.link(persistent_collection)
        
        # Reasign scene action
        if self.replay and \
            runtime_settings.replay_mode == 'TIMELINE' and \
            not bpy.context.scene.animation_data :
            bpy.context.scene.animation_data_create()
            bpy.context.scene.animation_data.action = bpy.data.actions.get('replay_action')
            bpy.context.scene.frame_end = runtime_settings.replay_duration
        
        # Reasign the scene camera
        if self.replay and \
            runtime_settings.replay_persistent_collection and \
            runtime_settings.replay_camera:
            bpy.context.scene.camera = runtime_settings.replay_camera
            

        
        return {'FINISHED'}
    
    @classmethod
    def poll(cls, context):
        return True

class SESSION_PT_ImportUser(bpy.types.Panel):
    bl_space_type = 'FILE_BROWSER'
    bl_region_type = 'TOOL_PROPS'
    bl_label = "Users"
    bl_parent_id = "FILE_PT_operator"
    bl_options = {'DEFAULT_CLOSED'}

    @classmethod
    def poll(cls, context):
        sfile = context.space_data
        operator = sfile.active_operator

        return operator.bl_idname == "SESSION_OT_load"

    def draw_header(self, context):
        sfile = context.space_data
        operator = sfile.active_operator

        self.layout.prop(operator, "draw_users", text="")

    def draw(self, context):
        layout = self.layout
        layout.use_property_split = True
        layout.use_property_decorate = False  # No animation.

        sfile = context.space_data
        operator = sfile.active_operator

        layout.enabled = operator.draw_users

        layout.prop(operator, "user_skin_radius")
        layout.prop(operator, "user_color_intensity")

class SessionPresetServerAdd(bpy.types.Operator):
    """Add a server to the server list preset"""
    bl_idname = "session.preset_server_add"
    bl_label = "Add server preset"
    bl_description = "add a server to the server preset list"
    bl_options = {"REGISTER"}

    server_name: bpy.props.StringProperty(default="")
    ip: bpy.props.StringProperty(default="127.0.0.1")
    port: bpy.props.IntProperty(default=5555)
    use_server_password: bpy.props.BoolProperty(default=False)
    server_password: bpy.props.StringProperty(default="", subtype = "PASSWORD")
    use_admin_password: bpy.props.BoolProperty(default=False)
    admin_password: bpy.props.StringProperty(default="", subtype = "PASSWORD")

    @classmethod
    def poll(cls, context):
        return True

    def invoke(self, context, event):
        self.server_name = ""
        self.ip = "127.0.0.1"
        self.port = 5555
        self.use_server_password = False
        self.server_password = ""
        self.use_admin_password = False
        self.admin_password = ""

        assert(context)
        return context.window_manager.invoke_props_dialog(self)

    def draw(self, context):
        layout = self.layout

        row = layout.row() 
        row.prop(self, "server_name", text="Server name")
        row = layout.row(align = True)
        row.prop(self, "ip", text="IP+port")
        row.prop(self, "port", text="")
        row = layout.row()
        col = row.column()
        col.prop(self, "use_server_password", text="Server password:")
        col = row.column()
        col.enabled = True if self.use_server_password else False
        col.prop(self, "server_password", text="")
        row = layout.row()
        col = row.column()
        col.prop(self, "use_admin_password", text="Admin password:")
        col = row.column()
        col.enabled = True if self.use_admin_password else False
        col.prop(self, "admin_password", text="")
        
    def execute(self, context):
        assert(context)

        settings = utils.get_preferences()
        existing_preset = settings.get_server_preset(self.server_name)

        new_server = existing_preset if existing_preset else settings.server_preset.add()
        new_server.name = str(uuid4())
        new_server.server_name = self.server_name
        new_server.ip = self.ip
        new_server.port = self.port
        new_server.use_server_password = self.use_server_password
        new_server.server_password = self.server_password
        new_server.use_admin_password = self.use_admin_password
        new_server.admin_password = self.admin_password

        refresh_sidebar_view()

        if new_server == existing_preset :
            self.report({'INFO'}, "Server '" + self.server_name + "' edited")
        else :
            self.report({'INFO'}, "New '" + self.server_name + "' server preset")

        return {'FINISHED'}


class SessionPresetServerEdit(bpy.types.Operator): # TODO : use preset, not settings
    """Edit a server to the server list preset"""
    bl_idname = "session.preset_server_edit"
    bl_label = "Edit server preset"
    bl_description = "Edit a server from the server preset list"
    bl_options = {"REGISTER"}

    target_server_name: bpy.props.StringProperty(default="None")

    @classmethod
    def poll(cls, context):
        return True

    def invoke(self, context, event):
        assert(context)
        return context.window_manager.invoke_props_dialog(self)

    def draw(self, context):
        layout = self.layout
        settings = utils.get_preferences()
        settings_active_server = settings.server_preset.get(self.target_server_name)
        
        row = layout.row()
        row.prop(settings_active_server, "server_name", text="Server name")
        row = layout.row(align = True)
        row.prop(settings_active_server, "ip", text="IP+port")
        row.prop(settings_active_server, "port", text="")
        row = layout.row()
        col = row.column()
        col.prop(settings_active_server, "use_server_password", text="Server password:")
        col = row.column()
        col.enabled = True if settings_active_server.use_server_password else False
        col.prop(settings_active_server, "server_password", text="")
        row = layout.row()
        col = row.column()
        col.prop(settings_active_server, "use_admin_password", text="Admin password:")
        col = row.column()
        col.enabled = True if settings_active_server.use_admin_password else False
        col.prop(settings_active_server, "admin_password", text="")
        
    def execute(self, context):
        assert(context)

        settings = utils.get_preferences()
        settings_active_server = settings.server_preset.get(self.target_server_name)

        refresh_sidebar_view()

        self.report({'INFO'}, "Server '" + settings_active_server.server_name + "' edited")

        return {'FINISHED'}

class SessionPresetServerRemove(bpy.types.Operator):
    """Remove a server to the server list preset"""
    bl_idname = "session.preset_server_remove"
    bl_label = "remove server preset"
    bl_description = "remove the current server from the server preset list"
    bl_options = {"REGISTER"}
    
    target_server_name: bpy.props.StringProperty(default="None")

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        assert(context)

        settings = utils.get_preferences()
        settings.server_preset.remove(settings.server_preset.find(self.target_server_name))

        return {'FINISHED'}
        
class RefreshServerStatus(bpy.types.Operator):
    bl_idname = "session.get_info"
    bl_label = "Get session info"
    bl_description = "Get session info"

    target_server: bpy.props.StringProperty(default="127.0.0.1:5555")

    @classmethod
    def poll(cls, context):
        return (session.state != STATE_ACTIVE)

    def execute(self, context):
        settings = utils.get_preferences()

        for server in settings.server_preset:
            infos = porcelain.request_session_info(f"{server.ip}:{server.port}", timeout=settings.ping_timeout)
            server.is_online = True if infos else False
            if server.is_online:
                server.is_private = infos.get("private")

        return {'FINISHED'}

class GetDoc(bpy.types.Operator):
    """Get the documentation of the addon"""
    bl_idname = "doc.get"
    bl_label = "Multi-user's doc"
    bl_description = "Go to the doc of the addon"

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        assert(context)
        bpy.ops.wm.url_open(url="https://slumber.gitlab.io/multi-user/index.html")

        return {'FINISHED'}

class FirstLaunch(bpy.types.Operator):
    """First time lauching the addon"""
    bl_idname = "firstlaunch.verify"
    bl_label = "First launch"
    bl_description = "First time lauching the addon"

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        assert(context)
        settings = utils.get_preferences()
        settings.is_first_launch = False
        settings.server_preset.clear()
        prefs = bpy.context.preferences.addons[__package__].preferences
        prefs.generate_default_presets()
        return {'FINISHED'}

def menu_func_import(self, context):
    self.layout.operator(SessionLoadSaveOperator.bl_idname, text='Multi-user session snapshot (.db)')

def menu_func_export(self, context):
    self.layout.operator(SessionSaveBackupOperator.bl_idname, text='Multi-user session snapshot (.db)')

class SessionRenderReplay(bpy.types.Operator):
    bl_idname = "session.render_replay"
    bl_label = "Render Replay"
    bl_description = "Render Replay"

    @classmethod
    def poll(cls, context):
        return context.window_manager.session.replay_files

    def execute(self, context):
        base_path = str(context.scene.render.filepath)
        for frame in range(0,context.scene.frame_end):
            logging.info(f"Rendering frame {frame} to {base_path}_{frame}.png")
            context.scene.frame_current = frame
            filename = Path(bpy.context.window_manager.session.replay_files[context.scene.active_replay_file].name)
            context.scene.render.filepath = f"{base_path}{frame}_{filename.stem}"
            bpy.ops.render.render(write_still=True)

        context.scene.render.filepath = base_path
        return {'FINISHED'}

classes = (
    SessionConnectOperator,
    SessionHostOperator,
    SessionStopOperator,
    SessionPropertyRemoveOperator,
    SessionSnapUserOperator,
    SessionSnapTimeOperator,
    SessionPropertyRightOperator,
    SessionApply,
    SessionCommit,
    SessionKickOperator,
    SessionInitOperator,
    SessionClearCache,
    SessionNotifyOperator, 
    SessionSaveBackupOperator,
    SessionLoadSaveOperator,
    SESSION_PT_ImportUser,
    SessionStopAutoSaveOperator,
    SessionPurgeOperator,
    SessionPresetServerAdd,
    SessionPresetServerEdit,
    SessionPresetServerRemove,
    RefreshServerStatus,
    GetDoc,
    FirstLaunch,
    SessionRenderReplay,
)


def register():
    from bpy.utils import register_class

    for cls in classes: 
        register_class(cls)


def unregister():
    if session and session.state == STATE_ACTIVE:
        session.disconnect()

    from bpy.utils import unregister_class
    for cls in reversed(classes):
        unregister_class(cls)