import zlib
from collections import defaultdict
from dataclasses import dataclass
from pathlib import Path

import pyarrow as pa
import pyarrow.compute as pc
import pyarrow.parquet as pq


def shard_of(value: str, n: int) -> int:
    return zlib.crc32(value.encode()) % n


def shard_name(config: str, s: int, n: int) -> str:
    return f"{config}-{s:05d}-of-{n:05d}.parquet"


def read_shard(directory: Path, config: str, s: int, n: int) -> pa.Table | None:
    path = Path(directory) / shard_name(config, s, n)
    return pq.read_table(path) if path.exists() else None


def write_shard(table: pa.Table, directory: Path, config: str, s: int, n: int) -> Path:
    directory = Path(directory)
    directory.mkdir(parents=True, exist_ok=True)
    path = directory / shard_name(config, s, n)
    pq.write_table(table, path, compression="zstd")
    return path


def read_index(raw_dir: Path, key_col: str, mod_col: str) -> dict[str, str]:
    out: dict[str, str] = {}
    for f in sorted(Path(raw_dir).glob("*.parquet")):
        t = pq.read_table(f, columns=[key_col, mod_col])
        out.update(zip(t.column(key_col).to_pylist(), t.column(mod_col).to_pylist()))
    return out


@dataclass
class Diff:
    fetch: list[str]
    removed: set[str]
    added: int
    changed: int
    unchanged: int


def diff(current: dict[str, str], previous: dict[str, str]) -> Diff:
    added = [k for k in current if k not in previous]
    changed = [k for k in current if k in previous and previous[k] != current[k]]
    return Diff(
        fetch=added + changed,
        removed=set(previous) - set(current),
        added=len(added),
        changed=len(changed),
        unchanged=len(current) - len(added) - len(changed),
    )


class Staging:
    """Buffers fetched rows to per-shard Parquet files so a shard is read back without scanning the rest."""

    def __init__(self, directory: Path, schema: pa.Schema, shard_col: str, n_shards: int, flush_rows: int = 100):
        self.dir = Path(directory)
        self.dir.mkdir(parents=True, exist_ok=True)
        self.schema = schema
        self.shard_col = shard_col
        self.n = n_shards
        self.flush_rows = flush_rows
        self.buffers: dict[int, list[dict]] = defaultdict(list)
        self.seq = 0

    def add(self, row: dict) -> None:
        s = shard_of(row[self.shard_col], self.n)
        self.buffers[s].append(row)
        if len(self.buffers[s]) >= self.flush_rows:
            self._flush_shard(s)

    def flush(self) -> None:
        for s in list(self.buffers):
            self._flush_shard(s)

    def _flush_shard(self, s: int) -> None:
        rows = self.buffers.pop(s, [])
        if not rows:
            return
        self.seq += 1
        pq.write_table(pa.Table.from_pylist(rows, schema=self.schema), self.dir / f"{s:05d}-{self.seq:07d}.parquet")

    def read_shard(self, s: int) -> pa.Table:
        files = sorted(self.dir.glob(f"{s:05d}-*.parquet"))
        if not files:
            return self.schema.empty_table()
        return pa.concat_tables(pq.read_table(f).cast(self.schema) for f in files)


def merge_shard(
    previous: pa.Table | None, fetched: pa.Table, removed: set[str], key_col: str, schema: pa.Schema
) -> pa.Table:
    parts = []
    if previous is not None and previous.num_rows:
        drop = pa.array(sorted(set(removed) | set(fetched.column(key_col).to_pylist())), pa.string())
        keep = pc.invert(pc.is_in(previous.column(key_col), value_set=drop))
        parts.append(previous.filter(keep).select(schema.names).cast(schema))
    parts.append(fetched.select(schema.names).cast(schema))
    return pa.concat_tables(parts).sort_by(key_col)