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.camera as camera

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


class Camera_Component_Tests(unittest.TestCase):
    """
    Class containing tests for camera component 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_camera_inst(self):

        root.Root()
        inst = camera.Camera()
        inst.parent = "root"
        return inst

    def test_create_camera(self):

        self._create_asset()
        jnt_inst = self._create_camera_inst()
        self.assertEquals(len(jnt_inst.joint_mover.get_created_joints()), 3)

    def test_delete_camera(self):

        self._create_asset()
        jnt_inst = self._create_camera_inst()

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

        jnt_inst.delete()
        self.assertFalse(cmds.objExists("camera_metadata"))

        for each in guide_nodes:
            self.assertFalse(cmds.objExists(each.nodeName()))
        for each in utility_nodes:
            self.assertFalse(cmds.objExists(each.nodeName()))

    def test_bake_offsets(self):

        self._create_asset()
        jnt_inst = self._create_camera_inst()
        cmds.setAttr("camera_camera_main_mover_offset.translateY", 60)

        pre_offset_position = format_position(cmds.xform("camera_camera_main_mover_offset", q=True, ws=True, t=True))
        pre_main_position = format_position(cmds.xform("camera_camera_main_mover", q=True, ws=True, t=True))
        self.assertNotEquals(pre_main_position, pre_offset_position)
        jnt_inst.joint_mover.bake_offsets()

        post_offset_position = format_position(cmds.xform("camera_camera_main_mover_offset", q=True, ws=True, t=True))
        post_main_position = format_position(cmds.xform("camera_camera_main_mover", q=True, ws=True, t=True))
        self.assertEquals(post_main_position, post_offset_position)

    def test_duplicate(self):

        self._create_asset()
        jnt_inst = self._create_camera_inst()

        cmds.setAttr("camera_camera_root_mover.translateZ", 65)
        cmds.setAttr("camera_camera_root_mover.rotateX", 20)
        cmds.setAttr("camera_camera_root_mover.rotateY", -20)
        cmds.setAttr("camera_camera_root_mover.rotateZ", 42)
        cmds.setAttr("camera_camera_root_mover.scaleX", 2)
        cmds.setAttr("camera_camera_root_mover.scaleY", 2)
        cmds.setAttr("camera_camera_root_mover.scaleZ", 2)

        duplicate_inst = jnt_inst.duplicate()

        self.assertEquals(duplicate_inst.parent, "root")
        self.assertEquals(cmds.getAttr("camera_01_camera_root_mover.tz"), cmds.getAttr("camera_camera_root_mover.tz"))
        self.assertEquals(cmds.getAttr("camera_01_camera_root_mover.rx"), cmds.getAttr("camera_camera_root_mover.rx"))
        self.assertEquals(cmds.getAttr("camera_01_camera_root_mover.ry"), cmds.getAttr("camera_camera_root_mover.ry"))
        self.assertEquals(cmds.getAttr("camera_01_camera_root_mover.rz"), cmds.getAttr("camera_camera_root_mover.rz"))
        self.assertEquals(cmds.getAttr("camera_01_camera_root_mover.sx"), cmds.getAttr("camera_camera_root_mover.sx"))
        self.assertEquals(cmds.getAttr("camera_01_camera_root_mover.sy"), cmds.getAttr("camera_camera_root_mover.sy"))
        self.assertEquals(cmds.getAttr("camera_01_camera_root_mover.sz"), cmds.getAttr("camera_camera_root_mover.sz"))

        dupe2 = jnt_inst.duplicate()
        dupe3 = jnt_inst.duplicate()
        self.assertEquals(dupe2.suffix, "_02")
        self.assertEquals(dupe3.suffix, "_03")

    def test_pin_component(self):

        self._create_asset()
        jnt_inst = self._create_camera_inst()

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

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

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