from __future__ import annotations

import io

import re

from app.services.normalize import RawRead

from app.services.parsers.base import BaseParser, ParseResult

class PdfReportParser(BaseParser):

    """Extracts ALPR reads from PDF reports. Many ALPR/Flock report exports are tabular text;

    pdfminer.six gives us the text layer, from which we pull rows containing a plate-like token

    and a timestamp. A camera token and coordinates are captured when present on the same line.

    Defensive by design: a missing dependency or a malformed PDF returns errors, never raises -

    so one bad upload can't take down ingest."""

    name = "pdf_report"

    _PLATE = re.compile(r"\b([A-Z0-9]{5,8})\b")

    _TS = re.compile(r"(\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}(?::\d{2})?(?:Z|[+-]\d{2}:?\d{2})?)")

    _CAM = re.compile(r"\b(CAM[-_][A-Z0-9-]+|[A-Z]{2,}-\d{2,})\b")

    _LATLON = re.compile(r"(-?\d{1,3}\.\d{3,}),\s*(-?\d{1,3}\.\d{3,})")

    _STOP = {"REPORT", "CAMERA", "PLATE", "VEHICLE", "SYSTEM", "EXPORT", "RESULTS", "DETAIL"}

    def parse(self, data: bytes) -> ParseResult:

        try:

            from pdfminer.high_level import extract_text

        except Exception:

            return ParseResult(headers=[], rows=[],

                               errors=["pdf parsing requires 'pdfminer.six'"])

        try:

            text = extract_text(io.BytesIO(data))

        except Exception as e:

            return ParseResult(headers=[], rows=[], errors=[f"pdf extract failed: {e}"])

        rows: list[RawRead] = []

        errors: list[str] = []

        for i, line in enumerate(text.splitlines(), start=1):

            up = line.upper()

            ts = self._TS.search(line)

            if not ts:

                continue

            without_ts = up.replace(ts.group(1).upper(), " ")

            cam = self._CAM.search(up)

            plate = None

            for cand in self._PLATE.finditer(without_ts):

                tok = cand.group(1)

                if tok in self._STOP or (cam and tok == cam.group(1)):

                    continue

                if tok.isdigit():

                    continue

                plate = tok

                break

            if not plate:

                continue

            fields = {"plate": plate, "timestamp": ts.group(1),

                      "camera": cam.group(1) if cam else "pdf-report"}

            ll = self._LATLON.search(line)

            if ll:

                fields["latitude"], fields["longitude"] = ll.group(1), ll.group(2)

            rows.append(RawRead(fields=fields, source_row=i))

        if not rows:

            errors.append("no plate+timestamp rows found in PDF text layer")

        return ParseResult(headers=["plate", "timestamp", "camera", "latitude", "longitude"],

                           rows=rows, errors=errors)