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

Read the state of the last viewport press event from the specified viewport. 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 OgnReadViewportPressStateDatabase(og.Database):
    """Helper class providing simplified access to data on nodes of type omni.graph.ui_nodes.ReadViewportPressState

    Class Members:
        node: Node being evaluated

    Attribute Value Properties:
        Inputs:
            inputs.gesture
            inputs.useNormalizedCoords
            inputs.viewport
        Outputs:
            outputs.isPressed
            outputs.isReleasePositionValid
            outputs.isValid
            outputs.pressPosition
            outputs.releasePosition

    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.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: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.DEFAULT: 'false'}, True, False, False, ''),
        ('inputs:viewport', 'token', 0, 'Viewport', 'Name of the viewport window to watch for press events', {ogn.MetadataKeys.DEFAULT: '"Viewport"'}, True, "Viewport", False, ''),
        ('outputs:isPressed', 'bool', 0, 'Is Pressed', 'True if the specified viewport is currently pressed', {}, True, None, 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:isValid', 'bool', 0, 'Is Valid', 'True if a valid event state was detected and the outputs of this node are valid, and false otherwise', {}, True, None, False, ''),
        ('outputs:pressPosition', 'double2', 0, 'Press Position', 'The position at which the specified viewport was last pressed', {}, True, None, False, ''),
        ('outputs:releasePosition', 'double2', 0, 'Release Position', 'The position at which the last press on the specified viewport was released,\nor (0,0) if the press was released outside of the viewport or the viewport is currently pressed', {}, True, None, False, ''),
    ])

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

    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 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 isPressed(self):
            data_view = og.AttributeValueHelper(self._attributes.isPressed)
            return data_view.get()

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

        @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 isValid(self):
            data_view = og.AttributeValueHelper(self._attributes.isValid)
            return data_view.get()

        @isValid.setter
        def isValid(self, value):
            data_view = og.AttributeValueHelper(self._attributes.isValid)
            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 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)

        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 = OgnReadViewportPressStateDatabase.ValuesForInputs(node, self.attributes.inputs, dynamic_attributes)
        dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_OUTPUT)
        self.outputs = OgnReadViewportPressStateDatabase.ValuesForOutputs(node, self.attributes.outputs, dynamic_attributes)
        dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_STATE)
        self.state = OgnReadViewportPressStateDatabase.ValuesForState(node, self.attributes.state, dynamic_attributes)
