"""
Make sure the getting a variable path works and doesn't crash.
"""


import lldb
import lldbsuite.test.lldbutil as lldbutil
from lldbsuite.test.decorators import *
from lldbsuite.test.lldbtest import *


class TestVarPath(TestBase):
    # If your test case doesn't stress debug info, then
    # set this to true.  That way it won't be run once for
    # each debug info format.
    NO_DEBUG_INFO_TESTCASE = True

    def test_frame_var(self):
        self.build()
        self.do_test()

    def verify_point(self, frame, var_name, var_typename, x_value, y_value):
        v = frame.GetValueForVariablePath(var_name)
        self.assertSuccess(v.GetError(), "Make sure we find '%s'" % (var_name))
        self.assertEqual(
            v.GetType().GetName(),
            var_typename,
            "Make sure '%s' has type '%s'" % (var_name, var_typename),
        )

        if "*" in var_typename:
            valid_prefix = var_name + "->"
            invalid_prefix = var_name + "."
        else:
            valid_prefix = var_name + "."
            invalid_prefix = var_name + "->"

        valid_x_path = valid_prefix + "x"
        valid_y_path = valid_prefix + "y"
        invalid_x_path = invalid_prefix + "x"
        invalid_y_path = invalid_prefix + "y"
        invalid_m_path = invalid_prefix + "m"

        v = frame.GetValueForVariablePath(valid_x_path)
        self.assertSuccess(v.GetError(), "Make sure we find '%s'" % (valid_x_path))
        self.assertEqual(
            v.GetValue(),
            str(x_value),
            "Make sure '%s' has a value of %i" % (valid_x_path, x_value),
        )
        self.assertEqual(
            v.GetType().GetName(),
            "int",
            "Make sure '%s' has type 'int'" % (valid_x_path),
        )
        v = frame.GetValueForVariablePath(invalid_x_path)
        self.assertTrue(
            v.GetError().Fail(), "Make sure we don't find '%s'" % (invalid_x_path)
        )

        v = frame.GetValueForVariablePath(valid_y_path)
        self.assertSuccess(v.GetError(), "Make sure we find '%s'" % (valid_y_path))
        self.assertEqual(
            v.GetValue(),
            str(y_value),
            "Make sure '%s' has a value of %i" % (valid_y_path, y_value),
        )
        self.assertEqual(
            v.GetType().GetName(),
            "int",
            "Make sure '%s' has type 'int'" % (valid_y_path),
        )
        v = frame.GetValueForVariablePath(invalid_y_path)
        self.assertTrue(
            v.GetError().Fail(), "Make sure we don't find '%s'" % (invalid_y_path)
        )

        v = frame.GetValueForVariablePath(invalid_m_path)
        self.assertTrue(
            v.GetError().Fail(), "Make sure we don't find '%s'" % (invalid_m_path)
        )

    def do_test(self):
        (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(
            self, "// Set a breakpoint here", lldb.SBFileSpec("main.cpp")
        )

        frame = thread.GetFrameAtIndex(0)
        v = frame.GetValueForVariablePath("no_such_variable")
        self.assertTrue(
            v.GetError().Fail(), "Make sure we don't find 'no_such_variable'"
        )

        # Test an instance
        self.verify_point(frame, "pt", "Point", 1, 2)
        # Test a pointer
        self.verify_point(frame, "pt_ptr", "Point *", 3030, 4040)
        # Test using a pointer as an array
        self.verify_point(frame, "pt_ptr[-1]", "Point", 1010, 2020)
        self.verify_point(frame, "pt_ptr[0]", "Point", 3030, 4040)
        self.verify_point(frame, "pt_ptr[1]", "Point", 5050, 6060)
        # Test arrays
        v_helper = frame.var("points")
        self.assertSuccess(v_helper.GetError(), "Make sure we find 'points'")
        v = frame.GetValueForVariablePath("points")
        self.assertSuccess(v.GetError(), "Make sure we find 'points'")
        self.verify_point(frame, "points[0]", "Point", 1010, 2020)
        self.verify_point(frame, "points[1]", "Point", 3030, 4040)
        self.verify_point(frame, "points[2]", "Point", 5050, 6060)
        v = frame.GetValueForVariablePath("points[0]+5")
        self.assertTrue(
            v.GetError().Fail(),
            "Make sure we do not ignore characters between ']' and the end",
        )
        # Test a reference
        self.verify_point(frame, "pt_ref", "Point &", 1, 2)
        v = frame.GetValueForVariablePath("pt_sp")
        self.assertSuccess(v.GetError(), "Make sure we find 'pt_sp'")
        # Make sure we don't crash when looking for non existant child
        # in type with synthetic children. This used to cause a crash.
        if not self.isAArch64Windows():
            v = frame.GetValueForVariablePath("pt_sp->not_valid_child")
            self.assertTrue(
                v.GetError().Fail(), "Make sure we don't find 'pt_sp->not_valid_child'"
            )

    @expectedFailureAll(
        oslist=["windows"],
        bugnumber="https://github.com/llvm/llvm-project/issues/25037",
    )
    def test_frame_var_use_dynamic(self):
        """Test `SBFrame.GetValueForVariablePath` return the current value and variable type."""
        self.build()
        (_, _, thread, _) = lldbutil.run_to_source_breakpoint(
            self, "// Set a breakpoint here", lldb.SBFileSpec("main.cpp")
        )
        frame: lldb.SBFrame = thread.GetFrameAtIndex(0)

        # Verify concrete types.
        concrete = [
            ("shape", "Shape"),
            ("shape_ref", "Shape &"),
            ("shape_ptr", "Shape *"),
            ("circle", "Circle"),
            ("circle_ref", "Circle &"),
            ("circle_ptr", "Circle *"),
        ]
        for name, expected_type in concrete:
            for dyn_val in (lldb.eNoDynamicValues, lldb.eDynamicDontRunTarget):
                val: lldb.SBValue = frame.GetValueForVariablePath(name, dyn_val)
                self.assertSuccess(val.GetError(), f"Make sure we find {name!r}")
                self.assertEqual(val.GetTypeName(), expected_type)

                # Test the helper.
                val: lldb.SBValue = frame.var(name, dyn_val)
                self.assertTrue(val.GetError().Success(), f"Make sure we find {name!r}")
                self.assertEqual(val.GetTypeName(), expected_type)

        # Verify dynamic types.
        polymorphic = [
            ("circle_as_shape_ref", "Shape &", "Circle &"),
            ("circle_as_shape_ptr", "Shape *", "Circle *"),
            ("circle_as_drawable_ref", "Drawable &", "Circle &"),
            ("circle_as_drawable_ptr", "Drawable *", "Circle *"),
        ]
        for name, static_type, dynamic_type in polymorphic:
            static = frame.GetValueForVariablePath(name, lldb.eNoDynamicValues)
            static_helper: lldb.SBValue = frame.var(name, lldb.eNoDynamicValues)
            for val in (static, static_helper):
                self.assertSuccess(val.GetError(), f"find {name!r} (static)")
                self.assertEqual(static_type, val.GetTypeName())
                self.assertNotIn("Circle", val.GetTypeName())
                self.assertFalse(
                    val.GetChildMemberWithName("circle_val").IsValid(),
                    f"{name!r} should not expose circle_val under eNoDynamicValues",
                )

            dynamic = frame.GetValueForVariablePath(name, lldb.eDynamicDontRunTarget)
            dynamic_helper: lldb.SBValue = frame.var(name, lldb.eDynamicDontRunTarget)
            for val in (dynamic, dynamic_helper):
                self.assertSuccess(val.GetError(), f"find {name!r} (dynamic)")
                self.assertEqual(
                    dynamic_type,
                    val.GetTypeName(),
                    f"'{name}' should resolve to Circle under eDynamicDontRunTarget",
                )
                circle_val = val.GetChildMemberWithName("circle_val")
                self.assertTrue(
                    circle_val.IsValid(),
                    f"{name!r} should expose circle_val under eDynamicDontRunTarget",
                )

                # Verify we can fetch the child from the static type.
                self.assertEqual(circle_val.GetValueAsSigned(), 20)