import bpy
from . import gen_vlayer, fn


def add_layer_to_render(ob, node_scene=None):
    '''Send GP object to render layer
    return a tuple with report message'''

    # ob = ob or bpy.context.object
    layer = ob.data.layers.active
    if not layer:
        return ('ERROR', 'No active layer')

    node_scene = fn.get_compo_scene(scene_name=node_scene, create=True)

    ct = 0
    # send scene ?
    hidden = 0
    for l in ob.data.layers:
        if not l.select:
            if not l.viewlayer_render:
                # TODO : need to link, can raise error if object is not linked in Render scene yet
                l.viewlayer_render = fn.get_view_layer('exclude').name
            continue

        gen_vlayer.get_set_viewlayer_from_gp(ob, l, node_scene=node_scene)

        if l.hide:
            hidden += 1
        ct += 1

    if hidden:
        return ('WARNING', f'{hidden}/{ct} layers are hidden!')

    else:
        return ('INFO', f'{ct} layer(s) added')

class GPEXP_OT_add_layer_to_render(bpy.types.Operator):
    bl_idname = "gp.add_layer_to_render"
    bl_label = "Add Gp Layer as render nodes"
    bl_description = "Create a view_layer for GP > add node > connect to output"
    bl_options = {"REGISTER"}

    @classmethod
    def poll(cls, context):
        return context.object and context.object.type == 'GPENCIL'

    # mode : bpy.props.StringProperty(options={'SKIP_SAVE'})
    node_scene : bpy.props.StringProperty(default='', 
        description='Scene where to add nodes, Abort if not found', options={'SKIP_SAVE'})

    def execute(self, context):
        ret = add_layer_to_render(context.object, node_scene=self.node_scene)
        if isinstance(ret, tuple):
            self.report({ret[0]}, ret[1])
            if ret[0] == 'ERROR':
                return {'CANCELLED'}
        return {"FINISHED"}


def add_object_to_render(mode='ALL', scene='', node_scene=''):
    context = bpy.context

    if scene:
        scn = fn.get_render_scene(scene)
    else:
        scn = fn.get_render_scene()

    if node_scene:
        node_scn = fn.get_compo_scene(scene_name=node_scene, create=True)
        if not node_scn:
            return ('ERROR', f'/!\ Node Scene "{node_scene}" not found ! Abort "Add object to Render" !')
    else:
        # if not passed add in render scene
        node_scn = scn

    excludes = [] # ['MA', 'IN'] # Get list dynamically
    if mode == 'SELECTED':
        gen_vlayer.export_gp_objects([o for o in context.selected_objects if o.type == 'GPENCIL'], exclude_list=excludes, scene=scn, node_scene=node_scn)

    elif mode == 'ALL':
        gen_vlayer.export_gp_objects([o for o in context.scene.objects if o.type == 'GPENCIL' and not o.hide_get() and fn.is_valid_name(o.name)], exclude_list=excludes, scene=scn, node_scene=node_scn)


## send operator with mode ALL or SELECTED to batch build
class GPEXP_OT_add_objects_to_render(bpy.types.Operator):
    bl_idname = "gp.add_object_to_render"
    bl_label = "Add all Gp Layer of active object as render nodes"
    bl_description = "Setup GP object in render scene\
                    \nNote: 'send all' mode skip hidden objects"
    bl_options = {"REGISTER"}

    @classmethod
    def poll(cls, context):
        return context.object and context.object.type == 'GPENCIL'

    mode : bpy.props.EnumProperty(
        items=(
            ('ALL', 'All', 'All objects', 0),
            ('SELECTED', 'Selected', 'Selected objects', 0),
            ),
            default='ALL', options={'SKIP_SAVE'},
            description='Choice to send all or only selected objects')

    scene : bpy.props.StringProperty(default='', 
        description='Scene where to link object and create viewlayer (create if not exists)', options={'SKIP_SAVE'})
    
    node_scene : bpy.props.StringProperty(default='', 
        description='Scene where to add nodes, Abort if not found', options={'SKIP_SAVE'})

    def execute(self, context):
        ret = add_object_to_render(mode=self.mode, scene=self.scene, node_scene=self.node_scene)
        if isinstance(ret, tuple):
            self.report({ret[0]}, ret[1])
            if ret[0] == 'ERROR':
                return {'CANCELLED'}
        return {"FINISHED"}

class GPEXP_OT_split_to_scene(bpy.types.Operator):
    bl_idname = "gp.split_to_scene"
    bl_label = "Split Objects To Scene"
    bl_description = "Take selected objects and send them to separate scene\n(new scene is named after active object)"
    bl_options = {"REGISTER"}

    @classmethod
    def poll(cls, context):
        return context.object and context.object.type == 'GPENCIL'

    mode : bpy.props.StringProperty(default='ALL', options={'SKIP_SAVE'})

    def execute(self, context):
        if self.mode == 'ALL':
            print('split selected object in separated scene')
            err = fn.split_object_to_scene()
            if err:
                self.report({'ERROR'}, err)
                return {"CANCELLED"}

        elif self.mode == 'INDIVIDUAL':
            print('split selected object individually in separated scenes')
            errors = []
            selected_objs = [o for o in context.selected_objects]
            scn = context.scene
            for o in reversed(selected_objs):
                err = fn.split_object_to_scene(objs=[o], scene_name=o.name)
                if err:
                    errors.append(err)
                
                ## Reset to current scene (function use ops and go to new scene)
                context.window.scene = scn

            if errors:
                fn.show_message_box(errors, 'Error Log')
                return {"CANCELLED"}

        return {"FINISHED"}

classes=(
GPEXP_OT_add_layer_to_render,
GPEXP_OT_add_objects_to_render,
GPEXP_OT_split_to_scene,
)

def register():
    for cls in classes:
        bpy.utils.register_class(cls)

def unregister():
    for cls in reversed(classes):
        bpy.utils.unregister_class(cls)