"""Lossless evidence fragments and compact, source-labelled lookup heads."""
import json
from collections import OrderedDict

import build_public_name_directory as base
from public_name_segment_layout import SCHEMA

HEAD_BYTES = 32 * 1024
EVIDENCE_BYTES = 64 * 1024


def evidence_parts(row):
    retained = {key: value for key, value in row.items() if key != "attestations"}
    observations = row.get("attestations", [])
    groups = []
    group = []
    # Conservative six-digit part counters avoid late size changes.
    def fits(items):
        value = {"record": {**retained, "attestations": items}, "part": 999999, "parts": 999999,
                 "had_attestations": "attestations" in row}
        return len(base.encoded(value)) <= 60 * 1024
    base.require(fits([]), "Non-attestation record fields require further lossless pagination")
    for item in observations:
        if group and not fits(group + [item]):
            groups.append(group)
            group = []
        base.require(fits([item]), "One source assertion requires further lossless pagination")
        group.append(item)
    if group or not observations:
        groups.append(group)
    return [{"record": {**retained, "attestations": group}, "part": number, "parts": len(groups),
             "had_attestations": "attestations" in row} for number, group in enumerate(groups)]


def head(row, parts_count=None):
    fields = ("key", "name", "forms", "roles", "source_id", "source_category", "evidence_status",
              "corroborated_roles", "role_warnings", "language", "written_script", "source_role_difference")
    result = {key: row[key] for key in fields}
    result["training_source_roles"] = sorted({x["role"] for x in row["primary_locators"]})
    grouped = OrderedDict()
    for item in row.get("attestations", []):
        key = (item["source_id"], item["role"], item.get("language"), item.get("language_name"))
        value = {field: item[field] for field in ("source_id", "tier", "role", "language")}
        for field in ("language_name", "evidence_kind"):
            if field in item:
                value[field] = item[field]
        grouped[key] = value
    result["evidence_summary"] = list(grouped.values())
    result["evidence_parts"] = len(evidence_parts(row)) if parts_count is None else parts_count
    return result


class EvidencePages:
    def __init__(self, segments, db):
        self.segments = segments
        self.db = db
        self.fragments = []
        self.size = len(base.encoded(self.value([])))
        self.pages = 0
        self.largest_inflated = 0
        self.db.execute("CREATE TABLE IF NOT EXISTS evidence_links(key TEXT,part INTEGER,ref TEXT,PRIMARY KEY(key,part)) WITHOUT ROWID")

    def value(self, fragments):
        return {"schema": SCHEMA, "release": self.segments.release, "kind": "evidence", "fragments": fragments}

    def flush(self):
        if not self.fragments:
            return
        value = self.value(self.fragments)
        raw_size = len(base.encoded(value))
        base.require(raw_size <= EVIDENCE_BYTES, "Evidence page exceeds its read bound")
        self.largest_inflated = max(self.largest_inflated, raw_size)
        ref = self.segments.add(value)
        encoded = base.encoded(ref).decode("utf-8")
        for fragment in self.fragments:
            self.db.execute("INSERT INTO evidence_links VALUES(?,?,?)", (fragment["record"]["key"], fragment["part"], encoded))
        self.fragments = []
        self.size = len(base.encoded(self.value([])))
        self.pages += 1

    def add(self, row):
        parts = evidence_parts(row)
        for fragment in parts:
            size = len(base.encoded(fragment))
            if self.fragments and (len(self.fragments) >= 50 or self.size + size + 1 > EVIDENCE_BYTES):
                self.flush()
            self.fragments.append(fragment)
            self.size += size + 1
        return len(parts)


def attach_evidence(head_row, db):
    refs = OrderedDict()
    for (encoded,) in db.execute("SELECT ref FROM evidence_links WHERE key=? ORDER BY part", (head_row["key"],)):
        ref = json.loads(encoded)
        refs[(ref["path"], ref["offset"])] = ref
    base.require(refs, "Head lacks recoverable source evidence")
    head_row["evidence_refs"] = list(refs.values())
    base.require(len(base.encoded(head_row)) + 128 <= HEAD_BYTES, "Head needs further bounded summary pagination before publication")
    return head_row


def recover(parts):
    parts = sorted(parts, key=lambda x: x["part"])
    base.require(parts and len(parts) == parts[0]["parts"] and [p["part"] for p in parts] == list(range(len(parts))), "Incomplete source evidence")
    row = dict(parts[0]["record"])
    retained = {k: v for k, v in row.items() if k != "attestations"}
    base.require(all(p["parts"] == len(parts) and p["had_attestations"] == parts[0]["had_attestations"] and
                 {k: v for k, v in p["record"].items() if k != "attestations"} == retained for p in parts), "Mixed evidence fragments")
    row["attestations"] = [item for part in parts for item in part["record"]["attestations"]]
    if not parts[0]["had_attestations"]:
        row.pop("attestations")
    return row
