"""Bounded gzip members in bounded stream-segment Pages assets and a hierarchical index.

This module performs no acquisition, publication-pointer update or deployment.
Every page/index is independently compressed and SHA-pinned. Bundles are padded
to a known 2 MiB, allowing immutable byte references before a bundle closes.
"""
import gzip
import hashlib
from pathlib import Path

import build_public_name_directory as base

SCHEMA = "ndr-public-directory/3"
SEGMENT_BYTES = 2 * 1024 * 1024
MEMBER_BYTES = 256 * 1024
RECORD_BYTES = 192 * 1024
TARGET_PAGE_BYTES = 128 * 1024
PAGE_ROWS = 128
INDEX_FANOUT = 128
MAX_DEPTH = 4


class Segments:
    def __init__(self, target, release, segment_bytes=SEGMENT_BYTES, start_number=0):
        base.require(0 < segment_bytes <= SEGMENT_BYTES and 0 <= start_number < 1000000, "Invalid bounded segment layout")
        self.target = Path(target)
        self.release = release
        self.cap = segment_bytes
        self.number = start_number - 1
        self.stream = None
        self.offset = 0
        self.members = 0
        self.payload_bytes = 0
        self.files = []

    def _close(self):
        if self.stream is None:
            return
        if self.offset < self.cap:
            self.stream.seek(self.cap - 1)
            self.stream.write(b"\0")
        self.stream.close()
        path = self.target / f"segments/{self.number:06d}.bin"
        self.files.append({"path": str(path), "bytes": self.cap, "sha256": base.sha(path)})
        self.stream = None

    def add(self, value):
        raw = base.encoded(value)
        base.require(0 < len(raw) <= MEMBER_BYTES, "Inflated member exceeds the bounded reader")
        packed = gzip.compress(raw, compresslevel=6, mtime=0)
        base.require(0 < len(packed) <= MEMBER_BYTES, "Stored member exceeds the bounded reader")
        base.require(len(packed) <= self.cap, "Member exceeds its segment size")
        if self.stream is None or self.offset + len(packed) > self.cap:
            self._close()
            self.number += 1
            path = self.target / f"segments/{self.number:06d}.bin"
            path.parent.mkdir(parents=True, exist_ok=True)
            self.stream = path.open("wb")
            self.offset = 0
        ref = {"path": f"/assets/public-name-data/{self.release}/segments/{self.number:06d}.bin",
               "segment_bytes": self.cap, "offset": self.offset, "bytes": len(packed),
               "sha256": hashlib.sha256(packed).hexdigest(), "inflated_bytes": len(raw)}
        self.stream.write(packed)
        self.offset += len(packed)
        self.members += 1
        self.payload_bytes += len(packed)
        return ref

    def close(self):
        self._close()


class View:
    def __init__(self, segments, role, target_page_bytes=TARGET_PAGE_BYTES, page_rows=None, page_kind="heads"):
        self.segments = segments
        self.role = role
        self.target_page_bytes = target_page_bytes
        self.page_rows = page_rows
        self.page_kind = page_kind
        self.page = []
        self.page_overhead = len(base.encoded({"schema": SCHEMA, "release": segments.release, "kind": page_kind, "records": []}))
        self.page_bytes = self.page_overhead
        self.pages = []
        self.levels = {}
        self.count = 0
        self.page_count = 0
        self.index_count = 0
        self.previous = None
        self.largest_record = 0

    def _node(self, kind, entries):
        base.require(0 < len(entries) <= INDEX_FANOUT, "Index fanout exceeded")
        value = {"schema": SCHEMA, "release": self.segments.release, "role": self.role,
                 "kind": kind, "entries": entries}
        base.require(len(base.encoded(value)) <= 128 * 1024, "Index node exceeds bounded query size")
        ref = self.segments.add(value)
        self.index_count += 1
        return {**ref, "first": entries[0]["first"], "last": entries[-1]["last"],
                "count": sum(item["count"] for item in entries)}

    def _push(self, ref, height):
        base.require(height <= MAX_DEPTH, "Packed index depth exceeds the request budget")
        level = self.levels.setdefault(height, [])
        level.append(ref)
        if len(level) == INDEX_FANOUT:
            parent = self._node("branches", level)
            self.levels[height] = []
            self._push(parent, height + 1)

    def _page(self):
        if not self.page:
            return
        ref = self.segments.add({"schema": SCHEMA, "release": self.segments.release, "kind": self.page_kind, "records": self.page})
        self.pages.append({**ref, "first": self.page[0]["key"], "last": self.page[-1]["key"], "count": len(self.page)})
        self.page_count += 1
        self.page = []
        self.page_bytes = self.page_overhead
        if len(self.pages) == INDEX_FANOUT:
            self._push(self._node("pages", self.pages), 1)
            self.pages = []

    def add(self, row):
        key = row["key"]
        base.require(self.previous is None or self.previous < key, "View keys are not strictly sorted")
        self.previous = key
        size = len(base.encoded(row)) - 1
        base.require(size <= RECORD_BYTES, "A record must be split into bounded public detail assets before publication")
        base.require(size + self.page_overhead <= self.target_page_bytes, "Compact head requires a bounded summary projection before publication")
        self.largest_record = max(self.largest_record, size)
        if self.page and (len(self.page) >= (self.page_rows or PAGE_ROWS) or self.page_bytes + size + 1 > self.target_page_bytes):
            self._page()
        self.page.append(row)
        self.page_bytes += size + 1
        self.count += 1

    def finish(self):
        self._page()
        if self.pages:
            self._push(self._node("pages", self.pages), 1)
            self.pages = []
        if not self.count:
            return {"count": 0, "root": None, "depth": 0}
        height = 1
        while True:
            level = self.levels.get(height, [])
            higher = any(entries for h, entries in self.levels.items() if h > height)
            if level and len(level) == 1 and not higher:
                return {"count": self.count, "root": level[0], "depth": height,
                        "data_pages": self.page_count, "index_nodes": self.index_count}
            if level:
                parent = self._node("branches", level)
                self.levels[height] = []
                self._push(parent, height + 1)
            height += 1
            base.require(height <= MAX_DEPTH, "Packed index depth exceeds its bound")
