"""Support for simplified access to data on nodes of type omni.graph.ui_nodes.OnViewportPressed

Event node which fires when the specified viewport is pressed, and when that press is released. Note that viewport mouse
events must be enabled on the specified viewport using a SetViewportMode node.
"""

import numpy

import omni.graph.core as og
import omni.graph.core._omni_graph_core as _og
import omni.graph.tools.ogn as ogn



class OgnOnViewportPressedDatabase(og.Database):
    """Helper class providing simplified access to data on nodes of type omni.graph.ui_nodes.OnViewportPressed

    Class Members:
        node: Node being evaluated

    Attribute Value Properties:
        Inputs:
            inputs.gesture
            inputs.onlyPlayback
            inputs.useNormalizedCoords
            inputs.viewport
        Outputs:
            outputs.isReleasePositionValid
            outputs.pressPosition
            outputs.pressed
            outputs.releasePosition
            outputs.released

    Predefined Tokens:
        tokens.LeftMouseDrag
        tokens.RightMouseDrag
        tokens.MiddleMouseDrag
    """

    # Imprint the generator and target ABI versions in the file for JIT generation
    GENERATOR_VERSION = (1, 41, 3)
    TARGET_VERSION = (2, 139, 12)

    # This is an internal object that provides per-class storage of a per-node data dictionary
    PER_NODE_DATA = {}

    # This is an internal object that describes unchanging attributes in a generic way
    # The values in this list are in no particular order, as a per-attribute tuple
    #     Name, Type, ExtendedTypeIndex, UiName, Description, Metadata,
    #     Is_Required, DefaultValue, Is_Deprecated, DeprecationMsg
    # You should not need to access any of this data directly, use the defined database interfaces
    INTERFACE = og.Database._get_interface([
        ('inputs:gesture', 'token', 0, 'Gesture', 'The input gesture to trigger viewport press events', {'displayGroup': 'parameters', ogn.MetadataKeys.LITERAL_ONLY: '1', ogn.MetadataKeys.ALLOWED_TOKENS: 'Left Mouse Press,Right Mouse Press,Middle Mouse Press', ogn.MetadataKeys.ALLOWED_TOKENS_RAW: '{"LeftMouseDrag": "Left Mouse Press", "RightMouseDrag": "Right Mouse Press", "MiddleMouseDrag": "Middle Mouse Press"}', ogn.MetadataKeys.DEFAULT: '"Left Mouse Press"'}, True, "Left Mouse Press", False, ''),
        ('inputs:onlyPlayback', 'bool', 0, 'Only Simulate On Play', 'When true, the node is only computed while Stage is being played', {ogn.MetadataKeys.LITERAL_ONLY: '1', ogn.MetadataKeys.DEFAULT: 'true'}, True, True, False, ''),
        ('inputs:useNormalizedCoords', 'bool', 0, 'Use Normalized Coords', 'When true, the components of 2D position outputs are scaled to between 0 and 1,\nwhere 0 is top/left and 1 is bottom/right.\nWhen false, components are in viewport render resolution pixels.', {ogn.MetadataKeys.LITERAL_ONLY: '1', ogn.MetadataKeys.DEFAULT: 'false'}, True, False, False, ''),
        ('inputs:viewport', 'token', 0, 'Viewport', 'Name of the viewport window to watch for press events', {ogn.MetadataKeys.LITERAL_ONLY: '1', ogn.MetadataKeys.DEFAULT: '"Viewport"'}, True, "Viewport", False, ''),
        ('outputs:isReleasePositionValid', 'bool', 0, 'Is Release Position Valid', 'True if the press was released inside of the viewport, and false otherwise', {}, True, None, False, ''),
        ('outputs:pressPosition', 'double2', 0, 'Press Position', "The position at which the viewport was pressed (valid when either 'Pressed' or 'Released' is enabled)", {}, True, None, False, ''),
        ('outputs:pressed', 'execution', 0, 'Pressed', "Enabled when the specified viewport is pressed, populating 'Press Position' with the current mouse position", {}, True, None, False, ''),
        ('outputs:releasePosition', 'double2', 0, 'Release Position', "The position at which the press was released, or (0,0) if the press was released outside of the viewport\nor the viewport is currently pressed (valid when 'Ended' is enabled and 'Is Release Position Valid' is true)", {}, True, None, False, ''),
        ('outputs:released', 'execution', 0, 'Released', "Enabled when the press is released, populating 'Release Position' with the current mouse position\nand setting 'Is Release Position Valid' to true if the press is released inside of the viewport.\nIf the press is released outside of the viewport, 'Is Release Position Valid' is set to false\nand 'Release Position' is set to (0,0).", {}, True, None, False, ''),
    ])

    class tokens:
        LeftMouseDrag = "Left Mouse Press"
        RightMouseDrag = "Right Mouse Press"
        MiddleMouseDrag = "Middle Mouse Press"

    @classmethod
    def _populate_role_data(cls):
        """Populate a role structure with the non-default roles on this node type"""
        role_data = super()._populate_role_data()
        role_data.outputs.pressed = og.AttributeRole.EXECUTION
        role_data.outputs.released = og.AttributeRole.EXECUTION
        return role_data

    class ValuesForInputs(og.DynamicAttributeAccess):
        LOCAL_PROPERTY_NAMES = { }
        """Helper class that creates natural hierarchical access to input attributes"""
        def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
            """Initialize simplified access for the attribute data"""
            context = node.get_graph().get_default_graph_context()
            super().__init__(context, node, attributes, dynamic_attributes)
            self._batchedReadAttributes = []
            self._batchedReadValues = []

        @property
        def gesture(self):
            data_view = og.AttributeValueHelper(self._attributes.gesture)
            return data_view.get()

        @gesture.setter
        def gesture(self, value):
            if self._setting_locked:
                raise og.ReadOnlyError(self._attributes.gesture)
            data_view = og.AttributeValueHelper(self._attributes.gesture)
            data_view.set(value)

        @property
        def onlyPlayback(self):
            data_view = og.AttributeValueHelper(self._attributes.onlyPlayback)
            return data_view.get()

        @onlyPlayback.setter
        def onlyPlayback(self, value):
            if self._setting_locked:
                raise og.ReadOnlyError(self._attributes.onlyPlayback)
            data_view = og.AttributeValueHelper(self._attributes.onlyPlayback)
            data_view.set(value)

        @property
        def useNormalizedCoords(self):
            data_view = og.AttributeValueHelper(self._attributes.useNormalizedCoords)
            return data_view.get()

        @useNormalizedCoords.setter
        def useNormalizedCoords(self, value):
            if self._setting_locked:
                raise og.ReadOnlyError(self._attributes.useNormalizedCoords)
            data_view = og.AttributeValueHelper(self._attributes.useNormalizedCoords)
            data_view.set(value)

        @property
        def viewport(self):
            data_view = og.AttributeValueHelper(self._attributes.viewport)
            return data_view.get()

        @viewport.setter
        def viewport(self, value):
            if self._setting_locked:
                raise og.ReadOnlyError(self._attributes.viewport)
            data_view = og.AttributeValueHelper(self._attributes.viewport)
            data_view.set(value)

        def _prefetch(self):
            readAttributes = self._batchedReadAttributes
            newValues = _og._prefetch_input_attributes_data(readAttributes)
            if len(readAttributes) == len(newValues):
                self._batchedReadValues = newValues

    class ValuesForOutputs(og.DynamicAttributeAccess):
        LOCAL_PROPERTY_NAMES = { }
        """Helper class that creates natural hierarchical access to output attributes"""
        def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
            """Initialize simplified access for the attribute data"""
            context = node.get_graph().get_default_graph_context()
            super().__init__(context, node, attributes, dynamic_attributes)
            self._batchedWriteValues = { }

        @property
        def isReleasePositionValid(self):
            data_view = og.AttributeValueHelper(self._attributes.isReleasePositionValid)
            return data_view.get()

        @isReleasePositionValid.setter
        def isReleasePositionValid(self, value):
            data_view = og.AttributeValueHelper(self._attributes.isReleasePositionValid)
            data_view.set(value)

        @property
        def pressPosition(self):
            data_view = og.AttributeValueHelper(self._attributes.pressPosition)
            return data_view.get()

        @pressPosition.setter
        def pressPosition(self, value):
            data_view = og.AttributeValueHelper(self._attributes.pressPosition)
            data_view.set(value)

        @property
        def pressed(self):
            data_view = og.AttributeValueHelper(self._attributes.pressed)
            return data_view.get()

        @pressed.setter
        def pressed(self, value):
            data_view = og.AttributeValueHelper(self._attributes.pressed)
            data_view.set(value)

        @property
        def releasePosition(self):
            data_view = og.AttributeValueHelper(self._attributes.releasePosition)
            return data_view.get()

        @releasePosition.setter
        def releasePosition(self, value):
            data_view = og.AttributeValueHelper(self._attributes.releasePosition)
            data_view.set(value)

        @property
        def released(self):
            data_view = og.AttributeValueHelper(self._attributes.released)
            return data_view.get()

        @released.setter
        def released(self, value):
            data_view = og.AttributeValueHelper(self._attributes.released)
            data_view.set(value)

        def _commit(self):
            _og._commit_output_attributes_data(self._batchedWriteValues)
            self._batchedWriteValues = { }

    class ValuesForState(og.DynamicAttributeAccess):
        """Helper class that creates natural hierarchical access to state attributes"""
        def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
            """Initialize simplified access for the attribute data"""
            context = node.get_graph().get_default_graph_context()
            super().__init__(context, node, attributes, dynamic_attributes)

    def __init__(self, node):
        super().__init__(node)
        dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_INPUT)
        self.inputs = OgnOnViewportPressedDatabase.ValuesForInputs(node, self.attributes.inputs, dynamic_attributes)
        dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_OUTPUT)
        self.outputs = OgnOnViewportPressedDatabase.ValuesForOutputs(node, self.attributes.outputs, dynamic_attributes)
        dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_STATE)
        self.state = OgnOnViewportPressedDatabase.ValuesForState(node, self.attributes.state, dynamic_attributes)
