"""
Test python scripted process in lldb
"""

import os, json, tempfile

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


class StackCoreScriptedProcesTestCase(TestBase):
    NO_DEBUG_INFO_TESTCASE = True

    def create_stack_skinny_corefile(self, file):
        self.build()
        target, process, thread, _ = lldbutil.run_to_source_breakpoint(
            self, "// break here", lldb.SBFileSpec("baz.cpp")
        )
        self.assertTrue(process.IsValid(), "Process is invalid.")
        # FIXME: Use SBAPI to save the process corefile.
        self.runCmd("process save-core -s stack  " + file)
        self.assertTrue(os.path.exists(file), "No stack-only corefile found.")
        self.assertTrue(self.dbg.DeleteTarget(target), "Couldn't delete target")

    def get_module_with_name(self, target, name):
        for module in target.modules:
            if name in module.GetFileSpec().GetFilename():
                return module
        return None

    @skipUnlessDarwin
    @skipIfRemote
    @skipIfAsan  # On ASAN builds, this test times-out (rdar://98678134)
    @skipIfDarwin
    def test_launch_scripted_process_stack_frames(self):
        """Test that we can launch an lldb scripted process from the command
        line, check its process ID and read string from memory."""
        self.build()
        target = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
        self.assertTrue(target, VALID_TARGET)

        main_module = self.get_module_with_name(target, "a.out")
        self.assertTrue(main_module, "Invalid main module.")
        error = target.SetModuleLoadAddress(main_module, 0)
        self.assertSuccess(error, "Reloading main module at offset 0 failed.")

        scripted_dylib = self.get_module_with_name(target, "libbaz.dylib")
        self.assertTrue(scripted_dylib, "Dynamic library libbaz.dylib not found.")
        self.assertEqual(
            scripted_dylib.GetObjectFileHeaderAddress().GetLoadAddress(target),
            0xFFFFFFFFFFFFFFFF,
        )

        os.environ["SKIP_SCRIPTED_PROCESS_LAUNCH"] = "1"

        def cleanup():
            del os.environ["SKIP_SCRIPTED_PROCESS_LAUNCH"]

        self.addTearDownHook(cleanup)

        scripted_process_example_relpath = "stack_core_scripted_process.py"
        self.runCmd(
            "command script import "
            + os.path.join(self.getSourceDir(), scripted_process_example_relpath)
        )

        corefile_process = None
        with tempfile.NamedTemporaryFile() as file:
            self.create_stack_skinny_corefile(file.name)
            corefile_target = self.dbg.CreateTarget(None)
            corefile_process = corefile_target.LoadCore(
                self.getBuildArtifact(file.name)
            )
        self.assertTrue(corefile_process, PROCESS_IS_VALID)

        # Create a random lib which does not exist in the corefile.
        random_dylib = self.get_module_with_name(corefile_target, "random.dylib")
        self.assertFalse(
            random_dylib, "Dynamic library random.dylib should not be found."
        )

        structured_data = lldb.SBStructuredData()
        structured_data.SetFromJSON(
            json.dumps(
                {
                    "backing_target_idx": self.dbg.GetIndexOfTarget(
                        corefile_process.GetTarget()
                    ),
                    "custom_modules": [
                        {
                            "path": self.getBuildArtifact("libbaz.dylib"),
                        },
                        {
                            "path": "/random/path/random.dylib",
                            "load_addr": 12345678,
                        },
                    ],
                }
            )
        )
        launch_info = lldb.SBLaunchInfo(None)
        launch_info.SetProcessPluginName("ScriptedProcess")
        launch_info.SetScriptedProcessClassName(
            "stack_core_scripted_process.StackCoreScriptedProcess"
        )
        launch_info.SetScriptedProcessDictionary(structured_data)

        error = lldb.SBError()
        process = target.Launch(launch_info, error)
        self.assertSuccess(error)
        self.assertTrue(process, PROCESS_IS_VALID)
        self.assertEqual(process.GetProcessID(), 42)

        self.assertEqual(process.GetNumThreads(), 2)
        thread = process.GetSelectedThread()
        self.assertTrue(thread, "Invalid thread.")
        self.assertEqual(thread.GetName(), "StackCoreScriptedThread.thread-1")

        self.assertTrue(target.triple, "Invalid target triple")
        arch = target.triple.split("-")[0]
        supported_arch = ["x86_64", "arm64", "arm64e"]
        self.assertIn(arch, supported_arch)
        # When creating a corefile of a arm process, lldb saves the exception
        # that triggers the breakpoint in the LC_NOTES of the corefile, so they
        # can be reloaded with the corefile on the next debug session.
        if arch in "arm64e":
            self.assertTrue(thread.GetStopReason(), lldb.eStopReasonException)
        # However, it's architecture specific, and corefiles made from intel
        # process don't save any metadata to retrieve to stop reason.
        # To mitigate this, the StackCoreScriptedProcess will report a
        # eStopReasonSignal with a SIGTRAP, mimicking what debugserver does.
        else:
            self.assertTrue(thread.GetStopReason(), lldb.eStopReasonSignal)

        self.assertEqual(thread.GetNumFrames(), 5)
        frame = thread.GetSelectedFrame()
        self.assertTrue(frame, "Invalid frame.")
        func = frame.GetFunction()
        self.assertTrue(func, "Invalid function.")

        self.assertIn("baz", frame.GetFunctionName())
        self.assertGreater(frame.vars.GetSize(), 0)
        self.assertEqual(int(frame.vars.GetFirstValueByName("k").GetValue()), 42)
        self.assertEqual(
            int(frame.vars.GetFirstValueByName("j").Dereference().GetValue()), 42 * 42
        )

        corefile_dylib = self.get_module_with_name(corefile_target, "libbaz.dylib")
        self.assertTrue(corefile_dylib, "Dynamic library libbaz.dylib not found.")
        scripted_dylib = self.get_module_with_name(target, "libbaz.dylib")
        self.assertTrue(scripted_dylib, "Dynamic library libbaz.dylib not found.")
        self.assertEqual(
            scripted_dylib.GetObjectFileHeaderAddress().GetLoadAddress(target),
            corefile_dylib.GetObjectFileHeaderAddress().GetLoadAddress(target),
        )
