"""
Test that lldb can target and debug an executable whose path is longer than the
Windows MAX_PATH limit (260 characters).
"""

import os
import shutil
import subprocess

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

MAX_PATH = 260


@requireWindows
class LongPathTargetTestCase(TestBase):
    NO_DEBUG_INFO_TESTCASE = True

    def _long_path(self, path):
        return lldbutil.get_extended_windows_path(path)

    def _normalize(self, path):
        if path.startswith("\\\\?\\"):
            path = path[4:]
        return os.path.normcase(os.path.normpath(path))

    def _make_long_dir(self):
        """Create (and return) a directory whose absolute path comfortably
        exceeds MAX_PATH, or None if the OS refuses to create it."""
        components = [self.getBuildArtifact("deep")] + ["d" * 80] * 3
        target_dir = os.path.join(*components)
        try:
            os.makedirs(self._long_path(target_dir), exist_ok=True)
        except OSError:
            return None
        return target_dir

    def _find_module(self, target, long_exe):
        """Return the module in `target` whose path matches `long_exe`, or an
        invalid module if none does."""
        wanted = self._normalize(long_exe)
        for i in range(target.GetNumModules()):
            mod = target.GetModuleAtIndex(i)
            if self._normalize(mod.GetFileSpec().fullpath) == wanted:
                return mod
        return lldb.SBModule()

    def _copy_exe_to_long_dir(self):
        """Build the test program, copy it into a directory whose path exceeds
        MAX_PATH and return the path of the copy."""
        self.build()
        src_exe = self.getBuildArtifact("a.out")

        long_dir = self._make_long_dir()
        if long_dir is None:
            self.skipTest("OS cannot create paths longer than MAX_PATH")

        long_exe = os.path.join(long_dir, os.path.basename(src_exe))
        shutil.copyfile(src_exe, self._long_path(long_exe))

        self.assertGreater(
            len(os.path.abspath(long_exe)),
            MAX_PATH,
            "the test executable path must exceed MAX_PATH to be meaningful",
        )
        return long_exe

    def test_target_with_long_path(self):
        """CreateTarget, launch and break in an executable located past
        MAX_PATH, and verify the full path is preserved (not truncated)."""
        long_exe = self._copy_exe_to_long_dir()
        exe_basename = os.path.basename(long_exe)

        # Creating the target has to open and parse the file at the long path.
        target = self.dbg.CreateTarget(long_exe)
        self.assertTrue(target.IsValid(), VALID_TARGET)

        # The main executable module must report its full, untruncated path.
        module = self._find_module(target, long_exe)
        self.assertTrue(
            module.IsValid(),
            "the executable module should be found by its full long path",
        )
        self.assertGreater(
            len(module.GetFileSpec().fullpath), MAX_PATH, "module path truncated"
        )

        bp = target.BreakpointCreateByName("main", exe_basename)
        self.assertGreater(bp.GetNumLocations(), 0, "main breakpoint has a location")

        process = target.LaunchSimple(None, None, self.get_process_working_directory())
        self.assertTrue(process.IsValid(), PROCESS_IS_VALID)
        self.assertState(
            process.GetState(), lldb.eStateStopped, "process stopped at main"
        )

        thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint)
        self.assertIsNotNone(thread, "stopped at the main breakpoint")
        self.assertEqual(thread.GetFrameAtIndex(0).GetFunctionName(), "main")

        # After launch the loaded executable module still carries the full path.
        live_module = self._find_module(process.GetTarget(), long_exe)
        self.assertTrue(live_module.IsValid(), "loaded module found by long path")
        self.assertGreater(
            len(live_module.GetFileSpec().fullpath),
            MAX_PATH,
            "loaded module path truncated",
        )

        process.Continue()
        self.assertState(process.GetState(), lldb.eStateExited)
        self.assertEqual(process.GetExitStatus(), 0)

    def test_attach_with_long_path(self):
        """Attach by pid to a process whose executable is located past
        MAX_PATH, and verify lldb determines its architecture and stops it."""
        long_exe = self._copy_exe_to_long_dir()

        token = self.getBuildArtifact("token")
        # Pass the "\\?\" form so CreateProcessW accepts a path past MAX_PATH.
        popen = subprocess.Popen(
            [long_exe, token], executable=self._long_path(long_exe)
        )
        self.addTearDownHook(popen.kill)
        lldbutil.wait_for_file_on_target(self, token)

        # Start from an empty target so the architecture has to come from the
        # process.
        target = self.dbg.CreateTarget("")
        error = lldb.SBError()
        process = target.AttachToProcessWithID(self.dbg.GetListener(), popen.pid, error)
        self.assertSuccess(error)
        self.assertTrue(process.IsValid(), PROCESS_IS_VALID)
        self.assertState(process.GetState(), lldb.eStateStopped)

        triple = target.GetTriple()
        self.assertTrue(triple, "target has a triple")
        self.assertNotEqual(triple.split("-")[0], "unknown", "target arch is known")
        # This reads the image file through Host::GetProcessInfo in lldb.
        self.assertTrue(
            process.GetProcessInfo().GetTriple(), "process info has a triple"
        )

        self.assertGreater(process.GetNumThreads(), 0, "process has threads")
        frame = process.GetSelectedThread().GetFrameAtIndex(0)
        self.assertTrue(frame.GetModule().IsValid(), "frame 0 is in a module")

        exe_module = target.FindModule(lldb.SBFileSpec(os.path.basename(long_exe)))
        self.assertTrue(exe_module.IsValid(), "the executable module is loaded")