bl_info = {
    "name": "Reload Linked Libraries",
    "author": "Jean-Marie Rudent + ia",
    "version": (1, 0),
    "blender": (4, 4, 0),
    "location": "Outliner > Header",
    "description": "Adds a button to the Outliner header to reload all linked libraries (bpy.data.libraries)",
    "category": "System",
}

import bpy

# Operator to reload linked libraries
class WM_OT_reload_linked_libraries(bpy.types.Operator):
    bl_idname = "wm.reload_linked_libraries"
    bl_label = "Reload Linked Libraries"
    bl_description = "Reloads all linked libraries (bpy.data.libraries)"
    
    def execute(self, context):
        count = 0
        for lib in bpy.data.libraries:
            try:
                lib.reload()
                count += 1
            except Exception as e:
                self.report({'WARNING'}, f"Failed to reload {lib.filepath}: {str(e)}")
        self.report({'INFO'}, f"{count} library/libraries reloaded")
        return {'FINISHED'}

# Draw function to add the button to the Outliner header
def draw_reload_button(self, context):
    layout = self.layout
    layout.operator("wm.reload_linked_libraries", text="Reload Libraries", icon='FILE_REFRESH')

# Register classes and add the button to the Outliner header
def register():
    bpy.utils.register_class(WM_OT_reload_linked_libraries)
    bpy.types.OUTLINER_HT_header.append(draw_reload_button)

def unregister():
    bpy.types.OUTLINER_HT_header.remove(draw_reload_button)
    bpy.utils.unregister_class(WM_OT_reload_linked_libraries)

if __name__ == "__main__":
    register()

bl_info = {
    "name": "Global Color Palettes",
    "version": (1, 4, 1),
    "description": "A global color library for Blender with multiple colors per palette, stored in a user-defined JSON file.",
    "author": "Jean-Marie Rudent (modified by Gemini)",
    "blender": (4, 2, 0),
    "location": "Shader Editor > Color Library",
    "warning": "",
    "category": "Material"
}

import bpy
import json
import os

# -----------------------------
# Data Structures
# -----------------------------

def update_palette(self, context):
    context.scene.palettes_modified = True

def update_color_item(self, context):
    context.scene.palettes_modified = True

class ColorItem(bpy.types.PropertyGroup):
    name: bpy.props.StringProperty(name="Name", default="Color", update=update_color_item)
    color: bpy.props.FloatVectorProperty(
        name="Color",
        size=4,
        min=0.0,
        max=1.0,
        default=(1.0, 1.0, 1.0, 1.0),
        subtype='COLOR',
        update=update_color_item
    )

class ColorPalette(bpy.types.PropertyGroup):
    name: bpy.props.StringProperty(name="Name", update=update_palette)
    colors: bpy.props.CollectionProperty(type=ColorItem)

# -----------------------------
# Addon Preferences
# -----------------------------

class ColorPalettesAddonPreferences(bpy.types.AddonPreferences):
    bl_idname = __name__

    global_config_path: bpy.props.StringProperty(
        name="Global Color Palette File",
        subtype='FILE_PATH',
        default="",
        description="Path to the JSON file storing global color palettes"
    )

# -----------------------------
# UI Panel
# -----------------------------

class COLOR_LIBRARY_PT_panel(bpy.types.Panel):
    bl_idname = "COLOR_LIBRARY_PT_panel"
    bl_label = "Color Palettes"
    bl_space_type = 'NODE_EDITOR'
    bl_region_type = 'UI'
    bl_category = 'Color Palettes'

    def draw(self, context):
        layout = self.layout
        scene = context.scene
        prefs = context.preferences.addons[__name__].preferences

        layout.label(text="Configuration File:")
        row = layout.row()
        row.prop(prefs, "global_config_path", text="")
        row = layout.row()
        row.operator("color_library.load_global_config", text="Load Palettes")
        layout.separator()

        row = layout.row()
        row.template_list("COLOR_LIBRARY_UL_list", "", scene, "color_palettes", scene, "color_palette_index")

        row = layout.row()
        row.operator("color_library.add_palette", text="Add Palette")
        row.operator("color_library.delete_palette", text="Delete Palette")

        layout.separator()
        row = layout.row()
        save_text = "Save Palettes"
        if scene.palettes_modified:
            save_text += " *"
        row.operator("color_library.save_global_config", text=save_text)

        if scene.color_palette_index >= 0 and len(scene.color_palettes) > 0:
            palette = scene.color_palettes[scene.color_palette_index]
            layout.prop(palette, "name")
            box = layout.box()
            for color in palette.colors:
                row = box.row(align=True)
                row.prop(color, "name", text="")
                row.prop(color, "color", text="")

class COLOR_LIBRARY_UL_list(bpy.types.UIList):
    def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
        if self.layout_type in {'DEFAULT', 'COMPACT'}:
            layout.label(text=item.name)
        elif self.layout_type == 'GRID':
            layout.alignment = 'CENTER'
            layout.label(text="")

# -----------------------------
# Operators
# -----------------------------

class COLOR_LIBRARY_OT_add_palette(bpy.types.Operator):
    bl_idname = "color_library.add_palette"
    bl_label = "Add Palette"

    def execute(self, context):
        scene = context.scene
        new_palette = scene.color_palettes.add()
        new_palette.name = f"Palette {len(scene.color_palettes)}"
        for i in range(10):
            new_color = new_palette.colors.add()
            new_color.name = f"Color {i+1}"
            new_color.color = (1.0, 1.0, 1.0, 1.0)
        context.scene.palettes_modified = True
        return {'FINISHED'}

class COLOR_LIBRARY_OT_delete_palette(bpy.types.Operator):
    bl_idname = "color_library.delete_palette"
    bl_label = "Delete Palette"

    def execute(self, context):
        scene = context.scene
        if scene.color_palette_index >= 0 and len(scene.color_palettes) > 0:
            scene.color_palettes.remove(scene.color_palette_index)
            scene.color_palette_index = min(scene.color_palette_index, len(scene.color_palettes) - 1)
        context.scene.palettes_modified = True
        return {'FINISHED'}

class COLOR_LIBRARY_OT_add_color(bpy.types.Operator):
    bl_idname = "color_library.add_color"
    bl_label = "Add Color"
    index: bpy.props.IntProperty()

    def execute(self, context):
        scene = context.scene
        if scene.color_palette_index >= 0 and len(scene.color_palettes) > 0:
            palette = scene.color_palettes[scene.color_palette_index]
            new_color = palette.colors.add()
            new_color.name = f"Color {len(palette.colors)}"
            new_color.color = (1.0, 1.0, 1.0, 1.0)
        context.scene.palettes_modified = True
        return {'FINISHED'}

class COLOR_LIBRARY_OT_load_global_config(bpy.types.Operator):
    bl_idname = "color_library.load_global_config"
    bl_label = "Load Palettes"

    def execute(self, context):
        load_global_config_function(context)
        context.scene.palettes_modified = False
        return {'FINISHED'}

class COLOR_LIBRARY_OT_save_global_config(bpy.types.Operator):
    bl_idname = "color_library.save_global_config"
    bl_label = "Save Palettes"

    def execute(self, context):
        save_global_config_function(context)
        context.scene.palettes_modified = False
        return {'FINISHED'}

# -----------------------------
# Config Load/Save (global)
# -----------------------------

def load_global_config_function(context):
    prefs = context.preferences.addons[__name__].preferences
    config_file_path = prefs.global_config_path

    if not config_file_path:
        print("[ColorPalettes] Global config path not set.")
        return

    if hasattr(bpy.context, 'scene'):
        scene = bpy.context.scene
        if os.path.exists(config_file_path):
            with open(config_file_path, 'r') as file:
                try:
                    config = json.load(file)
                    scene.color_palettes.clear()
                    for palette_data in config.get('palettes', []):
                        new_palette = scene.color_palettes.add()
                        new_palette.name = palette_data.get('name', '')
                        for color_data in palette_data.get('colors', []):
                            new_color = new_palette.colors.add()
                            new_color.name = color_data.get('name', 'Color')
                            new_color.color = tuple(color_data.get('color', [1.0, 1.0, 1.0, 1.0]))
                    print(f"[ColorPalettes] Palettes loaded from: {config_file_path}")
                except json.JSONDecodeError as e:
                    print(f"[ColorPalettes] Failed to load config (invalid JSON): {e}")
                except Exception as e:
                    print(f"[ColorPalettes] Failed to load config: {e}")
        else:
            print(f"[ColorPalettes] Global config file not found: {config_file_path}")

def save_global_config_function(context):
    prefs = context.preferences.addons[__name__].preferences
    config_file_path = prefs.global_config_path

    if not config_file_path:
        print("[ColorPalettes] Global config path not set.")
        return

    if hasattr(bpy.context, 'scene'):
        scene = bpy.context.scene
        config = {'palettes': []}
        for palette in scene.color_palettes:
            palette_data = {
                'name': palette.name,
                'colors': []
            }
            for color in palette.colors:
                palette_data['colors'].append({
                    'name': color.name,
                    'color': list(color.color)
                })
            config['palettes'].append(palette_data)
        try:
            os.makedirs(os.path.dirname(config_file_path), exist_ok=True)
            with open(config_file_path, 'w') as file:
                json.dump(config, file, indent=4)
            print(f"[ColorPalettes] Palettes saved to: {config_file_path}")
        except Exception as e:
            print(f"[ColorPalettes] Failed to save config: {e}")

# -----------------------------
# Registration
# -----------------------------

classes = (
    ColorItem,
    ColorPalette,
    ColorPalettesAddonPreferences,
    COLOR_LIBRARY_PT_panel,
    COLOR_LIBRARY_UL_list,
    COLOR_LIBRARY_OT_add_palette,
    COLOR_LIBRARY_OT_delete_palette,
    COLOR_LIBRARY_OT_add_color,
    COLOR_LIBRARY_OT_load_global_config,
    COLOR_LIBRARY_OT_save_global_config,
)

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

    bpy.types.Scene.color_palettes = bpy.props.CollectionProperty(type=ColorPalette)
    bpy.types.Scene.color_palette_index = bpy.props.IntProperty(name="Palette Index")
    bpy.types.Scene.palettes_modified = bpy.props.BoolProperty(default=False)

    # Load config on register (Blender startup if addon is enabled)
    if bpy.context:
        load_global_config_function(bpy.context)

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

    if hasattr(bpy.types.Scene, "color_palettes"):
        del bpy.types.Scene.color_palettes
    if hasattr(bpy.types.Scene, "color_palette_index"):
        del bpy.types.Scene.color_palette_index
    if hasattr(bpy.types.Scene, "palettes_modified"):
        del bpy.types.Scene.palettes_modified

if __name__ == "__main__":
    register()