from dataclasses import dataclass
from io import BytesIO

from pyhanko.pdf_utils import generic

from ..writer import BasePdfFileWriter
from .api import FontEngine, FontEngineFactory, ShapeResult

pdf_name = generic.NameObject

__all__ = [
    'SimpleFontEngine',
    'SimpleFontEngineFactory',
    'SimpleFontMeta',
    'get_courier',
]


@dataclass(frozen=True)
class SimpleFontMeta:
    first_char: int
    last_char: int
    widths: list[int]
    descriptor: generic.DictionaryObject


COURIER_META = SimpleFontMeta(
    # only define one width, let everything default to MissingWidth
    first_char=32,
    last_char=32,
    widths=[600],
    descriptor=generic.DictionaryObject(
        {
            pdf_name('/Type'): pdf_name('/FontDescriptor'),
            pdf_name('/FontName'): pdf_name('/Courier'),
            # set fixed pitch, serif and nonsymbolic
            pdf_name('/Flags'): generic.NumberObject(0b100011),
            pdf_name('/FontBBox'): generic.ArrayObject(
                map(generic.NumberObject, [-23, -250, 715, 805])
            ),
            pdf_name('/Ascent'): generic.NumberObject(629),
            pdf_name('/Descent'): generic.NumberObject(-157),
            pdf_name('/CapHeight'): generic.NumberObject(629),
            pdf_name('/ItalicAngle'): generic.NumberObject(0),
            pdf_name('/StemV'): generic.NumberObject(51),
            pdf_name('/MissingWidth'): generic.NumberObject(600),
            pdf_name('/AvgWidth'): generic.NumberObject(600),
            pdf_name('/MaxWidth'): generic.NumberObject(600),
        }
    ),
)


class SimpleFontEngine(FontEngine):
    """
    Simplistic font engine that effectively only works with PDF standard fonts,
    and does not care about font metrics. Best used with monospaced fonts such
    as Courier.
    """

    @property
    def uses_complex_positioning(self):
        return False

    def __init__(
        self,
        writer: BasePdfFileWriter,
        name: str,
        avg_width: float,
        meta: SimpleFontMeta | None = None,
    ):
        self.avg_width = avg_width
        self.name = name
        self.meta = meta
        super().__init__(writer, name, embedded_subset=False)

    def shape(self, txt) -> ShapeResult:
        ops = BytesIO()
        generic.TextStringObject(txt).write_to_stream(ops)
        ops.write(b" Tj")
        total_len = len(txt) * self.avg_width

        return ShapeResult(
            graphics_ops=ops.getvalue(), x_advance=total_len, y_advance=0
        )

    def as_resource(self):
        font_dict = generic.DictionaryObject(
            {
                pdf_name('/Type'): pdf_name('/Font'),
                pdf_name('/BaseFont'): pdf_name('/' + self.name),
                pdf_name('/Subtype'): pdf_name('/Type1'),
                pdf_name('/Encoding'): pdf_name('/WinAnsiEncoding'),
            }
        )
        # TODO maybe we could be a bit more clever to avoid duplication
        #  (cf. how GlyphAccumulator does it)
        meta = self.meta
        if meta is not None:
            font_dict['/FirstChar'] = generic.NumberObject(meta.first_char)
            font_dict['/LastChar'] = generic.NumberObject(meta.last_char)
            font_dict['/Widths'] = generic.ArrayObject(
                map(generic.NumberObject, meta.widths)
            )
            font_dict['/FontDescriptor'] = self.writer.add_object(
                generic.DictionaryObject(meta.descriptor)
            )

        return font_dict


class SimpleFontEngineFactory(FontEngineFactory):
    def __init__(
        self, name: str, avg_width: float, meta: SimpleFontMeta | None = None
    ):
        self.avg_width = avg_width
        self.name = name
        self.meta = meta

    def create_font_engine(self, writer: BasePdfFileWriter, obj_stream=None):
        return SimpleFontEngine(writer, self.name, self.avg_width, self.meta)

    @staticmethod
    def default_factory():
        """
        :return:
            A :class:`.FontEngineFactory` instance representing the Courier
            standard font.
        """
        return SimpleFontEngineFactory('Courier', 0.6, COURIER_META)


def get_courier(pdf_writer: BasePdfFileWriter):
    """
    Quick-and-dirty way to obtain a Courier font resource.

    :param pdf_writer:
        A PDF writer.
    :return:
        A resource dictionary representing the standard Courier font
        (or one of its metric equivalents).
    """

    return (
        SimpleFontEngineFactory.default_factory()
        .create_font_engine(pdf_writer)
        .as_resource()
    )
