# -*- coding: utf-8 -*-
"""
:author:
    Jeremy Ernst
:description:
    This module contains unit tests for the spine component.
"""

import unittest
import maya.cmds as cmds
import artv2.components.base_components.rig_asset as rig_asset
import artv2.components.root as root
import artv2.components.spine as spine
import artv2.components.joint as joint


def format_position(pos):
    return [float("{0:.3f}".format(pos[0])), float("{0:.3f}".format(pos[1])), float("{0:.3f}".format(pos[2]))]


class Spine_Component_Tests(unittest.TestCase):
    """
    Class containing tests for spine module creation and manipulation.
    """

    def _create_asset(self):
        new_asset = rig_asset.RigAsset()
        self.assertEquals(new_asset.name, "asset")
        self.assertEquals(new_asset.network_node, "asset_metadata")
        return new_asset

    def _create_spine_inst(self, prefix):
        if not cmds.objExists("master_metadata"):
            root.Root()
        spine_inst = spine.Spine(prefix=prefix)
        spine_inst.parent = "root"
        return spine_inst

    def test_create_spine(self):

        self._create_asset()
        spine_inst = self._create_spine_inst("")
        self.assertEquals(len(spine_inst.joint_mover.get_created_joints()), 4)

    def test_delete_spine(self):

        self._create_asset()
        spine_inst = self._create_spine_inst("")
        joint_inst = joint.Joint()
        joint_inst.parent = "pelvis"

        component_containers = spine_inst.joint_mover.get_containers()
        guide_nodes = component_containers[1].getNodeList()
        utility_nodes = component_containers[2].getNodeList()
        spine_inst.delete()

        self.assertFalse(cmds.objExists("spine_metadata"))

        for each in guide_nodes:
            self.assertFalse(cmds.objExists(each.nodeName()))
        for each in utility_nodes:
            self.assertFalse(cmds.objExists(each.nodeName()))
        self.assertEquals(joint_inst.parent, "root")

    def test_bake_offsets(self):

        self._create_asset()
        spine_inst = self._create_spine_inst("")
        spine_inst.joint_mover.aim_helper.toggle_aim_mode()
        cmds.setAttr("spine_spine_02_mover_offset.translateY", 10)

        pre_offset_position = format_position(cmds.xform("spine_spine_02_mover_offset", q=True, ws=True, t=True))
        pre_main_position = format_position(cmds.xform("spine_spine_02_mover", q=True, ws=True, t=True))
        pre_end_position = format_position(cmds.xform("spine_spine_03_mover", q=True, ws=True, t=True))

        self.assertNotEquals(pre_main_position, pre_offset_position)

        spine_inst.joint_mover.bake_offsets()

        post_offset_position = format_position(cmds.xform("spine_spine_02_mover_offset", q=True, ws=True, t=True))
        post_main_position = format_position(cmds.xform("spine_spine_02_mover", q=True, ws=True, t=True))
        post_end_position = format_position(cmds.xform("spine_spine_03_mover", q=True, ws=True, t=True))

        self.assertEquals(post_main_position, post_offset_position)
        self.assertEquals(pre_end_position, post_end_position)

    def test_pin_component(self):

        self._create_asset()
        spine_inst = self._create_spine_inst("")

        pre_position = format_position(cmds.xform("spine_pelvis_mover", q=True, ws=True, t=True))
        spine_inst.joint_mover.toggle_pin_component()
        self.assertTrue(spine_inst.network_node.pinned.get())

        cmds.setAttr("master_root_mover.translateX", 100)
        post_position = format_position(cmds.xform("spine_pelvis_mover", q=True, ws=True, t=True))
        self.assertEquals(pre_position, post_position)

        spine_inst.joint_mover.toggle_pin_component()
        cmds.setAttr("master_root_mover.translateX", 0)
        new_position = format_position(cmds.xform("spine_pelvis_mover", q=True, ws=True, t=True))
        self.assertNotEquals(post_position, new_position)

    def test_aim_mode(self):

        self._create_asset()
        spine_inst = self._create_spine_inst("")
        spine_inst.joint_mover.aim_helper.toggle_aim_mode()

        self.assertEquals(spine_inst.network_node.isAiming.get(), True)
        self.assertNotEquals(len(spine_inst.network_node.aimModeConstraints.connections()), 0)

        original_orientation = cmds.xform("spine_spine_01_mover_offset", q=True, ws=True, ro=True)
        cmds.setAttr("spine_spine_02_mover.translateY", 10)
        new_orientation = cmds.xform("spine_spine_01_mover_offset", q=True, ws=True, ro=True)

        self.assertNotEquals(original_orientation, new_orientation)

        spine_inst.joint_mover.aim_helper.toggle_aim_mode()
        self.assertEquals(spine_inst.network_node.isAiming.get(), False)
        self.assertEquals(len(spine_inst.network_node.aimModeConstraints.connections()), 0)

        original_orientation = cmds.xform("spine_spine_01_mover_offset", q=True, ws=True, ro=True)
        cmds.setAttr("spine_spine_02_mover.translateY", 0)
        new_orientation = cmds.xform("spine_spine_01_mover_offset", q=True, ws=True, ro=True)

        self.assertEquals(original_orientation, new_orientation)

    def test_duplicate(self):

        self._create_asset()
        spine_inst = self._create_spine_inst("")

        cmds.setAttr("spine_pelvis_mover.translateY", -10)
        cmds.setAttr("spine_pelvis_mover.rotateY", 30)
        cmds.setAttr("spine_pelvis_mover.rotateZ", 42)
        cmds.setAttr("spine_pelvis_mover.scaleY", 1.319)
        cmds.setAttr("spine_pelvis_mover.scaleX", 1.319)
        cmds.setAttr("spine_pelvis_mover.scaleZ", 1.319)
        cmds.setAttr("spine_spine_01_mover.rotateZ", -25)

        duplicate_inst = spine_inst.duplicate()

        self.assertEquals(duplicate_inst.parent, "root")
        self.assertEquals(cmds.getAttr("spine_01_pelvis_mover.ty"), cmds.getAttr("spine_pelvis_mover.ty"))
        self.assertEquals(cmds.getAttr("spine_01_pelvis_mover.ry"), cmds.getAttr("spine_pelvis_mover.ry"))
        self.assertEquals(cmds.getAttr("spine_01_pelvis_mover.rz"), cmds.getAttr("spine_pelvis_mover.rz"))
        self.assertEquals(cmds.getAttr("spine_01_pelvis_mover.sx"), cmds.getAttr("spine_pelvis_mover.sx"))
        self.assertEquals(cmds.getAttr("spine_01_pelvis_mover.sy"), cmds.getAttr("spine_pelvis_mover.sy"))
        self.assertEquals(cmds.getAttr("spine_01_pelvis_mover.sz"), cmds.getAttr("spine_pelvis_mover.sz"))

        self.assertEquals(cmds.getAttr("spine_01_spine_01_mover.rz"), cmds.getAttr("spine_spine_01_mover.rz"))
        spine_inst.num_joints = 5
        dupe2 = spine_inst.duplicate()
        dupe3 = spine_inst.duplicate()
        dupe4 = spine_inst.duplicate()
        self.assertEquals(dupe2.suffix, "_02")
        self.assertEquals(dupe3.suffix, "_03")
        self.assertEquals(dupe4.suffix, "_04")

    def test_invalid_property_values(self):

        self._create_asset()
        spine_inst = self._create_spine_inst("")

        with self.assertRaises(RuntimeError):
            spine_inst.num_joints = 6

        with self.assertRaises(RuntimeError):
            spine_inst.num_joints = 3.5

        with self.assertRaises(RuntimeError):
            spine_inst.num_joints = "3"

        with self.assertRaises(RuntimeError):
            spine_inst.num_joints = 0

    def test_num_spine_bones(self):

        self._create_asset()
        spine_inst = self._create_spine_inst("")
        spine_inst.num_joints = 4
        joint_inst = joint.Joint()
        joint_inst.parent = "spine_04"
        spine_inst.num_joints = 3
        self.assertEquals(joint_inst.parent, "root")
        spine_inst.num_joints = 5
        spine_inst.num_joints = 3
        spine_inst.num_joints = 4