"""
    pygments.formatters.img
    ~~~~~~~~~~~~~~~~~~~~~~~

    Formatter for Pixmap output.

    :copyright: Copyright 2006-2022 by the Pygments team, see AUTHORS.
    :license: BSD, see LICENSE for details.
"""

import os
import sys

from pip._vendor.pygments.formatter import Formatter
from pip._vendor.pygments.util import (
    get_bool_opt,
    get_int_opt,
    get_list_opt,
    get_choice_opt,
)

import subprocess

# Import this carefully
try:
    from PIL import Image, ImageDraw, ImageFont

    pil_available = True
except ImportError:
    pil_available = False

try:
    import _winreg
except ImportError:
    try:
        import winreg as _winreg
    except ImportError:
        _winreg = None

__all__ = [
    "ImageFormatter",
    "GifImageFormatter",
    "JpgImageFormatter",
    "BmpImageFormatter",
]


# For some unknown reason every font calls it something different
STYLES = {
    "NORMAL": ["", "Roman", "Book", "Normal", "Regular", "Medium"],
    "ITALIC": ["Oblique", "Italic"],
    "BOLD": ["Bold"],
    "BOLDITALIC": ["Bold Oblique", "Bold Italic"],
}

# A sane default for modern systems
DEFAULT_FONT_NAME_NIX = "DejaVu Sans Mono"
DEFAULT_FONT_NAME_WIN = "Courier New"
DEFAULT_FONT_NAME_MAC = "Menlo"


class PilNotAvailable(ImportError):
    """When Python imaging library is not available"""


class FontNotFound(Exception):
    """When there are no usable fonts specified"""


class FontManager:
    """
    Manages a set of fonts: normal, italic, bold, etc...
    """

    def __init__(self, font_name, font_size=14):
        self.font_name = font_name
        self.font_size = font_size
        self.fonts = {}
        self.encoding = None
        if sys.platform.startswith("win"):
            if not font_name:
                self.font_name = DEFAULT_FONT_NAME_WIN
            self._create_win()
        elif sys.platform.startswith("darwin"):
            if not font_name:
                self.font_name = DEFAULT_FONT_NAME_MAC
            self._create_mac()
        else:
            if not font_name:
                self.font_name = DEFAULT_FONT_NAME_NIX
            self._create_nix()

    def _get_nix_font_path(self, name, style):
        proc = subprocess.Popen(
            ["fc-list", "%s:style=%s" % (name, style), "file"],
            stdout=subprocess.PIPE,
            stderr=None,
        )
        stdout, _ = proc.communicate()
        if proc.returncode == 0:
            lines = stdout.splitlines()
            for line in lines:
                if line.startswith(b"Fontconfig warning:"):
                    continue
                path = line.decode().strip().strip(":")
                if path:
                    return path
            return None

    def _create_nix(self):
        for name in STYLES["NORMAL"]:
            path = self._get_nix_font_path(self.font_name, name)
            if path is not None:
                self.fonts["NORMAL"] = ImageFont.truetype(path, self.font_size)
                break
        else:
            raise FontNotFound('No usable fonts named: "%s"' % self.font_name)
        for style in ("ITALIC", "BOLD", "BOLDITALIC"):
            for stylename in STYLES[style]:
                path = self._get_nix_font_path(self.font_name, stylename)
                if path is not None:
                    self.fonts[style] = ImageFont.truetype(path, self.font_size)
                    break
            else:
                if style == "BOLDITALIC":
                    self.fonts[style] = self.fonts["BOLD"]
                else:
                    self.fonts[style] = self.fonts["NORMAL"]

    def _get_mac_font_path(self, font_map, name, style):
        return font_map.get((name + " " + style).strip().lower())

    def _create_mac(self):
        font_map = {}
        for font_dir in (
            os.path.join(os.getenv("HOME"), "Library/Fonts/"),
            "/Library/Fonts/",
            "/System/Library/Fonts/",
        ):
            font_map.update(
                (os.path.splitext(f)[0].lower(), os.path.join(font_dir, f))
                for f in os.listdir(font_dir)
                if f.lower().endswith(("ttf", "ttc"))
            )

        for name in STYLES["NORMAL"]:
            path = self._get_mac_font_path(font_map, self.font_name, name)
            if path is not None:
                self.fonts["NORMAL"] = ImageFont.truetype(path, self.font_size)
                break
        else:
            raise FontNotFound('No usable fonts named: "%s"' % self.font_name)
        for style in ("ITALIC", "BOLD", "BOLDITALIC"):
            for stylename in STYLES[style]:
                path = self._get_mac_font_path(font_map, self.font_name, stylename)
                if path is not None:
                    self.fonts[style] = ImageFont.truetype(path, self.font_size)
                    break
            else:
                if style == "BOLDITALIC":
                    self.fonts[style] = self.fonts["BOLD"]
                else:
                    self.fonts[style] = self.fonts["NORMAL"]

    def _lookup_win(self, key, basename, styles, fail=False):
        for suffix in ("", " (TrueType)"):
            for style in styles:
                try:
                    valname = "%s%s%s" % (basename, style and " " + style, suffix)
                    val, _ = _winreg.QueryValueEx(key, valname)
                    return val
                except OSError:
                    continue
        else:
            if fail:
                raise FontNotFound(
                    "Font %s (%s) not found in registry" % (basename, styles[0])
                )
            return None

    def _create_win(self):
        lookuperror = None
        keynames = [
            (
                _winreg.HKEY_CURRENT_USER,
                r"Software\Microsoft\Windows NT\CurrentVersion\Fonts",
            ),
            (
                _winreg.HKEY_CURRENT_USER,
                r"Software\Microsoft\Windows\CurrentVersion\Fonts",
            ),
            (
                _winreg.HKEY_LOCAL_MACHINE,
                r"Software\Microsoft\Windows NT\CurrentVersion\Fonts",
            ),
            (
                _winreg.HKEY_LOCAL_MACHINE,
                r"Software\Microsoft\Windows\CurrentVersion\Fonts",
            ),
        ]
        for keyname in keynames:
            try:
                key = _winreg.OpenKey(*keyname)
                try:
                    path = self._lookup_win(key, self.font_name, STYLES["NORMAL"], True)
                    self.fonts["NORMAL"] = ImageFont.truetype(path, self.font_size)
                    for style in ("ITALIC", "BOLD", "BOLDITALIC"):
                        path = self._lookup_win(key, self.font_name, STYLES[style])
                        if path:
                            self.fonts[style] = ImageFont.truetype(path, self.font_size)
                        else:
                            if style == "BOLDITALIC":
                                self.fonts[style] = self.fonts["BOLD"]
                            else:
                                self.fonts[style] = self.fonts["NORMAL"]
                    return
                except FontNotFound as err:
                    lookuperror = err
                finally:
                    _winreg.CloseKey(key)
            except OSError:
                pass
        else:
            # If we get here, we checked all registry keys and had no luck
            # We can be in one of two situations now:
            # * All key lookups failed. In this case lookuperror is None and we
            #   will raise a generic error
            # * At least one lookup failed with a FontNotFound error. In this
            #   case, we will raise that as a more specific error
            if lookuperror:
                raise lookuperror
            raise FontNotFound("Can't open Windows font registry key")

    def get_char_size(self):
        """
        Get the character size.
        """
        return self.get_text_size("M")

    def get_text_size(self, text):
        """
        Get the text size (width, height).
        """
        font = self.fonts["NORMAL"]
        if hasattr(font, "getbbox"):  # Pillow >= 9.2.0
            return font.getbbox(text)[2:4]
        else:
            return font.getsize(text)

    def get_font(self, bold, oblique):
        """
        Get the font based on bold and italic flags.
        """
        if bold and oblique:
            return self.fonts["BOLDITALIC"]
        elif bold:
            return self.fonts["BOLD"]
        elif oblique:
            return self.fonts["ITALIC"]
        else:
            return self.fonts["NORMAL"]


class ImageFormatter(Formatter):
    """
    Create a PNG image from source code. This uses the Python Imaging Library to
    generate a pixmap from the source code.

    .. versionadded:: 0.10

    Additional options accepted:

    `image_format`
        An image format to output to that is recognised by PIL, these include:

        * "PNG" (default)
        * "JPEG"
        * "BMP"
        * "GIF"

    `line_pad`
        The extra spacing (in pixels) between each line of text.

        Default: 2

    `font_name`
        The font name to be used as the base font from which others, such as
        bold and italic fonts will be generated.  This really should be a
        monospace font to look sane.

        Default: "Courier New" on Windows, "Menlo" on Mac OS, and
                 "DejaVu Sans Mono" on \\*nix

    `font_size`
        The font size in points to be used.

        Default: 14

    `image_pad`
        The padding, in pixels to be used at each edge of the resulting image.

        Default: 10

    `line_numbers`
        Whether line numbers should be shown: True/False

        Default: True

    `line_number_start`
        The line number of the first line.

        Default: 1

    `line_number_step`
        The step used when printing line numbers.

        Default: 1

    `line_number_bg`
        The background colour (in "#123456" format) of the line number bar, or
        None to use the style background color.

        Default: "#eed"

    `line_number_fg`
        The text color of the line numbers (in "#123456"-like format).

        Default: "#886"

    `line_number_chars`
        The number of columns of line numbers allowable in the line number
        margin.

        Default: 2

    `line_number_bold`
        Whether line numbers will be bold: True/False

        Default: False

    `line_number_italic`
        Whether line numbers will be italicized: True/False

        Default: False

    `line_number_separator`
        Whether a line will be drawn between the line number area and the
        source code area: True/False

        Default: True

    `line_number_pad`
        The horizontal padding (in pixels) between the line number margin, and
        the source code area.

        Default: 6

    `hl_lines`
        Specify a list of lines to be highlighted.

        .. versionadded:: 1.2

        Default: empty list

    `hl_color`
        Specify the color for highlighting lines.

        .. versionadded:: 1.2

        Default: highlight color of the selected style
    """

    # Required by the pygments mapper
    name = "img"
    aliases = ["img", "IMG", "png"]
    filenames = ["*.png"]

    unicodeoutput = False

    default_image_format = "png"

    def __init__(self, **options):
        """
        See the class docstring for explanation of options.
        """
        if not pil_available:
            raise PilNotAvailable(
                "Python Imaging Library is required for this formatter"
            )
        Formatter.__init__(self, **options)
        self.encoding = "latin1"  # let pygments.format() do the right thing
        # Read the style
        self.styles = dict(self.style)
        if self.style.background_color is None:
            self.background_color = "#fff"
        else:
            self.background_color = self.style.background_color
        # Image options
        self.image_format = get_choice_opt(
            options,
            "image_format",
            ["png", "jpeg", "gif", "bmp"],
            self.default_image_format,
            normcase=True,
        )
        self.image_pad = get_int_opt(options, "image_pad", 10)
        self.line_pad = get_int_opt(options, "line_pad", 2)
        # The fonts
        fontsize = get_int_opt(options, "font_size", 14)
        self.fonts = FontManager(options.get("font_name", ""), fontsize)
        self.fontw, self.fonth = self.fonts.get_char_size()
        # Line number options
        self.line_number_fg = options.get("line_number_fg", "#886")
        self.line_number_bg = options.get("line_number_bg", "#eed")
        self.line_number_chars = get_int_opt(options, "line_number_chars", 2)
        self.line_number_bold = get_bool_opt(options, "line_number_bold", False)
        self.line_number_italic = get_bool_opt(options, "line_number_italic", False)
        self.line_number_pad = get_int_opt(options, "line_number_pad", 6)
        self.line_numbers = get_bool_opt(options, "line_numbers", True)
        self.line_number_separator = get_bool_opt(
            options, "line_number_separator", True
        )
        self.line_number_step = get_int_opt(options, "line_number_step", 1)
        self.line_number_start = get_int_opt(options, "line_number_start", 1)
        if self.line_numbers:
            self.line_number_width = (
                self.fontw * self.line_number_chars + self.line_number_pad * 2
            )
        else:
            self.line_number_width = 0
        self.hl_lines = []
        hl_lines_str = get_list_opt(options, "hl_lines", [])
        for line in hl_lines_str:
            try:
                self.hl_lines.append(int(line))
            except ValueError:
                pass
        self.hl_color = options.get("hl_color", self.style.highlight_color) or "#f90"
        self.drawables = []

    def get_style_defs(self, arg=""):
        raise NotImplementedError(
            "The -S option is meaningless for the image "
            "formatter. Use -O style=<stylename> instead."
        )

    def _get_line_height(self):
        """
        Get the height of a line.
        """
        return self.fonth + self.line_pad

    def _get_line_y(self, lineno):
        """
        Get the Y coordinate of a line number.
        """
        return lineno * self._get_line_height() + self.image_pad

    def _get_char_width(self):
        """
        Get the width of a character.
        """
        return self.fontw

    def _get_char_x(self, linelength):
        """
        Get the X coordinate of a character position.
        """
        return linelength + self.image_pad + self.line_number_width

    def _get_text_pos(self, linelength, lineno):
        """
        Get the actual position for a character and line position.
        """
        return self._get_char_x(linelength), self._get_line_y(lineno)

    def _get_linenumber_pos(self, lineno):
        """
        Get the actual position for the start of a line number.
        """
        return (self.image_pad, self._get_line_y(lineno))

    def _get_text_color(self, style):
        """
        Get the correct color for the token from the style.
        """
        if style["color"] is not None:
            fill = "#" + style["color"]
        else:
            fill = "#000"
        return fill

    def _get_text_bg_color(self, style):
        """
        Get the correct background color for the token from the style.
        """
        if style["bgcolor"] is not None:
            bg_color = "#" + style["bgcolor"]
        else:
            bg_color = None
        return bg_color

    def _get_style_font(self, style):
        """
        Get the correct font for the style.
        """
        return self.fonts.get_font(style["bold"], style["italic"])

    def _get_image_size(self, maxlinelength, maxlineno):
        """
        Get the required image size.
        """
        return (
            self._get_char_x(maxlinelength) + self.image_pad,
            self._get_line_y(maxlineno + 0) + self.image_pad,
        )

    def _draw_linenumber(self, posno, lineno):
        """
        Remember a line number drawable to paint later.
        """
        self._draw_text(
            self._get_linenumber_pos(posno),
            str(lineno).rjust(self.line_number_chars),
            font=self.fonts.get_font(self.line_number_bold, self.line_number_italic),
            text_fg=self.line_number_fg,
            text_bg=None,
        )

    def _draw_text(self, pos, text, font, text_fg, text_bg):
        """
        Remember a single drawable tuple to paint later.
        """
        self.drawables.append((pos, text, font, text_fg, text_bg))

    def _create_drawables(self, tokensource):
        """
        Create drawables for the token content.
        """
        lineno = charno = maxcharno = 0
        maxlinelength = linelength = 0
        for ttype, value in tokensource:
            while ttype not in self.styles:
                ttype = ttype.parent
            style = self.styles[ttype]
            # TODO: make sure tab expansion happens earlier in the chain.  It
            # really ought to be done on the input, as to do it right here is
            # quite complex.
            value = value.expandtabs(4)
            lines = value.splitlines(True)
            # print lines
            for i, line in enumerate(lines):
                temp = line.rstrip("\n")
                if temp:
                    self._draw_text(
                        self._get_text_pos(linelength, lineno),
                        temp,
                        font=self._get_style_font(style),
                        text_fg=self._get_text_color(style),
                        text_bg=self._get_text_bg_color(style),
                    )
                    temp_width, _ = self.fonts.get_text_size(temp)
                    linelength += temp_width
                    maxlinelength = max(maxlinelength, linelength)
                    charno += len(temp)
                    maxcharno = max(maxcharno, charno)
                if line.endswith("\n"):
                    # add a line for each extra line in the value
                    linelength = 0
                    charno = 0
                    lineno += 1
        self.maxlinelength = maxlinelength
        self.maxcharno = maxcharno
        self.maxlineno = lineno

    def _draw_line_numbers(self):
        """
        Create drawables for the line numbers.
        """
        if not self.line_numbers:
            return
        for p in range(self.maxlineno):
            n = p + self.line_number_start
            if (n % self.line_number_step) == 0:
                self._draw_linenumber(p, n)

    def _paint_line_number_bg(self, im):
        """
        Paint the line number background on the image.
        """
        if not self.line_numbers:
            return
        if self.line_number_fg is None:
            return
        draw = ImageDraw.Draw(im)
        recth = im.size[-1]
        rectw = self.image_pad + self.line_number_width - self.line_number_pad
        draw.rectangle([(0, 0), (rectw, recth)], fill=self.line_number_bg)
        if self.line_number_separator:
            draw.line([(rectw, 0), (rectw, recth)], fill=self.line_number_fg)
        del draw

    def format(self, tokensource, outfile):
        """
        Format ``tokensource``, an iterable of ``(tokentype, tokenstring)``
        tuples and write it into ``outfile``.

        This implementation calculates where it should draw each token on the
        pixmap, then calculates the required pixmap size and draws the items.
        """
        self._create_drawables(tokensource)
        self._draw_line_numbers()
        im = Image.new(
            "RGB",
            self._get_image_size(self.maxlinelength, self.maxlineno),
            self.background_color,
        )
        self._paint_line_number_bg(im)
        draw = ImageDraw.Draw(im)
        # Highlight
        if self.hl_lines:
            x = self.image_pad + self.line_number_width - self.line_number_pad + 1
            recth = self._get_line_height()
            rectw = im.size[0] - x
            for linenumber in self.hl_lines:
                y = self._get_line_y(linenumber - 1)
                draw.rectangle([(x, y), (x + rectw, y + recth)], fill=self.hl_color)
        for pos, value, font, text_fg, text_bg in self.drawables:
            if text_bg:
                text_size = draw.textsize(text=value, font=font)
                draw.rectangle(
                    [pos[0], pos[1], pos[0] + text_size[0], pos[1] + text_size[1]],
                    fill=text_bg,
                )
            draw.text(pos, value, font=font, fill=text_fg)
        im.save(outfile, self.image_format.upper())


# Add one formatter per format, so that the "-f gif" option gives the correct result
# when used in pygmentize.


class GifImageFormatter(ImageFormatter):
    """
    Create a GIF image from source code. This uses the Python Imaging Library to
    generate a pixmap from the source code.

    .. versionadded:: 1.0
    """

    name = "img_gif"
    aliases = ["gif"]
    filenames = ["*.gif"]
    default_image_format = "gif"


class JpgImageFormatter(ImageFormatter):
    """
    Create a JPEG image from source code. This uses the Python Imaging Library to
    generate a pixmap from the source code.

    .. versionadded:: 1.0
    """

    name = "img_jpg"
    aliases = ["jpg", "jpeg"]
    filenames = ["*.jpg"]
    default_image_format = "jpeg"


class BmpImageFormatter(ImageFormatter):
    """
    Create a bitmap image from source code. This uses the Python Imaging Library to
    generate a pixmap from the source code.

    .. versionadded:: 1.0
    """

    name = "img_bmp"
    aliases = ["bmp", "bitmap"]
    filenames = ["*.bmp"]
    default_image_format = "bmp"
