import bpy
from mathutils import Vector#, Matrix
from pathlib import Path
from math import radians
from .utils import get_gp_objects, set_collection, show_message_box

class GPTB_OT_copy_text(bpy.types.Operator):
    bl_idname = "wm.copytext"
    bl_label = "Copy to clipboard"
    bl_description = "Insert passed text to clipboard"
    bl_options = {"REGISTER", "INTERNAL"}

    text : bpy.props.StringProperty(name="cliptext", description="text to clip", default="")

    def execute(self, context):
        context.window_manager.clipboard = self.text
        mess = f'Clipboard: {context.window_manager.clipboard}'
        self.report({'INFO'}, mess)
        return {"FINISHED"}

class GPTB_OT_flipx_view(bpy.types.Operator):
    bl_idname = "gp.mirror_flipx"
    bl_label = "cam mirror flipx"
    bl_description = "Invert X scale on camera to flip image horizontally"
    bl_options = {"REGISTER"}

    @classmethod
    def poll(cls, context):
        return context.region_data.view_perspective == 'CAMERA'

    def execute(self, context):
        context.scene.camera.scale.x *= -1
        return {"FINISHED"}

class GPTB_OT_rename_data_from_obj(bpy.types.Operator):
    bl_idname = "gp.rename_data_from_obj"
    bl_label = "Rename GP from object"
    bl_description = "Rename the GP datablock with the same name as the object"
    bl_options = {"REGISTER"}

    rename_all : bpy.props.BoolProperty(default=False)

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

    def execute(self, context):
        if not self.rename_all:
            obj = context.object
            if obj.name == obj.data.name:
                self.report({'WARNING'}, 'Nothing to rename')
                return {"FINISHED"}
            old = obj.data.name
            obj.data.name = obj.name
            self.report({'INFO'}, f'GP data renamed: {old} -> {obj.data.name}')
        else:
            oblist = []
            for o in context.scene.objects:
                if o.type == 'GPENCIL':
                    if o.name == o.data.name:
                        continue
                    oblist.append(f'{o.data.name} -> {o.name}')
                    o.data.name = o.name
            print('\nrenamed GP datablock:')
            for i in oblist:
                print(i)
            self.report({'INFO'}, f'{len(oblist)} data renamed (see console for detail)')
            
        return {"FINISHED"}

# TODO make secondary cam
# 2 solution : 
# - parenting to main cam except for roll axis (drivers or simple parents)
# - Facing current "peg" (object) and parented to it to keep distance
# --> reset roll means aligning to object again (to main camera if one) or maybe align to global Z (as possible).

# other solution, button to disable all object Fcu evaluation (fix object movement while moving in timeline)

# 1 ops to enter in manip/draw Cam (create if not exists)
# 1 ops to reset rotation
# 1 ops to swap between cam follow or object follow (toggle or two button), maybe accessible only when drawcam is active

# hide camera that isn't used (playblast should always get main camera)

def get_gp_alignement_vector(context):
#SETTINGS
    settings = context.scene.tool_settings
    orient = settings.gpencil_sculpt.lock_axis#'VIEW', 'AXIS_Y', 'AXIS_X', 'AXIS_Z', 'CURSOR'
    loc = settings.gpencil_stroke_placement_view3d#'ORIGIN', 'CURSOR', 'SURFACE', 'STROKE'

    ### CHOOSE HOW TO PROJECT

    """ # -> placement
    if loc == "CURSOR":
        plane_co = scn.cursor.location
    else:#ORIGIN (also on origin if set to 'SURFACE', 'STROKE')
        plane_co = obj.location """

    # -> orientation
    if orient == 'VIEW':
        #only depth is important, no need to get view vector
        return None

    elif orient == 'AXIS_Y':#front (X-Z)
        return Vector((0,1,0))

    elif orient == 'AXIS_X':#side (Y-Z)
        return Vector((1,0,0))

    elif orient == 'AXIS_Z':#top (X-Y)
        return Vector((0,0,1))

    elif orient == 'CURSOR':
        return Vector((0,0,1))#.rotate(context.scene.cursor.matrix)

class GPTB_OT_draw_cam(bpy.types.Operator):
    bl_idname = "gp.draw_cam_switch"
    bl_label = "Draw cam switch"
    bl_description = "switch between main camera and draw (manipulate) camera"
    bl_options = {"REGISTER"}

    @classmethod
    def poll(cls, context):
        return context.scene.camera
        # return context.region_data.view_perspective == 'CAMERA'# check if in camera
    
    cam_mode : bpy.props.StringProperty()

    def execute(self, context):
        created=False
        
        if self.cam_mode == 'draw':
            dcam_name = 'draw_cam'
        else:
            dcam_name = 'obj_cam'
            act = context.object
            if not act:
                self.report({'ERROR'}, "No active object to lock on")
                return {"CANCELLED"}
            
            if context.region_data.view_perspective == 'ORTHO':
                self.report({'ERROR'}, "Can't be set in othographic view, swith to persp (numpad 5)")
                return {"CANCELLED"}

        camcol_name = 'manip_cams'
        if not context.scene.camera:
            self.report({'ERROR'}, "No camera to return to")
            return {"CANCELLED"}

        ## if already in draw_cam BACK to main camera
        if context.scene.camera.name in ('draw_cam', 'obj_cam'):
            drawcam = context.scene.camera
            # get main cam and error if not available
            if drawcam.name == 'draw_cam':
                maincam = drawcam.parent
            
            else:
                maincam = None
                main_name = drawcam.get('maincam_name')# Custom prop with previous avtive cam.
                if main_name:
                    maincam = context.scene.objects.get(main_name)

                if not maincam:
                    cams = [ob for ob in context.scene.objects if ob.type == 'CAMERA' and not ob.name in ("draw_cam", "obj_cam")]
                    if not cams:
                        self.report({'ERROR'}, "Can't find any other camera to switch to...")
                        return {"CANCELLED"}
                    maincam = cams[0]
            
            # dcam_col = bpy.data.collections.get(camcol_name)
            # if not dcam_col:
            set_collection(drawcam, camcol_name)
            
            # Swap to it, unhide if necessary and hide previous 
            context.scene.camera = maincam
            
            ## hide cam object 
            drawcam.hide_viewport = True
            maincam.hide_viewport = False

        ## if in main camera GO to drawcam
        elif context.scene.camera.name not in ('draw_cam', 'obj_cam'):
            # use current cam as main cam (more flexible than naming convention)
            maincam = context.scene.camera
            drawcam = context.scene.objects.get(dcam_name)
            
            if not drawcam:
                created=True
                drawcam = bpy.data.objects.new(dcam_name, context.scene.camera.data)
                drawcam.show_name = True
                set_collection(drawcam, 'manip_cams')
            
            if dcam_name == 'draw_cam':
                drawcam.parent = maincam
                if created:#set to main at creation time
                    drawcam.matrix_world = maincam.matrix_world
                drawcam.lock_location = (True,True,True)
            
            else:
                if created:
                    drawcam['maincam_name'] = context.scene.camera.name
                    drawcam.parent = act
                    drawcam.matrix_world = context.space_data.region_3d.view_matrix.inverted()
                    # Place cam from current view
                    '''
                    drawcam.parent = act
                    vec = Vector((0,1,0))

                    if act.type == 'GPENCIL':
                        #change vector according to alignement
                        vec = get_gp_alignement_vector(context)
                    
                    vec = None #!# FORCE creation of cam at current viewpoint
                    if vec:
                        # Place drawcam at distance at standard distance from the object facing it
                        drawcam.location = act.matrix_world @ (vec * -6)
                        drawcam.rotation_euler = act.rotation_euler
                        drawcam.rotation_euler.x -= radians(-90)
                    else:
                        #Create cam at view point
                        drawcam.matrix_world = context.space_data.region_3d.view_matrix.inverted()
                    ''' 

            ## hide cam object 
            context.scene.camera = drawcam
            drawcam.hide_viewport = False
            maincam.hide_viewport = True
            
            if created and drawcam.name == 'obj_cam':#Go in camera view
                context.region_data.view_perspective = 'CAMERA'
            # ## make active
            # bpy.context.view_layer.objects.active = ob
            
        return {"FINISHED"}


class GPTB_OT_set_view_as_cam(bpy.types.Operator):
    bl_idname = "gp.set_view_as_cam"
    bl_label = "Cam at view"
    bl_description = "Place the active camera at current viewpoint, parent to active object. (need to be out of camera)"
    bl_options = {"REGISTER"}

    @classmethod
    def poll(cls, context):
        return context.region_data.view_perspective != 'CAMERA'# need to be out of  camera
        # return context.scene.camera and not context.scene.camera.name.startswith('Cam')
  
    def execute(self, context):
        if context.region_data.view_perspective == 'ORTHO':
            self.report({'ERROR'}, "Can't be set in othographic view")
            return {"CANCELLED"}
            ## switching to persp work in 2 times, but need update before...
            #context.area.tag_redraw()
            #context.region_data.view_perspective = 'PERSP'

        cam = context.scene.camera
        if not cam:
            self.report({'ERROR'}, "No camera to set")
            return {"CANCELLED"}

        obj = context.object
        if obj and obj.type != 'CAMERA':# parent to object
            cam.parent = obj
        
        if not cam.parent:
            self.report({'WARNING'}, "No parents...")


        # set view
        cam.matrix_world = context.space_data.region_3d.view_matrix.inverted()
        # Enter in cam view
        #https://blender.stackexchange.com/questions/30643/how-to-toggle-to-camera-view-via-python
        context.region_data.view_perspective = 'CAMERA'
        
        return {"FINISHED"}


class GPTB_OT_reset_cam_rot(bpy.types.Operator):
    bl_idname = "gp.reset_cam_rot"
    bl_label = "Reset rotation"
    bl_description = "Reset rotation of the draw manipulation camera"
    bl_options = {"REGISTER"}

    @classmethod
    def poll(cls, context):
        return context.scene.camera and not context.scene.camera.name.startswith('Cam')
        # return context.region_data.view_perspective == 'CAMERA'# check if in camera
    
    def execute(self, context):
        # dcam_name = 'draw_cam'
        # camcol_name = 'manip_cams'
        drawcam = context.scene.camera
        if drawcam.parent.type == 'CAMERA':
            ## align to parent camera
            drawcam.matrix_world = drawcam.parent.matrix_world#wrong, get the parent rotation offset
            # drawcam.rotation_euler = drawcam.parent.rotation_euler#wrong, get the parent rotation offset
        elif drawcam.parent:
            ## there is a parent, so align the Y of the camera to object's Z
            # drawcam.rotation_euler.rotate(drawcam.parent.matrix_world)# wrong
            pass
        else:
            self.report({'ERROR'}, "No parents to refer to for rotation reset")
            return {"CANCELLED"}
            
            
        return {"FINISHED"}

class GPTB_OT_toggle_mute_animation(bpy.types.Operator):
    bl_idname = "gp.toggle_mute_animation"
    bl_label = "Toggle animation mute"
    bl_description = "Enable/Disable animation evaluation\n(shift+clic to affect selection only)"
    bl_options = {"REGISTER"}

    
    mute : bpy.props.BoolProperty(default=False)
    skip_gp : bpy.props.BoolProperty(default=False)
    skip_obj : bpy.props.BoolProperty(default=False)

    def invoke(self, context, event):
        self.selection = event.shift
        return self.execute(context)

    def execute(self, context):

        if self.selection:
            pool = context.selected_objects
        else:
            pool = context.scene.objects

        for o in pool:
            if self.skip_gp and o.type == 'GPENCIL':
                continue
            if self.skip_obj and o.type != 'GPENCIL':
                continue

            if not o.animation_data:
                continue
            act = o.animation_data.action
            if not act:
                continue

            for i, fcu in enumerate(act.fcurves):
                print(i, fcu.data_path, fcu.array_index)
                fcu.mute = self.mute

        return {'FINISHED'}

class GPTB_OT_list_disabled_anims(bpy.types.Operator):
    bl_idname = "gp.list_disabled_anims"
    bl_label = "List disabled anims"
    bl_description = "List disabled animations channels in scene. (shit+clic to list only on seleciton)"
    bl_options = {"REGISTER"}

    mute : bpy.props.BoolProperty(default=False)
    # skip_gp : bpy.props.BoolProperty(default=False)
    # skip_obj : bpy.props.BoolProperty(default=False)

    def invoke(self, context, event):
        self.selection = event.shift
        return self.execute(context)

    def execute(self, context):
        li = []
        oblist = []
        if self.selection:
            pool = context.selected_objects
        else:
            pool = context.scene.objects

        for o in pool:
            # if self.skip_gp and o.type == 'GPENCIL':
            #     continue
            # if self.skip_obj and o.type != 'GPENCIL':
            #     continue
            if not o.animation_data:
                continue
            act = o.animation_data.action
            if not act:
                continue
            for i, fcu in enumerate(act.fcurves):
                # print(i, fcu.data_path, fcu.array_index)
                if fcu.mute:
                    if o not in oblist:
                        oblist.append(o)
                        li.append(f'{o.name} : {fcu.data_path} {fcu.array_index}')
                    else:
                        li.append(f'{" "*len(o.name)}  - {fcu.data_path} {fcu.array_index}')
        if li:
            show_message_box(li)
        else:
            self.report({'INFO'}, f"No animation disabled on {'selection' if self.selection else 'scene'}")
        return {'FINISHED'}


## TODO presets are still not used... need to make a custom preset save/remove/quickload manager to be efficient (UIlist ?)

class GPTB_OT_overlay_presets(bpy.types.Operator):
    bl_idname = "gp.overlay_presets"
    bl_label = "Overlay presets"
    bl_description = "Overlay save/load presets for showing only whats needed"
    bl_options = {"REGISTER"}

    # @classmethod
    # def poll(cls, context):
    #     return context.region_data.view_perspective == 'CAMERA'
    val_dic = {}
    
    def execute(self, context):
        self.zones = [bpy.context.space_data.overlay]
        exclude = (
        ### add lines here to exclude specific attribute
        'bl_rna', 'identifier','name_property','rna_type','properties', 'compare', 'to_string',#basic
        )
        if not self.val_dic:
            ## store attribute of data_path in self.zones list.
            for data_path in self.zones:
                self.val_dic[data_path] = {}
                for attr in dir(data_path):#iterate in attribute of given datapath
                    if attr not in exclude and not attr.startswith('__') and not callable(getattr(data_path, attr)) and not data_path.is_property_readonly(attr):
                        self.val_dic[data_path][attr] = getattr(data_path, attr)
            # Do tomething with the dic (backup to a json ?)

        else:
            ## restore attribute from self.zones list
            for data_path, prop_dic in self.val_dic.items():
                for attr, val in prop_dic.items():
                    try:
                        setattr(data_path, attr, val)
                    except Exception as e:
                        print(f"/!\ Impossible to re-assign: {attr} = {val}")
                        print(e)
        '''
        overlay = context.space_data.overlay
        # still need ref
        
        overlay.show_extras = not val
        overlay.show_outline_selected = val
        overlay.show_object_origins = val
        overlay.show_motion_paths = val
        overlay.show_relationship_lines = val
        overlay.show_bones = val
        overlay.show_annotation = val
        overlay.show_text = val
        overlay.show_cursor = val
        overlay.show_floor = val
        overlay.show_axis_y = val
        overlay.show_axis_x = val
        '''
        
        return {'FINISHED'}

classes = (
GPTB_OT_copy_text,
GPTB_OT_flipx_view,
GPTB_OT_rename_data_from_obj,
GPTB_OT_draw_cam,
GPTB_OT_set_view_as_cam,
GPTB_OT_reset_cam_rot,
GPTB_OT_toggle_mute_animation,
GPTB_OT_list_disabled_anims,
)

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

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