# <pep8 compliant>
#  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 2
#  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, write to the Free Software Foundation,
#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

import os
import bpy
import bpy.utils.previews
import random
import math
import colorsys

from bpy.props import (IntProperty,
                       FloatProperty,
                       FloatVectorProperty,
                       EnumProperty,
                       PointerProperty,
                       )
from bpy.types import (Panel,
                       Operator,
                       PropertyGroup,
                       )


# ----------------------------------------------------------------------------
#    Functions
# ----------------------------------------------------------------------------


def recurLayerCollection(layerColl, collName):
    found = None
    if (layerColl.name == collName):
        return layerColl
    for layer in layerColl.children:
        found = recurLayerCollection(layer, collName)
        if found:
            return found


def save_selected():
    name = bpy.context.view_layer.objects.active.name
    return name


def recall_selected(name):
    if name != '' and name is not None:
        ob = bpy.context.scene.objects[name]
        bpy.ops.object.select_all(action='DESELECT')
        bpy.context.view_layer.objects.active = ob
        ob.select_set(True)


def get_offset():
    x = y = z = 0
    if bpy.context.active_object:
        x, y, z = bpy.context.active_object.location
        return x, y, z


def set_position(type="sphere", number=20, radius=5, height=0,
                 offsetx=0, offsety=0, offsetz=0):
    if type == "sphere" or type == "topsphere":
        latDeg = random.randint(0, 360)
        lonDeg = random.randint(0, 360)
        latRad, lonRad = math.radians(latDeg), math.radians(lonDeg)
        x = math.cos(latRad) * math.cos(lonRad) * radius
        y = math.cos(latRad) * math.sin(lonRad) * radius
        if type == "sphere":
            z = math.sin(latRad) * radius
        elif type == "topsphere":
            z = abs(math.sin(latRad) * radius)
        return x + offsetx, y + offsety, z + offsetz
    elif type == "grid":
        z = height
        di = 1
        dj = 0
        seglen = 1
        x = 0
        y = 0
        segpas = 0
        if number == 0:
            return(0 + offsetx, 0 + offsety, z + offsetz)
        for n in range(number):
            x += di
            y += dj
            segpas = segpas + 1
            if n == number - 1:
                return((radius * x) + offsetx,
                       (radius * y) + offsety,
                       z + offsetz)
            if (segpas == seglen):
                segpas = 0
                buffer = di
                di = -dj
                dj = buffer
                if dj == 0:
                    seglen = seglen + 1


def make_tracker(name, collection, parent, x, y, z):
    tracktarget = bpy.context.scene.objects.get(name)
    if tracktarget:
        pass
    else:
        make_collection(collection, parent, True)
        bpy.ops.object.empty_add(type='SPHERE', radius=3, location=(x, y, z))
        bpy.context.active_object.name = name


def track_to(name):
    bpy.ops.object.constraint_add(type='TRACK_TO')
    bpy.context.object.constraints["Track To"].target = bpy.data.objects[name]
    bpy.context.object.constraints["Track To"].track_axis = 'TRACK_NEGATIVE_Z'
    bpy.context.object.constraints["Track To"].up_axis = 'UP_Y'


def find_collection(name, deselectall=True):
    """not used"""
    if deselectall:
        bpy.ops.object.select_all(action='DESELECT')
        bpy.context.view_layer.objects.active = None
    col = bpy.data.collections.get(name)
    if col:
        for obj in col.objects:
            obj.select_set(True)


def get_active_collection():
    active_coll = bpy.context.view_layer.active_layer_collection
    # probably want to use the .name of the collection like:
    # active_collection = get_active_collection()
    # set_collection(active_collection.name)
    return active_coll


def select_object(name, deselectall=True):
    """not used"""
    if deselectall:
        bpy.ops.object.select_all(action='DESELECT')
        bpy.context.view_layer.objects.active = None
    obj = bpy.context.scene.objects.get(name)
    if obj:
        for n in name:
            bpy.context.view_layer.objects.active = obj
            obj.select_set(True)


def del_all_in_collection(name):
    if bpy.context.blend_data.collections.find(name) > -1:
        delete = bpy.data.collections.get(name)
        for obj in delete.objects:
            bpy.data.objects.remove(obj, do_unlink=True)


def make_collection(name, parent='', active=True):
    # not scene / layer specific, issue, TODO
    if bpy.context.blend_data.collections.find(name) == -1:
        newcoll = bpy.data.collections.new(name)
        if parent:
            parentcoll = bpy.context.scene.collection.children.get(parent)
            parentcoll.children.link(newcoll)
        else:
            bpy.context.scene.collection.children.link(newcoll)
    if active:
        set_collection(name)


def set_collection(name):
    # is scene specific, gets active view layer (scene)
    layer_collection = bpy.context.view_layer.layer_collection
    # print("layer_collection ",layer_collection)
    # print("name ", name)
    layerColl = recurLayerCollection(layer_collection, name)
    # print("layerColl", layerColl)
    bpy.context.view_layer.active_layer_collection = layerColl
    # print("active", bpy.context.view_layer.active_layer_collection)


def make_light(type, color, energy, x, y, z, sizemin='', sizemax='',
               powermin='', powermax=''):
    if type == 'area':
        bpy.ops.object.light_add(type='AREA', radius=1, align='WORLD',
                                 location=(x, y, z))
        bpy.context.object.data.size = random.uniform(sizemin, sizemax)
        bpy.context.object.data.energy = energy * \
            random.uniform(powermin * 10, powermax * 10)
    elif type == 'sun':
        bpy.ops.object.light_add(type='SUN', radius=1, align='WORLD',
                                 location=(x, y, z))
        bpy.context.object.data.angle = \
            random.uniform(sizemin / 2000, sizemax / 2000)
        bpy.context.object.data.energy = energy * \
            random.uniform(powermin / 200, powermax / 200)
    elif type == 'spot':
        bpy.ops.object.light_add(type='SPOT', align='WORLD',
                                 location=(x, y, z))
        bpy.context.object.data.spot_size = \
            random.uniform(sizemin / 10, sizemax / 10)
        bpy.context.object.data.energy = energy * \
            random.uniform(powermin * 400, powermax * 400)
        bpy.context.object.data.spot_blend = 1
    elif type == 'point':
        bpy.ops.object.light_add(type='POINT', radius=1, align='WORLD',
                                 location=(x, y, z))
        bpy.context.object.data.shadow_soft_size = \
            random.uniform(sizemin, sizemax)
        bpy.context.object.data.energy = energy * \
            random.uniform(powermin * 70, powermax * 70)
    if type != 'plane':
        bpy.context.object.data.color = color
    if type == 'plane':
        bpy.ops.mesh.primitive_plane_add(size=random.uniform(sizemin, sizemax),
                                         enter_editmode=False, align='WORLD',
                                         location=(x, y, z))
        # make new material, append to object
        new_mat = bpy.data.materials.new(name="Emit")
        so = bpy.context.active_object
        so.data.materials.append(new_mat)
        new_mat.use_nodes = True
        nodes = new_mat.node_tree.nodes
        material_output = nodes.get("Material Output")
        # set shader to emission
        node_emission = nodes.new(type='ShaderNodeEmission')
        # set emission color
        node_emission.inputs[0].default_value = (color[0],
                                                 color[1],
                                                 color[2], 1)
        # set emission brightness / strength
        node_emission.inputs[1].default_value = energy * \
            random.randint(powermin / 20, powermax / 20)
        # connect the nodes for emission shader
        links = new_mat.node_tree.links
        new_links = links.new(node_emission.outputs[0],
                              material_output.inputs[0])


def set_color(mode, basecolor='', huemin='', huemax='', satmin='',
              satmax='', huespread='', index=''):
    if mode != 'range':
        # convert hue from rgb (blender) to hsv so we can just get the hue
        hsv = colorsys.rgb_to_hsv(basecolor[0], basecolor[1], basecolor[2])
        hue = hsv[0]
        sat = hsv[1]
        # val = hsv[2]
    if mode == 'range':
        # create random hue, saturation for lights, and brightness
        lighthue = random.uniform(huemin, huemax)
        lightsat = random.uniform(satmin, satmax)
        lightval = 1
        lightcolor = colorsys.hsv_to_rgb(lighthue, lightsat, lightval)
    elif mode == 'monochromatic':
        lighthue = hue + (random.uniform(huespread / 100,
                                         - huespread / 100)) + 1
        lightsat = random.uniform(sat * satmin, sat * satmax)
        lightval = random.uniform(0.5, 1.0)
        lightcolor = colorsys.hsv_to_rgb(lighthue, lightsat, lightval)
    elif mode == 'complementary':
        if index % 2 == 0:
            lighthue = hue + (random.uniform(huespread / 100,
                                             -huespread / 100)) + 1
        if ((index + 1) % 2) == 0:
            lighthue = hue + (random.uniform(huespread / 100,
                                             -huespread / 100)) + 1.5
        lightsat = random.uniform(sat * satmin, sat * satmax)
        lightval = random.uniform(0.7, 1.0)
        lightcolor = colorsys.hsv_to_rgb(lighthue, lightsat, lightval)
    elif mode == 'triad':
        if index % 3 == 0:
            lighthue = hue + (random.uniform(huespread / 100,
                                             -huespread / 100)) + 1
        if ((index + 2) % 3) == 0:
            lighthue = hue + (random.uniform(huespread / 100,
                                             -huespread / 100)) + 1.33
        if ((index + 1) % 3) == 0:
            lighthue = hue + (random.uniform(huespread / 100,
                                             -huespread / 100)) + 0.67
        lightsat = random.uniform(sat * satmin, sat * satmax)
        lightval = random.uniform(0.7, 1.0)
        lightcolor = colorsys.hsv_to_rgb(lighthue, lightsat, lightval)
    elif mode == 'split complementary':
        if index % 3 == 0:
            lighthue = hue + (random.uniform(huespread / 100,
                                             -huespread / 100)) + 1
        if ((index + 2) % 3) == 0:
            lighthue = hue + (random.uniform(huespread / 100,
                                             -huespread / 100)) + 1.44
        if ((index + 1) % 3) == 0:
            lighthue = hue + (random.uniform(huespread / 100,
                                             -huespread / 100)) + 0.56
        lightsat = random.uniform(sat * satmin, sat * satmax)
        lightval = random.uniform(0.7, 1.0)
        lightcolor = colorsys.hsv_to_rgb(lighthue, lightsat, lightval)
    elif mode == 'analogous':
        if index % 5 == 0:
            lighthue = hue + 1
        if ((index + 4) % 5) == 0:
            lighthue = hue + (random.uniform(huespread / 10,
                                             -huespread / 10)) + 1
        if ((index + 3) % 5) == 0:
            lighthue = hue - (random.uniform(huespread / 10,
                                             -huespread / 10)) + 1
        if ((index + 2) % 5) == 0:
            lighthue = hue + ((random.uniform(huespread / 10,
                                              -huespread / 10)) * 2) + 1
        if ((index + 1) % 5) == 0:
            lighthue = hue - ((random.uniform(huespread / 10,
                                              -huespread / 10)) * 2) + 1
        lightsat = random.uniform(sat * satmin, sat * satmax)
        lightval = random.uniform(0.7, 1.0)
        lightcolor = colorsys.hsv_to_rgb(lighthue, lightsat, lightval)
    return lightcolor


def purge_unused():
    if (2, 83, 0) <= bpy.app.version <= (2, 91, 99):
        bpy.ops.outliner.orphans_purge()
    elif (2, 92, 0) <= bpy.app.version:
        bpy.ops.outliner.orphans_purge(do_local_ids=True, do_recursive=True)


# ----------------------------------------------------------------------------
#    Scene Properties
# ----------------------------------------------------------------------------

# custom icons for dropdown
preview_collections = {}
# Note that preview collections returned by bpy.utils.previews
# are regular py objects - you can use them to store custom data.
GENESISicons = bpy.utils.previews.new()
# path to the folder where the icon is
# the path is calculated relative to this py file inside the addon folder
# '..' goes up a level, seems to be needed?
# my_icons_dir = os.path.join(os.path.dirname(__file__), '..', "genesis-icons")
my_icons_dir = os.path.join(os.path.dirname(__file__), "genesis-icons")
# load a preview thumbnail of a file and store in the previews collection
GENESISicons.load("icon_mono",
                  os.path.join(my_icons_dir, "monochromatic.png"), 'IMAGE')
GENESISicons.load("icon_comp",
                  os.path.join(my_icons_dir, "complementary.png"), 'IMAGE')
GENESISicons.load("icon_spco",
                  os.path.join(my_icons_dir, "splitcomplementary.png"),
                  'IMAGE')
GENESISicons.load("icon_trid",
                  os.path.join(my_icons_dir, "triad.png"), 'IMAGE')
GENESISicons.load("icon_anlg",
                  os.path.join(my_icons_dir, "analogous.png"), 'IMAGE')
GENESISicons.load("icon_rang",
                  os.path.join(my_icons_dir, "range.png"), 'IMAGE')
preview_collections["main"] = GENESISicons
# create aliases for icon names
customicons = preview_collections["main"]
ic1 = customicons["icon_rang"]
ic2 = customicons["icon_comp"]
ic3 = customicons["icon_trid"]
ic4 = customicons["icon_mono"]
ic5 = customicons["icon_spco"]
ic6 = customicons["icon_anlg"]
# end custom icons for dropdown


class GENESISProperties(PropertyGroup):
    lightmode: EnumProperty(
        name="Light Type:",
        description="Type of light(s) to create",
        items=[('point', "Point Lights", "Emit light in every direction",
                'LIGHT_POINT', 1),
               ('sun', "Sun Lights", "Emit light from an infinite distance",
                'LIGHT_SUN', 2),
               ('spot', "Spot Lights", "Emit light in a cone shape",
                'LIGHT_SPOT', 3),
               ('area', "Area Lights", "Emit light from a plane",
                'LIGHT_AREA', 4),
               ('plane', "Plane Lights", "Emission shader from a plane",
                'MESH_GRID', 5)
               ],
        default='area'
    )

    colormode: EnumProperty(
        name="Color Mode:",
        description="Type of color mode to use for light colors",
        items=[('range', "Range", "Infinite Colors between Min Hue and Max "
                "Hue range on color wheel", ic1.icon_id, 1),
               ('complementary', "Complementary",
                "2 Colors on opposite sides of color wheel", ic2.icon_id, 2),
               ('triad', "Triad", "3 Colors on opposite sides of color wheel",
                ic3.icon_id, 3),
               ('monochromatic', "Monochromatic", "1 Color, all the same hue",
                ic4.icon_id, 4),
               ('split complementary', "Split Complementary",
                "3 Colors on opposite sides of color wheel", ic5.icon_id, 5),
               ('analogous', "Analogous",
                "5 Colors on same side of color wheel", ic6.icon_id, 6)
               ],
        default='range'
    )

    layoutmode: EnumProperty(
        name="Layout Mode:",
        description="How lights should be located in the scene",
        items=[('sphere', "Sphere",
                "Sphere shape layout around the selected object",
                'SPHERE', 1),
               ('topsphere', "Top Sphere",
                "Sphere Shape, but only above the horizon",
                'MATSPHERE', 2),
               ('grid', "Grid",
                "Grid shape layout above the selected object",
                'OUTLINER_DATA_LATTICE', 3)
               ],
        default='sphere'
    )

    lightnumber: IntProperty(
        name="Number",
        description="Total number of lights to create",
        default=9,
        min=1,
        max=200
    )

    lightradius: FloatProperty(
        name="Radius",
        description="Distance between lights and the center point",
        default=40.0,
        min=0.0001,
        max=1000.0
    )

    gridheight: FloatProperty(
        name="Grid Height",
        description="Distance lights are above the horizon",
        default=40.0,
        min=0.0001,
        max=1000.0
    )

    opm: FloatProperty(
        name="Power Multiplier",
        description="Overall light strength",
        default=1.0,
        min=0.01,
        max=1000.0
    )

    basecolor: FloatVectorProperty(
        subtype='COLOR',
        name="Base Color",
        min=0.0,
        max=1.0,
        default=(1.0, 1.0, 0.0)
    )

    huemin: FloatProperty(
        name="Min Hue",
        description="Minimum Hue Value (0 red, 0.3 green, 0.6 blue)",
        default=0.0,
        min=0.0,
        max=1.0
    )

    huemax: FloatProperty(
        name="Max Hue",
        description="Maximum Hue Value (0 red, 0.3 green, 0.6 blue)",
        default=1.0,
        min=0.0,
        max=1.0
    )

    huespread: FloatProperty(
        name="Hue Spread",
        description="Hue Range to pick from",
        default=0.1,
        min=0.0,
        max=15.0
    )

    satmin: FloatProperty(
        name="Min Sat",
        description="Minimum Saturation Value (0 no saturation, "
                    "0.5 medium saturation, 1.0 full saturation)",
        default=0.7,
        min=0.0,
        max=1.0
    )

    satmax: FloatProperty(
        name="Max Sat",
        description="Maximum Saturation Value (0 no saturation, "
                    "0.5 medium saturation, 1.0 full saturation)",
        default=1.0,
        min=0.0,
        max=1.0
    )

    sizemin: FloatProperty(
        name="Min Size",
        description="Minimum light size",
        default=7.0,
        min=0.0001,
        max=1000.0
    )

    sizemax: FloatProperty(
        name="Max Size",
        description="Maximum light size",
        default=15.0,
        min=0.0001,
        max=1000.0
    )

    powermin: FloatProperty(
        name="Min Power",
        description="Minimum light strength",
        default=500.0,
        min=0.0,
        max=1000000.0
    )

    powermax: FloatProperty(
        name="Max Power",
        description="Maximum light strength",
        default=1000.0,
        min=0.0,
        max=1000000.0
    )

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


class WM_OT_GENESISGenerateLights(Operator):

    """Add Lights to the Scene"""
    bl_label = "Generate Lights"
    bl_idname = "wm.genesisgenerate"
    bl_options = {"REGISTER", "UNDO"}

    def execute(self, context):
        scene = context.scene
        lt = scene.genesis_tools

        so = save_selected()
        sox, soy, soz = get_offset()
        active_collection = get_active_collection()
        make_collection("GENESIS")
        del_all_in_collection("GENESISLights")
        purge_unused()
        make_collection("GENESISUtilities", "GENESIS")
        make_tracker("GENESISEmpty", "GENESISUtilities", "GENESIS",
                     sox, soy, soz)
        make_collection("GENESISLights", "GENESIS")
        for l in range(lt.lightnumber):
            x, y, z = set_position(lt.layoutmode, l, lt.lightradius,
                                   lt.gridheight, sox, soy, soz)
            color = set_color(lt.colormode, lt.basecolor,
                              lt.huemin, lt.huemax, lt.satmin, lt.satmax,
                              lt.huespread, l)
            make_light(lt.lightmode, color, lt.opm, x, y, z,
                       lt.sizemin, lt.sizemax, lt.powermin, lt.powermax)
            track_to("GENESISEmpty")
        bpy.ops.object.select_all(action='DESELECT')
        set_collection(active_collection.name)
        recall_selected(so)

        return {'FINISHED'}


class WM_OT_GENESISGenerateLightsWithKeyframes(Operator):

    """Add Lights to the Scene, Keyframed on and off. """ \
        """May take a while to complete if the timeline duration """ \
        """is long. Test with short (less than 10 frame) timelines first"""
    bl_label = "Lights with Keyframes"
    bl_idname = "wm.genesisgeneratekeys"
    bl_options = {"REGISTER", "UNDO"}

    def execute(self, context):
        scene = context.scene
        lt = scene.genesis_tools
        beg = scene.frame_start
        end = scene.frame_end

        so = save_selected()
        sox, soy, soz = get_offset()
        active_collection = get_active_collection()
        make_collection("GENESIS")
        del_all_in_collection("GENESISLights")
        purge_unused()
        make_collection("GENESISUtilities", "GENESIS")
        make_tracker("GENESISEmpty", "GENESISUtilities", "GENESIS",
                     sox, soy, soz)
        make_collection("GENESISLights", "GENESIS")
        for gindex in range(end):
            for l in range(lt.lightnumber):
                x, y, z = set_position(lt.layoutmode, l, lt.lightradius,
                                       lt.gridheight, sox, soy, soz)
                color = set_color(lt.colormode, lt.basecolor,
                                  lt.huemin, lt.huemax, lt.satmin, lt.satmax,
                                  lt.huespread, l)
                make_light(lt.lightmode, color, lt.opm, x, y, z,
                           lt.sizemin, lt.sizemax, lt.powermin, lt.powermax)
                track_to("GENESISEmpty")
                obj = bpy.context.object
                frame = gindex + 1
                previousframe = frame - 1
                nextframe = frame + 1
                obj.hide_render = True
                obj.hide_viewport = True
                obj.keyframe_insert(data_path="hide_render",
                                    frame=previousframe)
                obj.keyframe_insert(data_path="hide_viewport",
                                    frame=previousframe)
                obj.hide_render = False
                obj.hide_viewport = False
                obj.keyframe_insert(data_path="hide_render",
                                    frame=frame)
                obj.keyframe_insert(data_path="hide_viewport",
                                    frame=frame)
                obj.hide_render = True
                obj.hide_viewport = True
                obj.keyframe_insert(data_path="hide_render",
                                    frame=nextframe)
                obj.keyframe_insert(data_path="hide_viewport",
                                    frame=nextframe)
        bpy.ops.object.select_all(action='DESELECT')
        set_collection(active_collection.name)
        recall_selected(so)

        return {'FINISHED'}


# ----------------------------------------------------------------------------
#    Panel in Object Mode
# ----------------------------------------------------------------------------


class OBJECT_PT_CustomPanel(Panel):

    """Generates light creation tools in 3D viewport Sidebar [N]"""
    bl_label = "Genesis"
    bl_idname = "OBJECT_PT_custom_panel"
    bl_space_type = "VIEW_3D"
    bl_region_type = "UI"
    bl_category = "Tool"
    bl_context = "objectmode"

    @classmethod
    def poll(self, context):
        return context.object is not None

    def draw(self, context):
        global custom_icons
        layout = self.layout
        scene = context.scene
        genesistools = scene.genesis_tools
        # duration = scene.frame_end - scene.frame_start

        col = layout.column(align=True)
        # generate lights button
        col.operator("wm.genesisgenerate", icon='LIGHT')
        col.separator()
        # light/color type dropdown
        col.prop(genesistools, "lightmode", text="Type")
        col.prop(genesistools, "colormode", text="Colors")
        col.prop(genesistools, "layoutmode", text="Layout")
        col.prop(genesistools, "lightnumber")
        if genesistools.layoutmode == 'grid':
            col.prop(genesistools, "lightradius", text="Grid Spacing")
            col.prop(genesistools, "gridheight")
        else:
            col.prop(genesistools, "lightradius")
        col.prop(genesistools, "opm")
        if genesistools.colormode == 'range':
            col.label(text="Hue:")
            col.prop(genesistools, "huemin")
            col.prop(genesistools, "huemax")
        else:
            col.prop(genesistools, "basecolor")
            col.prop(genesistools, "huespread")
        col.label(text="Saturation:")
        col.prop(genesistools, "satmin")
        col.prop(genesistools, "satmax")
        if genesistools.lightmode == 'spot':
            col.label(text="Spot Size / Angle:")
        else:
            col.label(text="Size:")
        col.prop(genesistools, "sizemin")
        col.prop(genesistools, "sizemax")
        col.label(text="Power:")
        col.prop(genesistools, "powermin")
        col.prop(genesistools, "powermax")
        col.separator()
        col.operator("wm.genesisgeneratekeys", icon='RENDER_ANIMATION')


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

classes = (
    GENESISProperties,
    WM_OT_GENESISGenerateLights,
    WM_OT_GENESISGenerateLightsWithKeyframes,
    OBJECT_PT_CustomPanel
)


def register():
    from bpy.utils import register_class
    for cls in classes:
        register_class(cls)
    bpy.types.Scene.genesis_tools = PointerProperty(type=GENESISProperties)


def unregister():
    from bpy.utils import unregister_class
    for cls in reversed(classes):
        unregister_class(cls)
    del bpy.types.Scene.genesis_tools
    # remove custom icons
    for GENESISicons in preview_collections.values():
        bpy.utils.previews.remove(GENESISicons)
    preview_collections.clear()


if __name__ == "__main__":
    # The path of this text (if saved)
    __file__ = bpy.context.space_data.text.filepath
    register()