import bpy

from ..models import FangeProject
from pathlib import Path


class ExportForFange(bpy.types.Operator):
    """Export a building for fange"""
    bl_idname = 'graou.building_export'
    bl_label = 'Easily export a building asset'

    def __init__(self):
        self.coll_layout = bpy.data.collections.get('Placeholder')
        self.path = FangeProject()
        self.asset = self.get_asset_name()
        self.category = self.get_asset_type()

    @classmethod
    def poll(cls, context):
        col = bpy.data.collections.get('Placeholder')

        if col is not None and bpy.data.is_saved:
            return True

    def execute(self, context):
        bpy.ops.object.select_all(action='DESELECT')
        print(f'[Pipeline] Start to export the building props.')

        # Make a check if the file are saved on the disk
        if not bpy.data.is_saved:
            self.report({'ERROR'}, 'Your blend file is not saved.')
            return {'CANCELLED'}

        if not self.category:
            self.report({'ERROR'}, 'Can\'t find the asset category.')
            return {'CANCELLED'}

        if len(self.coll_layout.collection_children):
            for coll in self.coll_layout.children:
                print(f'[Pipeline] Update "{coll.name}" mesh')
                child = bpy.data.collections.get(coll.name)

                for ob in child.all_objects:
                    print(f'\tLook "{ob.name}", his type are "{type(ob.data)}"')
                    # TODO Support another type object, not only SM/SK
                    if ob.type == 'MESH' or 'EMPTY':
                        ob.select_set(True)

                abs_export = self.category.joinpath(self.asset, "Meshes")
                if not abs_export.exists():
                    abs_export.mkdir()

                # TODO Use a preset system
                bpy.ops.export_scene.fbx(filepath=abs_export.joinpath(f"SM_{coll.name}.fbx").as_posix(),
                                         use_selection=True,
                                         use_visible=False,
                                         use_active_collection=False,
                                         global_scale=1.0,
                                         apply_unit_scale=True,
                                         apply_scale_options='FBX_SCALE_NONE',
                                         use_space_transform=True,
                                         bake_space_transform=True,
                                         object_types={'MESH', 'EMPTY'},
                                         use_mesh_modifiers=True,
                                         use_mesh_modifiers_render=True,
                                         mesh_smooth_type='OFF',
                                         colors_type='SRGB',
                                         prioritize_active_color=False,
                                         use_subsurf=False,
                                         use_mesh_edges=False,
                                         use_tspace=False,
                                         use_triangles=False,
                                         use_custom_props=False,
                                         add_leaf_bones=True,
                                         primary_bone_axis='Y',
                                         secondary_bone_axis='X',
                                         use_armature_deform_only=False,
                                         armature_nodetype='NULL',
                                         bake_anim=False,
                                         bake_anim_use_all_bones=True,
                                         bake_anim_use_nla_strips=True,
                                         bake_anim_use_all_actions=True,
                                         bake_anim_force_startend_keying=True,
                                         bake_anim_step=1.0,
                                         bake_anim_simplify_factor=1.0,
                                         path_mode='AUTO',
                                         embed_textures=False,
                                         batch_mode='OFF',
                                         use_batch_own_dir=True,
                                         axis_forward='X',
                                         axis_up='Y'
                                         )

                print(f'[Pipeline] Export here "{abs_export}"')
                bpy.ops.object.select_all(action='DESELECT')

        # for coll in coll_layout.children:
        #    print(f'[Pipeline] Check {coll}. Item type {type(coll)}')

        self.report({'INFO'}, 'Placeholder exported')
        return {'FINISHED'}

    def get_asset_type(self) -> Path:
        """Look the file path, to understand if the asset are a Character, Buildings or Props"""
        abs_blend_path = Path(bpy.data.filepath)
        print(f'[Pipeline] Get blend file path "{abs_blend_path}"')
        print(f'[Pipeline] Convert to List "{abs_blend_path.parts}"')

        if 'Buildings' in abs_blend_path.parts:
            print(f'[Pipeline] Export here "{self.path.buildings}"')
            return self.path.buildings

        elif 'Pros' in abs_blend_path.parts:
            print(f'[Pipeline] Export here "{self.path.props}"')
            return self.path.props

        elif 'Characters' in abs_blend_path.parts:
            print(f'[Pipeline] Export here "{self.path.characters}"')
            return self.path.characters

        else:
            print(f'[Pipeline] Can\'t find asset category')
            return Path()

    @staticmethod
    def get_asset_name():
        abs_blend_path = Path(bpy.data.filepath)
        return abs_blend_path.stem