"""
Class for parsing Python tracebacks.

This module was adapted from the `tblib` package https://github.com/ionelmc/python-tblib
modified to also recover line content from the traceback.

BSD 2-Clause License

Copyright (c) 2013-2023, Ionel Cristian Mărieș. All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are
permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, this list of
    conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright notice, this list
    of conditions and the following disclaimer in the documentation and/or other materials
    provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
"""

import re
import sys
from types import CodeType, FrameType, TracebackType
from typing import Any, Dict, List, Optional

__version__ = "3.0.0"
__all__ = "Traceback", "TracebackParseError", "Frame", "Code"

FRAME_RE = re.compile(
    r'^\s*File "(?P<co_filename>.+)", line (?P<tb_lineno>\d+)(, in (?P<co_name>.+))?$'
)


class _AttrDict(dict):
    __slots__ = ()

    def __getattr__(self, name: str) -> Any:
        try:
            return self[name]
        except KeyError:
            raise AttributeError(name) from None


# noinspection PyPep8Naming
class __traceback_maker(Exception):
    pass


class TracebackParseError(Exception):
    pass


class Code:
    """
    Class that replicates just enough of the builtin Code object to enable serialization
    and traceback rendering.
    """

    co_code: Optional[bytes] = None

    def __init__(self, code: CodeType) -> None:
        self.co_filename = code.co_filename
        self.co_name: Optional[str] = code.co_name
        self.co_argcount = 0
        self.co_kwonlyargcount = 0
        self.co_varnames = ()
        self.co_nlocals = 0
        self.co_stacksize = 0
        self.co_flags = 64
        self.co_firstlineno = 0


class Frame:
    """
    Class that replicates just enough of the builtin Frame object to enable serialization
    and traceback rendering.

    Args:

        get_locals (callable): A function that take a frame argument and returns a dict.

            See :class:`Traceback` class for example.
    """

    def __init__(self, frame: FrameType, *, get_locals: Any = None) -> None:
        self.f_locals = {} if get_locals is None else get_locals(frame)
        self.f_globals = {k: v for k, v in frame.f_globals.items() if k in ("__file__", "__name__")}
        self.f_code = Code(frame.f_code)
        self.f_lineno = frame.f_lineno

    def clear(self) -> None:
        """
        For compatibility with PyPy 3.5;
        clear() was added to frame in Python 3.4
        and is called by traceback.clear_frames(), which
        in turn is called by unittest.TestCase.assertRaises
        """


class LineCacheEntry(list):
    """
    The list of lines in a file where only some of the lines are available.
    """

    def set_line(self, lineno: int, line: str) -> None:
        self.extend([""] * (lineno - len(self)))
        self[lineno - 1] = line


class Traceback:
    """
    Class that wraps builtin Traceback objects.

    Args:
        get_locals (callable): A function that take a frame argument and returns a dict.

            Ideally you will only return exactly what you need, and only with simple types
            that can be json serializable.

            Example:

            .. code:: python

                def get_locals(frame):
                    if frame.f_locals.get("__tracebackhide__"):
                        return {"__tracebackhide__": True}
                    else:
                        return {}
    """

    tb_next: Optional["Traceback"] = None

    def __init__(self, tb: TracebackType, *, get_locals: Any = None):
        self.tb_frame = Frame(tb.tb_frame, get_locals=get_locals)
        self.tb_lineno = int(tb.tb_lineno)
        self.cached_lines: Dict[str, Dict[int, str]] = {}  # filename -> lineno -> line
        """
        Lines shown in the parsed traceback.
        """

        # Build in place to avoid exceeding the recursion limit
        _tb = tb.tb_next
        prev_traceback = self
        cls = type(self)
        while _tb is not None:
            traceback = object.__new__(cls)
            traceback.tb_frame = Frame(_tb.tb_frame, get_locals=get_locals)
            traceback.tb_lineno = int(_tb.tb_lineno)
            prev_traceback.tb_next = traceback
            prev_traceback = traceback
            _tb = _tb.tb_next

    def populate_linecache(self) -> None:
        """
        For each cached line, update the linecache if the file is not present.
        This helps us show the original lines even if the source file is not available,
        for example when the parsed traceback comes from a different host.
        """
        import linecache

        for filename, lines in self.cached_lines.items():
            entry: list[str] = linecache.getlines(filename, module_globals=None)
            if entry:
                if not isinstance(entry, LineCacheEntry):
                    # no need to update the cache if the file is present
                    continue
            else:
                entry = LineCacheEntry()
                linecache.cache[filename] = (1, None, entry, filename)
            for lineno, line in lines.items():
                entry.set_line(lineno, line)

    def as_traceback(self) -> Optional[TracebackType]:
        """
        Convert to a builtin Traceback object that is usable for raising or rendering a stacktrace.
        """
        current: Optional[Traceback] = self
        top_tb = None
        tb = None
        stub = compile(
            "raise __traceback_maker",
            "<string>",
            "exec",
        )
        while current:
            f_code = current.tb_frame.f_code
            code = stub.replace(
                co_firstlineno=current.tb_lineno,
                co_argcount=0,
                co_filename=f_code.co_filename,
                co_name=f_code.co_name or stub.co_name,
                co_freevars=(),
                co_cellvars=(),
            )

            # noinspection PyBroadException
            try:
                exec(
                    code, dict(current.tb_frame.f_globals), dict(current.tb_frame.f_locals)
                )  # noqa: S102
            except Exception:
                next_tb = sys.exc_info()[2].tb_next  # type: ignore
                if top_tb is None:
                    top_tb = next_tb
                if tb is not None:
                    tb.tb_next = next_tb
                tb = next_tb
                del next_tb

            current = current.tb_next
        try:
            return top_tb
        finally:
            del top_tb
            del tb

    to_traceback = as_traceback

    def as_dict(self) -> dict:
        """
        Converts to a dictionary representation. You can serialize the result to JSON
        as it only has builtin objects like dicts, lists, ints or strings.
        """
        if self.tb_next is None:
            tb_next = None
        else:
            tb_next = self.tb_next.as_dict()

        code = {
            "co_filename": self.tb_frame.f_code.co_filename,
            "co_name": self.tb_frame.f_code.co_name,
        }
        frame = {
            "f_globals": self.tb_frame.f_globals,
            "f_locals": self.tb_frame.f_locals,
            "f_code": code,
            "f_lineno": self.tb_frame.f_lineno,
        }
        return {
            "tb_frame": frame,
            "tb_lineno": self.tb_lineno,
            "tb_next": tb_next,
        }

    to_dict = as_dict

    @classmethod
    def from_dict(cls, dct: dict) -> "Traceback":
        """
        Creates an instance from a dictionary with the same structure as ``.as_dict()`` returns.
        """
        if dct["tb_next"]:
            tb_next = cls.from_dict(dct["tb_next"])
        else:
            tb_next = None

        code = _AttrDict(
            co_filename=dct["tb_frame"]["f_code"]["co_filename"],
            co_name=dct["tb_frame"]["f_code"]["co_name"],
        )
        frame = _AttrDict(
            f_globals=dct["tb_frame"]["f_globals"],
            f_locals=dct["tb_frame"].get("f_locals", {}),
            f_code=code,
            f_lineno=dct["tb_frame"]["f_lineno"],
        )
        tb = _AttrDict(
            tb_frame=frame,
            tb_lineno=dct["tb_lineno"],
            tb_next=tb_next,
        )
        return cls(tb, get_locals=get_all_locals)  # type: ignore

    @classmethod
    def from_string(cls, string: str, strict: bool = True) -> "Traceback":
        """
        Creates an instance by parsing a stacktrace.
        Strict means that parsing stops when lines are not indented by at least two spaces anymore.
        """

        frames: List[Dict[str, str]] = []
        cached_lines: Dict[str, Dict[int, str]] = {}

        lines = string.splitlines()[::-1]
        if strict:  # skip the header
            while lines:
                line = lines.pop()
                if line == "Traceback (most recent call last):":
                    break

        while lines:
            line = lines.pop()
            frame_match = FRAME_RE.match(line)
            if frame_match:
                frames.append(frame_match.groupdict())
                if lines and lines[-1].startswith("    "):  # code for the frame
                    code = lines.pop().strip()
                    filename = frame_match.group("co_filename")
                    lineno = int(frame_match.group("tb_lineno"))
                    cached_lines.setdefault(filename, {}).setdefault(lineno, code)
            elif line.startswith("  "):
                pass
            elif strict:
                break  # traceback ended

        if frames:
            previous = None
            for frame in reversed(frames):
                previous = _AttrDict(
                    frame,
                    tb_frame=_AttrDict(
                        frame,
                        f_globals=_AttrDict(
                            __file__=frame["co_filename"],
                            __name__="?",
                        ),
                        f_locals={},
                        f_code=_AttrDict(frame),
                        f_lineno=int(frame["tb_lineno"]),
                    ),
                    tb_next=previous,
                )
            self = cls(previous)  # type: ignore
            self.cached_lines = cached_lines
            return self
        else:
            raise TracebackParseError("Could not find any frames in %r." % string)


def get_all_locals(frame: FrameType) -> dict:
    return dict(frame.f_locals)