"""Deterministic additional domain inputs, generated without model/reference output."""

import csv
import datetime as dt
import io
import random


def generated_inputs(family, count=24, seed=1729):
    r = random.Random(f"{seed}/{family}/domain")

    def nums():
        return [r.randrange(-9, 10) for _ in range(r.randrange(12))]

    def words():
        return [
            r.choice(["a", "b", "c", "", "é", "a/b"]) for _ in range(r.randrange(12))
        ]

    def text(chars="abAB09_ -é\n"):
        return "".join(r.choices(chars, k=r.randrange(60)))

    def intervals():
        return [
            sorted([r.randrange(-10, 11), r.randrange(-10, 11)])
            for _ in range(r.randrange(10))
        ]

    for _ in range(count):
        if family in {"word_frequency", "run_length"}:
            x = {"text": text()}
        elif family == "bracket_audit":
            x = {"text": text("()[]{}abcé ")}
        elif family == "slug_registry":
            x = {"titles": [text("aAB -_/é") for _ in range(r.randrange(12))]}
        elif family == "text_wrap":
            x = {"text": text(), "width": r.randrange(1, 20)}
        elif family == "ngram_index":
            x = {"tokens": words(), "n": r.randrange(1, 5)}
        elif family == "glob_filter":
            x = {
                "paths": words(),
                "pattern": r.choice(["*", "?", "[abc]*", "*/*", "[!a]*", "é"]),
            }
        elif family == "edit_distance":
            x = {"a": text(), "b": text()}
        elif family == "roman_codec":
            x = {"number": r.randrange(1, 4000)}
        elif family == "caesar_cipher":
            x = {"text": text(), "shift": r.randrange(-1000, 1001)}
        elif family == "csv_records":
            stream = io.StringIO()
            writer = csv.writer(stream)
            writer.writerow(["a", "b"])
            writer.writerows(
                [[text('a,b"\né '), text()] for _ in range(r.randrange(8))]
            )
            x = {"csv": stream.getvalue()}
        elif family in {"record_query", "dedupe_records"}:
            rows = [
                {k: r.choice([None, 1, 2, "x"]) for k in ("a", "b") if r.random() < 0.8}
                for _ in range(r.randrange(15))
            ]
            x = (
                {
                    "rows": rows,
                    "where": {"a": r.choice([None, 1, 2])},
                    "select": ["b", "c"],
                }
                if family == "record_query"
                else {"rows": rows, "keys": r.choice([[], ["a"], ["a", "b"]])}
            )
        elif family == "inner_join":
            x = {
                "left": [{"k": r.randrange(4)} for _ in range(r.randrange(8))],
                "right": [{"k": r.randrange(4)} for _ in range(r.randrange(8))],
                "key": "k",
            }
        elif family == "group_totals":
            x = {
                "rows": [
                    {"g": r.choice(["a", "b", ""]), "v": r.randrange(-20, 21)}
                    for _ in range(r.randrange(16))
                ],
                "group": "g",
                "value": "v",
            }
        elif family == "pivot_table":
            x = {
                "rows": [
                    {
                        "r": r.choice(["a", "b", ""]),
                        "c": r.choice(["x", "y"]),
                        "v": r.randrange(-9, 10),
                    }
                    for _ in range(r.randrange(16))
                ],
                "row": "r",
                "column": "c",
                "value": "v",
            }
        elif family in {"json_flatten", "merge_patch", "json_pointer"}:
            value = {
                "a/b": [nums(), {}, None],
                "~": {"": r.randrange(9)},
                "x": r.choice([True, None, "é"]),
            }
            if family == "json_flatten":
                x = {"value": value}
            elif family == "merge_patch":
                x = {
                    "target": value,
                    "patch": {
                        "a/b": r.choice([None, [1], {"z": 2}]),
                        "x": {"v": r.randrange(9)},
                    },
                }
            else:
                x = {
                    "value": value,
                    "pointer": r.choice(
                        ["", "/a~1b/0", "/a~1b/99", "/~0/", "/x/no", "/absent"]
                    ),
                }
        elif family == "schema_check":
            x = {
                "schema": {
                    k: {
                        "type": r.choice(
                            [
                                "integer",
                                "number",
                                "boolean",
                                "string",
                                "array",
                                "object",
                                "null",
                            ]
                        ),
                        "required": r.choice([True, False]),
                    }
                    for k in ("a", "b", "c")
                },
                "value": {
                    k: r.choice([True, 1, 1.5, "x", [], {}, None])
                    for k in ("a", "b")
                    if r.random() < 0.8
                },
            }
        elif family in {
            "interval_union",
            "interval_gaps",
            "booking_peak",
            "uptime_report",
        }:
            pairs = intervals()
            if family == "booking_peak":
                x = {"bookings": pairs}
            elif family == "uptime_report":
                x = {"start": -5, "end": 5, "downtime": pairs}
            else:
                x = {"intervals": pairs}
                if family == "interval_gaps":
                    x["bounds"] = [-5, 5]
        elif family == "business_days":
            start = dt.date(2000, 1, 1) + dt.timedelta(days=r.randrange(9000))
            x = {
                "start": start.isoformat(),
                "end": (start + dt.timedelta(days=r.randrange(30))).isoformat(),
                "holidays": [
                    (start + dt.timedelta(days=r.randrange(30))).isoformat()
                    for _ in range(5)
                ],
            }
        elif family == "calendar_month":
            x = {"year": r.randrange(1900, 2101), "month": r.randrange(1, 13)}
        elif family == "moving_average":
            x = {"values": nums(), "window": r.randrange(1, 8)}
        elif family == "statistics":
            x = {"values": nums()}
        elif family == "histogram":
            x = {"values": nums(), "edges": sorted(r.sample(range(-10, 11), 5))}
        elif family == "matrix_product":
            m, n, p = [r.randrange(1, 5) for _ in range(3)]
            x = {
                "a": [[r.randrange(-4, 5) for _ in range(n)] for _ in range(m)],
                "b": [[r.randrange(-4, 5) for _ in range(p)] for _ in range(n)],
            }
        elif family == "polynomial":
            x = {"coefficients": nums(), "points": nums()}
        elif family == "prime_factors":
            x = {"number": r.randrange(1, 100001)}
        elif family == "base_convert":
            x = {
                "digits": str(r.randrange(-(2**70), 2**70)),
                "from_base": 10,
                "to_base": r.randrange(2, 37),
            }
        elif family == "money_split":
            x = {
                "amount": r.randrange(10000),
                "weights": [r.randrange(1, 20)]
                + [r.randrange(20) for _ in range(r.randrange(8))],
            }
        elif family == "invoice_total":
            x = {
                "items": [
                    {
                        "price": f"{r.randrange(100)}.{r.randrange(1000):03d}",
                        "quantity": r.randrange(10),
                    }
                    for _ in range(r.randrange(8))
                ],
                "tax_rate": r.choice(["0", "0.075", "0.20"]),
            }
        elif family == "coin_change":
            x = {
                "coins": [r.randrange(1, 15) for _ in range(r.randrange(8))],
                "amount": r.randrange(100),
            }
        elif family in {
            "graph_reach",
            "shortest_path",
            "topological_order",
            "connected_components",
        }:
            nodes = list("abcdef")[: r.randrange(1, 7)]
            edges = [[r.choice(nodes), r.choice(nodes)] for _ in range(r.randrange(15))]
            if family == "shortest_path":
                edges = [edge + [r.randrange(10)] for edge in edges]
            x = {"nodes": nodes, "edges": edges}
            if family in {"graph_reach", "shortest_path"}:
                x["start"] = r.choice(nodes)
        elif family == "grid_route":
            grid = ["".join(r.choices(".#", weights=[4, 1], k=5)) for _ in range(5)]
            x = {
                "grid": grid,
                "start": [r.randrange(5), r.randrange(5)],
                "end": [r.randrange(5), r.randrange(5)],
            }
        elif family == "tree_outline":
            nodes = []
            for key in list("abcdefgh")[: r.randrange(9)]:
                nodes.append(
                    {"id": key, "parent": r.choice([None] + [n["id"] for n in nodes])}
                )
            r.shuffle(nodes)
            x = {"nodes": nodes}
        elif family == "dependency_build":
            nodes = list("abcde")[: r.randrange(1, 6)]
            x = {
                "dependencies": {
                    n: r.sample(nodes, r.randrange(len(nodes) + 1)) for n in nodes
                },
                "targets": r.sample(nodes, r.randrange(len(nodes) + 1)),
            }
        elif family == "path_normalize":
            x = {
                "paths": [
                    "/".join(
                        r.choices(["a", "b", "..", ".", "", "é"], k=r.randrange(10))
                    )
                    for _ in range(r.randrange(12))
                ]
            }
        elif family == "url_query":
            x = {
                "query": "&".join(
                    r.choices(
                        ["a=1", "a=2", "x=a+b", "x=%2B", "flag", "", "=v", "q=%C3%A9"],
                        k=r.randrange(12),
                    )
                )
            }
        elif family == "version_sort":
            x = {
                "versions": [
                    f"{r.randrange(3)}.{r.randrange(12)}.{r.randrange(5)}"
                    + r.choice(["", "-a", "-a.2", "-a.10", "-1", "-b"])
                    for _ in range(r.randrange(15))
                ]
            }
        elif family == "lru_trace":
            x = {"capacity": r.randrange(6), "accesses": words()}
        elif family == "rate_limit":
            x = {
                "events": [
                    {"time": t, "key": r.choice(["a", "b"])}
                    for t in sorted(r.choices(range(12), k=r.randrange(20)))
                ],
                "window": r.randrange(1, 8),
                "limit": r.randrange(5),
            }
        elif family == "priority_queue":
            x = {
                "events": [
                    {"op": "pop"}
                    if r.random() < 0.4
                    else {
                        "op": "push",
                        "priority": r.randrange(-2, 3),
                        "value": r.choice([None, "x", {"a": 1}, []]),
                    }
                    for _ in range(r.randrange(20))
                ]
            }
        elif family == "round_robin":
            x = {
                "jobs": [
                    {"id": str(i), "duration": r.randrange(1, 12)}
                    for i in range(r.randrange(6))
                ],
                "quantum": r.randrange(1, 6),
            }
        elif family == "inventory_ledger":
            x = {
                "events": [
                    {"sku": r.choice(["a", "b", "c"]), "delta": r.randrange(-5, 6)}
                    for _ in range(r.randrange(20))
                ]
            }
        elif family == "bank_ledger":
            x = {
                "balances": {"a": r.randrange(20), "b": r.randrange(20)},
                "transfers": [
                    {
                        "from": r.choice(["a", "b", "missing"]),
                        "to": r.choice(["a", "b", "missing"]),
                        "amount": r.randrange(1, 12),
                    }
                    for _ in range(r.randrange(12))
                ],
            }
        elif family == "ballot_count":
            x = {
                "candidates": ["a", "b", "c"],
                "votes": r.choices(["a", "b", "c", "bad"], k=r.randrange(30)),
            }
        elif family == "search_rank":
            x = {
                "documents": [
                    {"id": str(i), "text": text()} for i in range(r.randrange(8))
                ],
                "query": text(),
            }
        elif family == "log_summary":
            x = {
                "events": [
                    {
                        "level": r.choice(["ERROR", "INFO", "WARN", "error"]),
                        "message": text(),
                    }
                    for _ in range(r.randrange(12))
                ]
            }
        elif family == "segment_intersection":
            x = {k: [r.randrange(-4, 5), r.randrange(-4, 5)] for k in "abcd"}
        elif family == "polygon_area":
            a, b, c, d = [r.randrange(1, 10) for _ in range(4)]
            x = {"points": [[-a, -b], [c, -b], [c, d], [-a, d]]}
            if r.random() < 0.5:
                x["points"].reverse()
        elif family == "skyline":
            x = {
                "buildings": [
                    [a, a + r.randrange(1, 8), r.randrange(1, 10)]
                    for a in [r.randrange(-5, 6) for _ in range(r.randrange(12))]
                ]
            }
        elif family == "knapsack":
            x = {
                "items": [
                    {"weight": r.randrange(1, 10), "value": r.randrange(20)}
                    for _ in range(r.randrange(10))
                ],
                "capacity": r.randrange(25),
            }
        elif family == "task_selection":
            x = {
                "tasks": [
                    {"id": str(i), "start": a, "end": a + r.randrange(1, 8)}
                    for i, a in enumerate(
                        [r.randrange(-5, 8) for _ in range(r.randrange(12))]
                    )
                ]
            }
        elif family == "sequence_diff":
            x = {"a": words(), "b": words()}
        elif family == "finite_automaton":
            x = {
                "start": "a",
                "accepting": r.sample(["a", "b"], r.randrange(3)),
                "transitions": [
                    {"from": a, "symbol": c, "to": r.choice(["a", "b"])}
                    for a in ["a", "b"]
                    for c in "xy"
                    if r.random() < 0.8
                ],
                "words": [
                    "".join(r.choices("xy", k=r.randrange(10)))
                    for _ in range(r.randrange(12))
                ],
            }
        elif family == "content_manifest":
            x = {"files": {str(i) + "/é": text() for i in range(r.randrange(8))}}
        elif family == "cellular_automaton":
            x = {
                "live": [
                    [r.randrange(-3, 4), r.randrange(-3, 4)]
                    for _ in range(r.randrange(20))
                ],
                "steps": r.randrange(5),
            }
        elif family == "expression_eval":
            x = {
                "tokens": [
                    str(r.randrange(-100, 101)),
                    str(r.randrange(-100, 101)),
                    r.choice(["+", "-", "*"]),
                    str(r.randrange(1, 10)),
                    "/",
                ]
            }
        else:
            raise ValueError(f"No generator for {family}")
        yield x