"""
Copyright (C) 2019 Remington Creative

This file is part of Atomic Data Manager.

Atomic Data Manager 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 3 of the
License, or (at your option) any later version.

Atomic Data Manager 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 Atomic Data Manager.  If not, see <https://www.gnu.org/licenses/>.

---

This file contains the operators used in the inspection UI's header.
This includes the rename, replace, toggle fake user, delete, and duplicate
operators.

"""

import bpy
from bpy.utils import register_class
from bpy.utils import unregister_class
from atomic_data_manager.ops.utils import delete
from atomic_data_manager.ops.utils import duplicate


# Atomic Data Manager Inspection Rename Operator
class ATOMIC_OT_inspection_rename(bpy.types.Operator):
    """Give this data-block a new name"""
    bl_idname = "atomic.rename"
    bl_label = "Rename Data-Block"

    def draw(self, context):
        atom = bpy.context.scene.atomic

        layout = self.layout
        row = layout.row()
        row.prop(atom, "rename_field", text="", icon="GREASEPENCIL")

    def execute(self, context):
        atom = bpy.context.scene.atomic
        inspection = atom.active_inspection

        name = atom.rename_field

        if inspection == 'COLLECTIONS':
            bpy.data.collections[atom.collections_field].name = name
            atom.collections_field = name

        if inspection == 'IMAGES':
            bpy.data.images[atom.images_field].name = name
            atom.images_field = name

        if inspection == 'LIGHTS':
            bpy.data.lights[atom.lights_field].name = name
            atom.lights_field = name

        if inspection == 'MATERIALS':
            bpy.data.materials[atom.materials_field].name = name
            atom.materials_field = name

        if inspection == 'NODE_GROUPS':
            bpy.data.node_groups[atom.node_groups_field].name = name
            atom.node_groups_field = name

        if inspection == 'PARTICLES':
            bpy.data.particles[atom.particles_field].name = name
            atom.particles_field = name

        if inspection == 'TEXTURES':
            bpy.data.textures[atom.textures_field].name = name
            atom.textures_field = name

        if inspection == 'WORLDS':
            bpy.data.worlds[atom.worlds_field].name = name
            atom.worlds_field = name

        atom.rename_field = ""
        return {'FINISHED'}

    def invoke(self, context, event):
        wm = context.window_manager
        return wm.invoke_props_dialog(self, width=200)


# Atomic Data Manager Inspection Replaces Operator
class ATOMIC_OT_inspection_replace(bpy.types.Operator):
    """Replace all instances of this data-block with another data-block"""
    bl_idname = "atomic.replace"
    bl_label = "Replace Data-Block"

    def draw(self, context):
        atom = bpy.context.scene.atomic
        inspection = atom.active_inspection

        layout = self.layout
        row = layout.row()

        if inspection == 'IMAGES':
            row.prop_search(
                atom,
                "replace_field",
                bpy.data,
                "images",
                text=""
            )

        if inspection == 'LIGHTS':
            row.prop_search(
                atom,
                "replace_field",
                bpy.data,
                "lights",
                text=""
            )

        if inspection == 'MATERIALS':
            row.prop_search(
                atom,
                "replace_field",
                bpy.data,
                "materials",
                text=""
            )

        if inspection == 'NODE_GROUPS':
            row.prop_search(
                atom,
                "replace_field",
                bpy.data,
                "node_groups",
                text=""
            )

        if inspection == 'PARTICLES':
            row.prop_search(
                atom,
                "replace_field",
                bpy.data,
                "particles",
                text=""
            )

        if inspection == 'TEXTURES':
            row.prop_search(
                atom,
                "replace_field",
                bpy.data,
                "textures",
                text=""
            )

        if inspection == 'WORLDS':
            row.prop_search(
                atom,
                "replace_field",
                bpy.data,
                "worlds",
                text=""
            )

    def execute(self, context):
        atom = bpy.context.scene.atomic
        inspection = atom.active_inspection

        if inspection == 'IMAGES' and \
                atom.replace_field in bpy.data.images.keys():
            bpy.data.images[atom.images_field].user_remap(
                bpy.data.images[atom.replace_field])
            atom.images_field = atom.replace_field

        if inspection == 'LIGHTS' and \
                atom.replace_field in bpy.data.lights.keys():
            bpy.data.lights[atom.lights_field].user_remap(
                bpy.data.lights[atom.replace_field])
            atom.lights_field = atom.replace_field

        if inspection == 'MATERIALS' and \
                atom.replace_field in bpy.data.materials.keys():
            bpy.data.materials[atom.materials_field].user_remap(
                bpy.data.materials[atom.replace_field])
            atom.materials_field = atom.replace_field

        if inspection == 'NODE_GROUPS' and \
                atom.replace_field in bpy.data.node_groups.keys():
            bpy.data.node_groups[atom.node_groups_field].user_remap(
                bpy.data.node_groups[atom.replace_field])
            atom.node_groups_field = atom.replace_field

        if inspection == 'PARTICLES' and \
                atom.replace_field in bpy.data.particles.keys():
            bpy.data.particles[atom.particles_field].user_remap(
                bpy.data.particles[atom.replace_field])
            atom.particles_field = atom.replace_field

        if inspection == 'TEXTURES' and \
                atom.replace_field in bpy.data.textures.keys():
            bpy.data.textures[atom.textures_field].user_remap(
                bpy.data.textures[atom.replace_field])
            atom.textures_field = atom.replace_field

        if inspection == 'WORLDS' and \
                atom.replace_field in bpy.data.worlds.keys():
            bpy.data.worlds[atom.worlds_field].user_remap(
                bpy.data.worlds[atom.replace_field])
            atom.worlds_field = atom.replace_field

        atom.replace_field = ""
        return {'FINISHED'}

    def invoke(self, context, event):
        wm = context.window_manager
        return wm.invoke_props_dialog(self, width=200)


# Atomic Data Manager Inspection Toggle Fake User Operator
class ATOMIC_OT_inspection_toggle_fake_user(bpy.types.Operator):
    """Save this data-block even if it has no users"""
    bl_idname = "atomic.toggle_fake_user"
    bl_label = "Toggle Fake User"

    def execute(self, context):
        atom = bpy.context.scene.atomic
        inspection = atom.active_inspection

        if inspection == 'IMAGES':
            image = bpy.data.images[atom.images_field]
            bpy.data.images[atom.images_field].use_fake_user = \
                not image.use_fake_user

        if inspection == 'LIGHTS':
            light = bpy.data.lights[atom.lights_field]
            bpy.data.lights[atom.lights_field].use_fake_user = \
                not light.use_fake_user

        if inspection == 'MATERIALS':
            material = bpy.data.materials[atom.materials_field]
            bpy.data.materials[atom.materials_field].use_fake_user = \
                not material.use_fake_user

        if inspection == 'NODE_GROUPS':
            node_group = bpy.data.node_groups[atom.node_groups_field]
            bpy.data.node_groups[atom.node_groups_field].use_fake_user = \
                not node_group.use_fake_user

        if inspection == 'PARTICLES':
            particle = bpy.data.particles[atom.particles_field]
            bpy.data.particles[atom.particles_field].use_fake_user = \
                not particle.use_fake_user

        if inspection == 'TEXTURES':
            texture = bpy.data.textures[atom.textures_field]
            bpy.data.textures[atom.textures_field].use_fake_user = \
                not texture.use_fake_user

        if inspection == 'WORLDS':
            world = bpy.data.worlds[atom.worlds_field]
            bpy.data.worlds[atom.worlds_field].use_fake_user = \
                not world.use_fake_user

        return {'FINISHED'}


# Atomic Data Manager Inspection Duplicate Operator
class ATOMIC_OT_inspection_duplicate(bpy.types.Operator):
    """Make an exact copy of this data-block"""
    bl_idname = "atomic.inspection_duplicate"
    bl_label = "Duplicate Data-Block"

    def execute(self, context):
        atom = bpy.context.scene.atomic
        inspection = atom.active_inspection

        if inspection == 'COLLECTIONS':
            key = atom.collections_field
            collections = bpy.data.collections

            if key in collections.keys():
                copy_key = duplicate.collection(key)
                atom.collections_field = copy_key

        elif inspection == 'IMAGES':
            key = atom.images_field
            images = bpy.data.images

            if key in images.keys():
                copy_key = duplicate.image(key)
                atom.images_field = copy_key

        elif inspection == 'LIGHTS':
            key = atom.lights_field
            lights = bpy.data.lights

            if key in lights.keys():
                copy_key = duplicate.light(key)
                atom.lights_field = copy_key

        elif inspection == 'MATERIALS':
            key = atom.materials_field
            materials = bpy.data.materials

            if key in materials.keys():
                copy_key = duplicate.material(key)
                atom.materials_field = copy_key

        elif inspection == 'NODE_GROUPS':
            key = atom.node_groups_field
            node_groups = bpy.data.node_groups

            if key in node_groups.keys():
                copy_key = duplicate.node_group(key)
                atom.node_groups_field = copy_key

        elif inspection == 'PARTICLES':
            key = atom.particles_field
            particles = bpy.data.particles

            if key in particles.keys():
                copy_key = duplicate.particle(key)
                atom.particles_field = copy_key

        elif inspection == 'TEXTURES':
            key = atom.textures_field
            textures = bpy.data.textures

            if key in textures.keys():
                copy_key = duplicate.texture(key)
                atom.textures_field = copy_key

        elif inspection == 'WORLDS':
            key = atom.worlds_field
            worlds = bpy.data.worlds

            if key in worlds.keys():
                copy_key = duplicate.world(key)
                atom.worlds_field = copy_key

        return {'FINISHED'}


# Atomic Data Manager Inspection Delete Operator
class ATOMIC_OT_inspection_delete(bpy.types.Operator):
    """Forcibly remove this data-block from the project"""
    bl_idname = "atomic.inspection_delete"
    bl_label = "Delete Data-Block"

    def execute(self, context):
        atom = bpy.context.scene.atomic
        inspection = atom.active_inspection

        if inspection == 'COLLECTIONS':
            key = atom.collections_field
            collections = bpy.data.collections

            if key in collections.keys():
                delete.collection(key)
                atom.collections_field = ""

        elif inspection == 'IMAGES':
            key = atom.images_field
            images = bpy.data.images

            if key in images.keys():
                delete.image(key)
                atom.images_field = ""

        elif inspection == 'LIGHTS':
            key = atom.lights_field
            lights = bpy.data.lights

            if key in lights.keys():
                delete.light(key)
                atom.lights_field = ""

        elif inspection == 'MATERIALS':
            key = atom.materials_field
            materials = bpy.data.materials

            if key in materials.keys():
                delete.material(key)
                atom.materials_field = ""

        elif inspection == 'NODE_GROUPS':
            key = atom.node_groups_field
            node_groups = bpy.data.node_groups

            if key in node_groups.keys():
                delete.node_group(key)
                atom.node_groups_field = ""

        elif inspection == 'PARTICLES':
            key = atom.particles_field
            particles = bpy.data.particles
            if key in particles.keys():
                delete.particle(key)
                atom.particles_field = ""

        elif inspection == 'TEXTURES':
            key = atom.textures_field
            textures = bpy.data.textures

            if key in textures.keys():
                delete.texture(key)
                atom.textures_field = ""

        elif inspection == 'WORLDS':
            key = atom.worlds_field
            worlds = bpy.data.worlds

            if key in worlds.keys():
                delete.world(key)
                atom.worlds_field = ""

        return {'FINISHED'}


reg_list = [
    ATOMIC_OT_inspection_rename,
    ATOMIC_OT_inspection_replace,
    ATOMIC_OT_inspection_toggle_fake_user,
    ATOMIC_OT_inspection_duplicate,
    ATOMIC_OT_inspection_delete
]


def register():
    for item in reg_list:
        register_class(item)


def unregister():
    for item in reg_list:
        unregister_class(item)