import barcode
import os
import unicodedata

from datetime import timedelta, datetime, date
from io import BytesIO

from reportlab.lib.enums import TA_CENTER
from reportlab.lib import colors
from reportlab.lib.pagesizes import A4
from reportlab.lib.styles import ParagraphStyle
from reportlab.lib.units import mm
from reportlab.pdfbase.pdfmetrics import registerFont, registerFontFamily
from reportlab.pdfbase.ttfonts import TTFont
from reportlab.pdfgen.canvas import Canvas
from reportlab.platypus import Image, Paragraph, Spacer, HRFlowable, Frame

from .config import PPA_GROUP_IDS
from .config import ESCAPE
from .config import request_type_name


def escape(line: str) -> str:
    """
    XML-Zeichen escapen
    :param line: string
    :return: escaped string
    """
    for key, value in ESCAPE.items():
        line = line.replace(key, value)
    return line


def auslage_bis(data: dict) -> date:
    """
    Formatiert das Datum für Zettel und rechnet Tage dazu.
    :param data: dict
    :return: abholdatum (date)
    """
    value = datetime.strptime(data["requestDate"][:10], "%Y-%m-%d").date() + timedelta(
        days=7
    )
    return value


def bestelldatum(data: dict) -> str:
    """
    Formatiert das Bestelldatum mit Uhrzeit sinnvoll menschenlesbar.

    Als Bonus wird auch die Zeitzone korrekt berechnet.
    :param data:
    :return: bestelldatum (str)
    """
    value = (
        datetime.fromisoformat(f"{data['requestDate']}+00:00")
        .astimezone()
        .strftime("%Y-%m-%d %H:%M:%S %Z")
    )
    return value


def print_ppa_group(data: dict) -> str:
    """
    Gibt PPA aus, wenn der Nutzer in einer der PPA-Gruppen ist.
    :param data:
    :return: str
    """
    if data.get("requesterPatronGroupId") in PPA_GROUP_IDS:
        return "PPA"
    return ""


# Definition der Schrift
registerFont(TTFont("dejavu-mono", "DejaVuSansMono.ttf"))
registerFont(TTFont("dejavu-mono-bold", "DejaVuSansMono-Bold.ttf"))
registerFontFamily(
    "dejavu-mono",
    normal="dejavu-mono",
    bold="dejavu-mono-bold",
    italic="",
    boldItalic="",
)


def reservation_order_a4(data: dict) -> BytesIO:
    """
    Erstellt einen UB-Standardzettel für A4.

    Man beachte, dass nur die obere Hälfte des Zettels belegt sein darf, da halbe Zettel im Drucker genutzt werden.
    :param data: dict
    :return: BytesIO
    """
    # Wir schreiben das PDF in ein BytesIO
    buffer = BytesIO()

    canvas = Canvas(buffer)
    canvas.line(0, A4[1] / 2, A4[0], A4[1] / 2)

    frame = Frame(
        0,
        0,
        *A4,
        leftPadding=5 * mm,
        topPadding=5 * mm,
        bottomPadding=5 * mm,
        rightPadding=5 * mm,
    )

    font_name = "dejavu-mono"
    font_size = 10.5
    spacer_size = 0.75 * font_size

    default_style = ParagraphStyle(
        "default",
        fontName=font_name,
        fontSize=font_size,
        spaceBefore=1,
        justifyLastLine=1,
        justifyBreak=1,
    )

    pre_story = [
        f"Bestelltyp: {request_type_name(data)} / Bestelldatum {bestelldatum(data)}",
        f"Bestellstatus: {data['requestStatus']}",
        Spacer(0, spacer_size),
        f"Signatur: <b>{data.get('itemCallNumber', '-')}</b>",
        f"Band: {data.get('itemVolume', '-')}, Heftzählung: {data.get('itemEnumeration', '-')}, Jahr: {data.get('itemChronology', '-')}",
        HRFlowable(
            width="99%",
            lineCap="square",
            spaceBefore=spacer_size,
            spaceAfter=spacer_size,
            vAlign="CENTER",
            color="black",
            dash=(5, 10),
        ),
        "Bibliothekssystem der JLU Gießen",
        f"Bibliothek: {data['itemLocationLibraryName']}",
        f"Standort: <b>{data['effectiveLocationName']}</b>",
        HRFlowable(
            width="99%",
            lineCap="square",
            spaceBefore=spacer_size,
            spaceAfter=spacer_size,
            vAlign="CENTER",
            color="black",
            dash=(5, 10),
        ),
        f"Titel: {escape(data.get('instanceTitle', '-')[:82])}",
        f"Autor*innen: {escape(data.get('instanceContributorName', '-'))}",
        f"Buchnummer: <b>{data.get('itemBarcode', '')}</b>",
        HRFlowable(
            width="99%",
            lineCap="square",
            spaceBefore=spacer_size,
            spaceAfter=spacer_size,
            vAlign="CENTER",
            color="black",
            dash=(5, 10),
        ),
        f"Ausgabetheke: {data['pickupServicePointName']}",
        f"Ausleihtyp: {data['itemPermanentLoanTypeName']}",
        HRFlowable(
            width="99%",
            lineCap="square",
            spaceBefore=spacer_size,
            spaceAfter=spacer_size,
            vAlign="CENTER",
            color="black",
            dash=(5, 10),
        ),
        f"{request_type_name(data)} für:",
        f"{data.get('requesterBarcode', '-')} // <b>{data['requesterPatronGroupDescription']}</b>",
        Spacer(0, spacer_size),
        f"<b>{data['requesterLastName']}</b>, {data.get('requesterFirstName', '-')}",
        Spacer(0, spacer_size),
        f"c/o: {escape(data.get('requesterAddressLine1', ''))}",
        f"Str./Nr.: {escape(data.get('requesterAddressLine2', '-'))}",
        f"PLZ/Ort: {data.get('requesterAddressPostalCode', '-')} {data.get('requesterAddressCity', '-')}",
        f"Lieferung an: <b>{data.get('customFieldsLieferungAn', '-')}</b>",
        HRFlowable(
            width="99%",
            lineCap="square",
            spaceBefore=15,
            spaceAfter=10,
            vAlign="CENTER",
            color="black",
            dash=(5, 10),
        ),
        f"Auslage bis: <b>{auslage_bis(data)}</b>",
    ]
    story = [
        (
            Paragraph(unicodedata.normalize("NFC", line), style=default_style)
            if isinstance(line, str)
            else line
        )
        for line in pre_story
    ]

    frame.addFromList(story, canvas)

    # Handelt es sich um das Testsystem, fügen wir ein Wasserzeichen ein
    if os.environ.get("TESTSYSTEM"):
        canvas.setFillColor(colors.grey, alpha=0.4)
        canvas.setFont("dejavu-mono", 70)
        # Startkoordinaten verschieben (oberes Viertel), anschließend dort drehen
        canvas.translate(A4[0] / 2, 3 * A4[1] / 4)
        canvas.rotate(45)
        canvas.drawCentredString(0 * mm, 0 * mm, "Testsystem")

    canvas.save()

    return buffer


def reservation_bon(data: dict) -> BytesIO:
    buffer = BytesIO()

    pagesize = (72 * mm, 150 * mm)

    canvas = Canvas(buffer, pagesize=pagesize)
    frame = Frame(
        0,
        0,
        *pagesize,
        leftPadding=0 * mm,
        topPadding=0 * mm,
        bottomPadding=0 * mm,
        rightPadding=0 * mm,
    )

    font_name = "dejavu-mono"
    font_size = 9
    spacer_size = 0.75 * font_size

    default_style = ParagraphStyle(
        "default",
        fontName=font_name,
        fontSize=font_size,
        spaceBefore=1,
        justifyLastLine=1,
        justifyBreak=1,
    )
    center_style = ParagraphStyle(
        "default",
        fontName=font_name,
        fontSize=font_size + 1,
        spaceBefore=1,
        justifyLastLine=1,
        justifyBreak=1,
        alignment=TA_CENTER,
    )

    volume_barcode = BytesIO()
    barcode.Code39(
        data["itemBarcode"], writer=barcode.writer.ImageWriter(), add_checksum=False
    ).write(volume_barcode, text="")

    story = [
        Paragraph("Bibliothekssystem", style=center_style),
        Paragraph("JLU Gießen", style=center_style),
        Spacer(0, 3 * spacer_size),
        Paragraph("Zweigbibliothek Philosophikum II", style=default_style),
        Paragraph("Karl-Glöckner-Straße 21 F", style=default_style),
        Paragraph("35394 Gießen", style=default_style),
        Spacer(0, 3 * spacer_size),
        # Paragraph("Signatur", style=default_style),
        Paragraph(
            f'<b><font size="12">{data["itemCallNumber"]}</font></b>',
            style=default_style,
        ),
        Spacer(0, 4 * spacer_size),
        Paragraph(
            unicodedata.normalize("NFC", escape(data.get("instanceContributorName", "-")))[:32],
            style=default_style,
        ),
        Paragraph(
            unicodedata.normalize("NFC", escape(data.get("instanceTitle", "-")))[: 2 * 32],
            style=default_style,
        ),
        Spacer(0, 3 * spacer_size),
        Image(volume_barcode, width=72 * mm, height=25 * mm, kind="proportional"),
        Paragraph(data["itemBarcode"], style=center_style),
        Spacer(0, 3 * spacer_size),
        Paragraph(
            f'Auslage bis: <b><font size="12">{auslage_bis(data)}</font></b>',
            style=default_style,
        ),
        Spacer(0, 3 * spacer_size),
        Paragraph(
            f'Benutzernummer: xxxx<b><font size="12">{data.get("requesterBarcode", "")[-4:]}</font></b> {print_ppa_group(data)}',
            style=default_style,
        ),
    ]

    frame.addFromList(story, canvas)

    # Handelt es sich um das Testsystem, fügen wir ein Wasserzeichen ein
    if os.environ.get("TESTSYSTEM"):
        canvas.setFillColor(colors.grey, alpha=0.4)
        canvas.setFont("dejavu-mono", 30)
        # Startkoordinaten verschieben (oberes Viertel), anschließend dort drehen
        canvas.translate(72 * mm / 2, 3 * 150 * mm / 4)
        canvas.rotate(45)
        canvas.drawCentredString(0 * mm, 0 * mm, "Testsystem")

    canvas.save()
    return buffer