from __future__ import print_function
import logging


import maya.api.OpenMaya as om
from maya import cmds

logger = logging.getLogger(__name__)


class BaseComponent(object):
    def __init__(self, *args, **kwargs):
        node = None
        if args:
            node = args[0]
        elif 'node' in kwargs:
            node = kwargs.get('node')

        self._mObject = self._convert_to_mObject(node)

        self.name = (
            om.MFnDependencyNode(self._mObject).name()
            if self._mObject is not None
            else None
        )

    @classmethod
    def from_selection(cls):
        """
        Initiate BaseComponent from maya selection
        Returns
        -------
        BaseComponent
        """
        return cls()

    @classmethod
    def from_string(cls, node_name):
        """
        Initiate BaseComponent from str
        Parameters
        ----------
        node_name : str
            Node Name
        Returns
        -------
        BaseComponent
        """
        if not isinstance(node_name, basestring):
            msg = '`node_name` should be of type <str>, recieved {}'.format(
                type(node_name)
            )
            raise TypeError(msg)

        _mObject = cls._convert_to_mObject(node_name)
        return cls(_mObject)

    @classmethod
    def from_mobject_handle(cls, mob_hdl):
        if not isinstance(mob_hdl, om.MObjectHandle):
            msg = (
                '`mob_hdl` should be of type <om.MObjectHandle>, recieved {}'
            ).format(type(mob_hdl))
            raise TypeError(msg)

        _mObject = cls._convert_to_mObject(mob_hdl)
        return cls(_mObject)

    @classmethod
    def _obj_name_from_selection(cls):
        try:
            name = str(cmds.ls(sl=1)[0])
        except IndexError:
            logger.error('No node selected.')
            return
        else:
            return name

    @classmethod
    def _m_object_from_name(cls, name):
        try:
            sel_list = om.MSelectionList()
            sel_list.add(name)
            return sel_list.getDependNode(0)
        except RuntimeError:
            logger.error("Node does not exist. Component not created.")

    @classmethod
    def _convert_to_mObject(cls, arg=None):
        if arg is None:
            object_name = cls._obj_name_from_selection()
        elif isinstance(arg, basestring):
            object_name = arg
        elif isinstance(arg, om.MObjectHandle):
            return arg.object()
        elif isinstance(arg, om.MObject):
            # We already recieved an MObject, let's just return it
            return arg

        if object_name is not None:
            return cls._m_object_from_name(object_name)


def _setup():
    cmds.file(new=True, f=1)
    cmds.polySphere()
    cmds.polySphere()
    cmds.select('pSphere1', r=1)


def main():
    _setup()

    test = BaseComponent()
    if test:
        print("TEST1:SELECTION: {}{} \r\n".format(test, test.__dict__))

    test2 = BaseComponent(node='pSphere2')
    if test2:
        print("TEST2:STR: {}{} \r\n".format(test2, test2.__dict__))

    sel = om.MGlobal.getActiveSelectionList()
    mob = sel.getDependNode(0)
    mob_hdl = om.MObjectHandle(mob)
    test3 = BaseComponent(node=mob_hdl)
    if test3:
        print("TEST3:MOBHANDLE: {}{} \r\n".format(test3, test3.__dict__))

    sel = om.MGlobal.getActiveSelectionList()
    mob = sel.getDependNode(0)
    test4 = BaseComponent(node=mob)
    if test4:
        print("TEST4:MOB: {}{} \r\n".format(test4, test4.__dict__))
    else:
        print("")


if __name__ == '__main__':
    main()