import bpy
from mathutils import Vector, Color
from . import fn

def add_rlayer(layer_name, scene=None, node_scene=None, location=None, color=None, node_name=None, width=400):
    '''Create a render layer node

    args:
    layer_name (str): Name of the viewlayer
    scene (Scene): Scene holding the viewlayer
    node_scene (Scene): scene where to add render layer
        if None: fallback scene pointed by compo scene property
        if compo scene property is empty: fallback to render scene.
    location (Vector2): Location of the node
    color (tuple): Color of the node
    node_name (str): if not specified, use layer_name
    width (int): width of the node
    '''

    if not node_name:
        node_name = layer_name # 'RL_' +

    if not node_scene:
        node_scene=fn.get_compo_scene(create=False)
    if not node_scene:
        node_scene=fn.get_render_scene(create=False)

    nodes = node_scene.node_tree.nodes

    comp = nodes.get(node_name)
    if comp:
        if comp.layer == node_name:
            return comp
        else:
            # TODO : delete rlayer with bad VL name !
            pass

    comp = nodes.new('CompositorNodeRLayers')
    comp.name = node_name
    comp.scene = scene
    comp.layer = layer_name
    comp.label = layer_name
    if location:
        comp.location = location
    if color:
        comp.color = color

    if width:
        comp.width = width
    comp.show_preview = False
    return comp

# FIXME (Maybe just use "base_path")

def connect_render_layer(rlayer, ng=None, out=None, frame=None,
                         base_path=None, file_slot=None, layer_slot=None
                         ):
    '''Connect a render layer node to a fileoutput
    Return existing or created nodegroup and file output nodes

    Args:
        rlayer (node): the renderlayuer node to connect
        ng (node, optional): Nodegroup to connect to if given
        out (node, optional): Fileoutput node to connect to if given
        frame (node, optional): frame node to use as parent if given

        base_path (str, optional): Template for base path when used with EXR
        file_slot (str, optional): Template for slots when used with EXR
        layer_slot (str, optional): Template for slots when used with Multilayer EXR
        File output template strings keyword :
            {object} : Set object name
            {gplayer} : Set Gp layer name

    Return:
        tuple(node, node) Nodegroup node, file_output node
    '''

    multi_base_path = base_path or '//render/{object}/{object}_'
    base_path = base_path or '//render/{object}'
    file_slot = file_slot or '{gplayer}/{gplayer}_'
    layer_slot = layer_slot or '{gplayer}'


    node_tree = rlayer.id_data # get node_tree from rlayer

    nodes = node_tree.nodes
    links = node_tree.links

    vl_name = rlayer.layer
    if not vl_name or vl_name == 'View Layer':
        print(f'Bad layer for node {rlayer.name}')

    if not ' / ' in vl_name:
        print(f'no slash (" / ") separator in vl_name {vl_name}, should be "obj.name / layer_name"')
        return

    obname, lname = vl_name.split(' / ')
    lname = bpy.path.clean_name(lname)

    if not frame:
        if rlayer.parent:
            frame=rlayer.parent
        else:
            print(f'render_layer has not parent frame: {rlayer.name}')
            frame=None

    ng_name = f'NG_{obname}' # only object name


    ## clear nodes groups duplication (.00?)
    fn.clear_nodegroup(ng_name, full_clear=False)

    # get set nodegroup from vlayer name
    if not ng:
        ng = nodes.get(ng_name)

    if not ng:
        ngroup = bpy.data.node_groups.get(ng_name)
        # full clear True if exists but not used
        if ngroup and ngroup.users == 0:
            ngroup = None
            fn.clear_nodegroup(ng_name, full_clear=True)

        if not ngroup:
            # delete and recreate ?
            print(f'create nodegroup {ng_name}')
            ngroup = bpy.data.node_groups.new(ng_name, 'CompositorNodeTree')

        ng = fn.create_node('CompositorNodeGroup', tree=node_tree, location=(fn.real_loc(rlayer)[0] + 600, fn.real_loc(rlayer)[1]), width=400) # (rlayer.location[0] + 600, rlayer.location[1])
        if frame:
            ng.parent= frame
        ng.node_tree = ngroup
        ng.name = ngroup.name

    else:
        ngroup = ng.node_tree
    
    if not (ng_in := ngroup.nodes.get('Group Input')):
        ng_in = fn.create_node('NodeGroupInput', tree=ngroup, location=(-600,0))

    if not (ng_out := ngroup.nodes.get('Group Output')):
        ng_out = fn.create_node('NodeGroupOutput', tree=ngroup, location=(600,0))

    # Connect rlayer to nodegroup
    if not rlayer.outputs['Image'].is_linked:
        sockin = ng.inputs.get(vl_name)
        if not sockin:  
            if bpy.app.version < (4,0,0):
                sockin = ng.node_tree.inputs.new('NodeSocketColor', vl_name)
            else:
                sockin = ng.node_tree.interface.new_socket(vl_name, in_out='INPUT', socket_type='NodeSocketColor')
            sockin = ng.inputs[-1]

        links.new(rlayer.outputs['Image'], sockin)

    ## get nodes from frame
    # rl_nodes = [n for n in nodes if n.type == 'R_LAYERS' and n.layer != 'View Layer' and n.parent == frame]

    # auto clean : if an input exists but is not linked and name not exists in rlayers of current frame

    if bpy.app.version < (4,0,0):
        for s in reversed(ng.inputs):
            if not s.is_linked: # and not any(x.layer == s.name for x in rl_nodes)
                print(f'Removing unlinked input {s.name}')
                ng.inputs.remove(s)
    else:
        g_inputs = [s for s in ngroup.interface.items_tree if s.in_out == 'INPUT']
        # g_outputs = [s for s in ngroup.interface.items_tree if s.in_out == 'OUTPUT']
        for i in range(len(ng.inputs))[::-1]:
            if not ng.inputs[i].is_linked:
                print(f'Removing unlinked input {ng.inputs[i].name}')
                ngroup.interface.remove(g_inputs[i])

    ## get nodes from linked NG inputs ??? maybe more clear...
    # rl_nodes = [s.links[0].from_node for s in ng.inputs if s.links and s.links[0].from_node and s.links[0].from_node.type == 'R_LAYERS']

    ## reorder
    fn.reorder_inputs(ng)
    ng.update()

    # CREATE NG outsocket (individual, without taking merge)
    connected = False

    if ng_in.outputs[vl_name].is_linked:
        # check if connect to the other side
        socket = fn.connect_to_group_output(ng_in.outputs[vl_name].links[0].to_node) #if ng_in.outputs[vl_name].links[0].to_node.type == 'ALPHAOVER':
        if socket:
            connected = True
            groupout = ng.outputs.get(socket.name)

    ng.update()

    if not connected:
        # add AA and connect
        aa = fn.create_aa_nodegroup(ngroup)# fn.new_aa_node(ngroup)
        groupout = ng.outputs.get(vl_name)
        if not groupout:
            if bpy.app.version < (4,0,0):
                ng.node_tree.outputs.new('NodeSocketColor', vl_name) # assigning direcly doesn't link well
            else:
                ng.node_tree.interface.new_socket(vl_name, in_out='OUTPUT', socket_type='NodeSocketColor')

            groupout = ng.outputs[-1]

        # print('ng_out.inputs.get(vl_name): ', ng_out.inputs.get(vl_name))
        # ng_in.outputs[vl_name]
        ngroup.links.new(ng_in.outputs[vl_name], aa.inputs[0]) # node_tree
        ngroup.links.new(aa.outputs[0], ng_out.inputs[vl_name]) # node_tree


        ## Get use_aa prop from render scene ?
        # rd_scn = fn.get_render_scene(create=False)
        # if rd_scn:
        #     aa.mute = rd_scn.gp_render_settings.use_aa # mute if native AA is used
        scene = next((s for s in bpy.data.scenes if s.node_tree == node_tree), None)
        if scene:
            print(f'set AA from scene {scene.name}')
            aa.mute = scene.gp_render_settings.use_aa # mute if native AA is used
        else:
            print('/!\ Scene could not be found to define if internal AA should be muted')

    fn.reorganise_NG_nodegroup(ng) # decorative

    # Clean outputs
    if bpy.app.version < (4,0,0):
        for o in reversed(ngroup.outputs):
            if not o.name in [o.name for o in ngroup.inputs]:
                print(f'removing group output {o.name} (name not exists in group inputs)')
                ngroup.outputs.remove(o)
    else:
        n_outputs = [s for s in ngroup.interface.items_tree if s.in_out == 'OUTPUT']
        n_inputs = [s for s in ngroup.interface.items_tree if s.in_out == 'INPUT']
        for o in reversed(n_outputs):
            if not o.name in [o.name for o in n_inputs]:
                print(f'Removing group output {o.name} (name not exists in group inputs)')
                ngroup.interface.remove(o)

    ng.update()
    # reorder output to match inputs
    fn.reorder_outputs(ng)

    ng.update()

    # Clear : delete orphan nodes that are not connected from ng_in
    for n in reversed(ngroup.nodes):
        if n.type in ('GROUP_INPUT', 'GROUP_OUTPUT'):
            continue
        if not fn.connect_to_group_input(n) and not fn.connect_to_group_output(n): # is disconnected from both side
            ngroup.nodes.remove(n)
        # TODO clear nodes that are disconnected from input side ?

    if groupout.links and groupout.links[0].to_node.type == 'OUTPUT_FILE':
        # if already connected to outfile just skip cause user might have customised the name
        return
    
    out_name = f'OUT_{obname}' # or get output from frame
    out_base = bpy.path.clean_name(obname)

    if not out:
        out = nodes.get(out_name)
    
    if not out:
        # color = (0.2,0.3,0.5)
        out = fn.create_node('CompositorNodeOutputFile', tree=node_tree, location=(fn.real_loc(ng)[0]+500, fn.real_loc(ng)[1]+50), width=600) # =(ng.location[0]+600, ng.location[1]+50)
        fn.set_file_output_format(out)

        out.name = out_name
        out.parent = frame
        
        if out.format.file_format == 'OPEN_EXR_MULTILAYER':
            out.base_path = multi_base_path.format(object=out_base, gplayer=lname)
            # out.base_path = f'//render/{out_base}/{out_base}_'
        else:
            out.base_path = base_path.format(object=out_base, gplayer=lname)
            # out.base_path = f'//render/{out_base}'

    if out.format.file_format == 'OPEN_EXR_MULTILAYER':
        # Direct name in multilayer
        # slot_name = lname
        slot_name = layer_slot.format(object=out_base, gplayer=lname)
    else:
        # base_path/ named_folder/image_####
        # slot_name = f'{lname}/{lname}_'
        slot_name = file_slot.format(object=out_base, gplayer=lname)


    ## out_input = out.inputs.get(slot_name) # Ok for non-numbered outputs

    out_input = None
    out_input = fn.get_numbered_output(out, slot_name)

    if not out_input:
        ## Assigning directly does not work
        # out.file_slots.new(file_slot.format(object=out_base, gplayer=lname))
        # out.layer_slots.new(layer_slot.format(object=out_base, gplayer=lname))

        out.file_slots.new('file_slots_temp_name')
        out.layer_slots.new('layer_slots_temp_name')

        fs = out.file_slots[-1]
        fs.path = file_slot.format(object=out_base, gplayer=lname)

        ls = out.layer_slots[-1]
        ls.name = layer_slot.format(object=out_base, gplayer=lname)
        # out.file_slots.new(slot_name)
        out_input = out.inputs[-1] # assigning directly as above doesn't link afterwards
        # print(f'new filouput entry: {out_input}')

    # link to FileOut
    links.new(groupout, out_input)

    # clean fileout
    fn.clear_disconnected(out) # maybe not disconnect ?
    fn.reorder_fileout(out, ng=ng)

    out.update()
    return ng, out


def clamp_color_value(color, clamp_value=0.65) -> Color:
    '''Return Color instance with clamped value component'''
    color = Color(color)
    color.v = min(color.v, clamp_value)
    return color

def get_set_viewlayer_from_gp(ob, l, scene=None, node_scene=None,
                              base_path=None, file_slot=None, layer_slot=None):
    '''setup ouptut from passed gp obj > layer
        scene: scene to set viewlayer
        node_scene: where to add compo node (use scene if not passed)
    
        base_path (str, optional) : File output Base Path template
        file_slot (str, optional) : File output slot template for individual files
        layer_slot (str, optional) : File output slot for multilayer EXR

    Return:
        viewlayer, render-layer node
    '''

    scene = scene or fn.get_render_scene()
    node_scene = node_scene or fn.get_compo_scene() or scene

    # print('Viewlayer Scene:', scene.name) #Dbg
    # print('Compo Scene:', node_scene.name) #Dbg

    ## If not passed, identical to scene holding viewlayers
    if not node_scene.use_nodes:
        node_scene.use_nodes = True
    node_tree = node_scene.node_tree
    nodes = node_tree.nodes

    in_rds = scene.collection.all_objects.get(ob.name)
    if not in_rds:
        # TODO : ? duplicate the object with name with a specific suffix '_renderdupe' to still parse it ?
        ## make single user if its a multiuser object ? maybe let the user do it
        if ob.data.users > 1:
            print(f'/!!\ {ob.name} data has multiple users ! ({ob.data.users})')
            # ob.data = ob.data.copy() # create duplicate (this will also affect the one in original scene !!!)
        scene.collection.objects.link(ob)
        ob.hide_viewport = ob.hide_render = False

        ## set object active in default viewlayer

        # if (avl := scene.view_layers.get('ViewLayer')):
        #     # This select the object in source scene
        #     avl.objects.active = ob
        #     # avl.objects.active.select_set(True)
        nob = scene.collection.objects.get(ob.name)
        if nob:
            nob.select_set(True)

    # Create viewlayer
    vl_name = f'{ob.name} / {l.info}'
    vl = fn.get_view_layer(vl_name, scene=scene)
    vl_name = vl.name

    ## To avoid potential error, transfer compo scene prop to renderscene.
    scn = bpy.context.scene
    if scn.gp_render_settings.node_scene and scn != scene:
        if scn.gp_render_settings.node_scene != scene.gp_render_settings.node_scene:
            print(f'Transfer compo scene target prop to render scene: "{scn.gp_render_settings.node_scene}"')
            scene.gp_render_settings.node_scene = scn.gp_render_settings.node_scene

    # Affect layer to this vl
    l.viewlayer_render = vl_name

    # Check if already exists
    rlayer_list = [n for n in nodes if n.type == 'R_LAYERS' and n.layer == vl_name]

    # Get frame object and their contents
    # dict model : {objname : [layer_nodeA, layer_nodeB,...]}
    frame_dic = {f.label: [n for n in nodes if n.type == 'R_LAYERS' and n.parent and n.parent.name == f.name and '/' in n.layer] # n.layer != 'View Layer'
        for f in nodes if f.type == 'FRAME'}

    # debug print
    # for k,v in frame_dic.items():
    #     print('-', k)
    #     for n in v:
    #         print('---', n.layer)

    if rlayer_list: # rlayer exists
        print(f'{len(rlayer_list)} nodes using {vl_name}')

        # affect only the one within an object frame
        framed_rl = [n for n in rlayer_list if n.parent and n.parent.label == ob.name]
        if framed_rl:
            if len(framed_rl) > 1:
                print(f'! More than one nodes using {vl_name} in a frame ({len(framed_rl)}) !')

            # sort top to bottom and take upper node
            framed_rl.sort(key=lambda x:x.location.y, reverse=True)
            cp = framed_rl[0]
            cp.select = True # select so the user see that it existed
            return vl, cp

    # Returned if existed and OK

    if not ob.name in frame_dic.keys(): # and len(frame_dic[ob.name])
        print(f'\n{ob.name} -> {l.info} (first generation)')
        # frame not exists, add the RL and frame at the very bottom of all render_layers
        # check position of frame type ? all type ?
        all_frames = [n for n in nodes if n.type == 'FRAME']
        # all_rl_x = [n.location.x for n in nodes if n.type == 'R_LAYERS' and n.layer != 'View Layer']
        if all_frames:
            # all_frames.sort(key=lambda x: x.location.y, reverse=True)
            # loc.y -  dim.y
            y_loc = min(fn.get_frame_transform(f, node_tree)[0].y - fn.get_frame_transform(f, node_tree)[1].y for f in all_frames)
            loc = (0, y_loc)
        else:
            loc = (0,0)

        # create frame at new rl position
        frame = nodes.new('NodeFrame')
        frame.label = ob.name
        frame.label_size = 50
        frame.location = (loc[0], loc[1] + 20)

        cp = add_rlayer(vl_name, scene=scene, node_scene=node_scene, location=loc)
        cp.parent = frame
        # use same color as layer
        if fn.has_channel_color(l):
            cp.use_custom_color = True
            cp.color = clamp_color_value(l.channel_color)

        connect_render_layer(cp, frame=frame,
                             base_path=base_path, file_slot=file_slot, layer_slot=layer_slot)

        fn.rearrange_frames(node_tree)

        return vl, cp

    ## If ob already was used

    print(f'\n {ob.name} -> {l.info} (connect to existing)')

    ## object frame exists: get framing and insert
    cp = add_rlayer(vl_name, scene=scene, node_scene=node_scene, location=(0,0))
    if cp.layer != vl_name:
        print(f'problem with {cp}: {cp.layer} != {vl_name}')
        return

    if fn.has_channel_color(l):
        cp.use_custom_color = True
        cp.color = clamp_color_value(l.channel_color)

    frame = next((f for f in nodes if f.type == 'FRAME' and f.label == ob.name), None)
    rl_nodes = frame_dic[frame.label] # get nodes from
    if rl_nodes:
        # get nodes order to insert
        rl_nodes.sort(key=lambda n: fn.real_loc(n).y, reverse=True) # descending
        top_loc = fn.real_loc(rl_nodes[0])
    else:
        print('!! gen_viewlayer: No Render layers nodes !!')
        top_loc = fn.get_frame_transform(frame, node_tree) - 60

    # cp.location = (top_loc[0], top_loc[1] + 100) # temp location to adjust x loc


    # List of layer names in nodes order
    rl_names = [n.layer.split(' / ')[1] for n in rl_nodes] # Get True layer name from rl
    
    ## Names with the right order WITH the new layer included
    # names = [lay.info for lay in ob.data.layers if lay.info in rl_names or lay == l] # <- Character limit problem
    ## Consider viewlayer name length of 63 char max
    char_limit = 63 - len(ob.name + ' / ')
    names = [lay.info[:char_limit] for lay in ob.data.layers if lay.info[:char_limit] in rl_names or lay == l]
    
    rl_nodes.append(cp)

    # filter by getting index(layer_name)
    cp.parent = frame
    rl_nodes.sort(key=lambda x : names.index(x.layer.split(' / ')[1])) # Sort True layer name from rl

    offset = 0
    # print(f'number of nodes in frame: {len(rl_nodes)}')
    ref_node = rl_nodes[0]

    # print('ref_node: ', ref_node.name, ref_node.location)
    for n in rl_nodes:
        # set x loc from first node in list (maybe use leftmost ?)
        n.location = Vector((fn.real_loc(ref_node)[0], top_loc[1] - offset)) - n.parent.location
        offset += 180
        n.update()

    # reorder render layers nodes within frame
    connect_render_layer(cp, frame=frame,
                        base_path=base_path, file_slot=file_slot, layer_slot=layer_slot)

    # re-arrange all frames (since the offset probably overlapped)
    fn.rearrange_frames(node_tree)

    return vl, cp

def export_gp_objects(oblist, exclude_list=[], scene=None, node_scene=None, base_path=None, file_slot=None, layer_slot=None):
    # Skip layer containing element in exclude list
    if not isinstance(oblist, list):
        oblist = [oblist]
    if isinstance(exclude_list, str):
        exclude_list = [p.strip() for p in exclude_list.split(',')]

    # print('exclude_list: ', exclude_list)

    for ob in oblist:
        for l in ob.data.layers:
            # if l.hide:
            #     continue
            if l.hide or l.opacity == 0 or any(x + '_' in l.info for x in exclude_list):
                print(f'Exclude export: {ob.name} : {l.info}')
                # Assign "exclude" layer
                l.viewlayer_render = fn.get_view_layer('exclude', scene=scene).name
                continue

            get_set_viewlayer_from_gp(ob, l, scene=scene, node_scene=node_scene,
                                      base_path=base_path, file_slot=file_slot, layer_slot=layer_slot)

def add_layer_to_render(ob, node_scene=None, base_path=None, file_slot=None, layer_slot=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

        get_set_viewlayer_from_gp(ob, l, node_scene=node_scene, base_path=base_path, file_slot=file_slot, layer_slot=layer_slot)

        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')


def add_object_to_render(mode='ALL', scene='', node_scene='', base_path=None, file_slot=None, layer_slot=None):
    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':
        export_gp_objects([o for o in context.selected_objects if o.type == 'GPENCIL'], 
                                     exclude_list=excludes, scene=scn, node_scene=node_scn,
                                     base_path=base_path, file_slot=file_slot, layer_slot=layer_slot)

    elif mode == 'ALL':
        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,
                                     base_path=base_path, file_slot=file_slot, layer_slot=layer_slot)
