"""Offline UTC+08:00 day-filter fixture, not a universal timezone parser."""

import argparse
import csv
import json
import re
from datetime import date, datetime, time, timedelta, timezone
from pathlib import Path


DAY = re.compile(r"[0-9]{4}-[0-9]{2}-[0-9]{2}")
STAMP = re.compile(
    r"[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}"
    r"(?:\.[0-9]{1,6})?(?:Z|[+-][0-9]{2}:[0-9]{2})"
)
BUSINESS_TZ = timezone(timedelta(hours=8))


def parse_timestamp(value):
    if not isinstance(value, str) or STAMP.fullmatch(value) is None:
        raise ValueError("explicit_offset_timestamp_required")
    if value.endswith("-00:00"):
        raise ValueError("unknown_local_offset_not_supported")
    offset = value[-6:]
    if offset[0:1] in {"+", "-"}:
        if int(offset[1:3]) > 23 or int(offset[4:6]) > 59:
            raise ValueError("invalid_utc_offset")
    parsed = datetime.fromisoformat(value[:-1] + "+00:00" if value.endswith("Z") else value)
    if parsed.utcoffset() is None:
        raise ValueError("explicit_offset_timestamp_required")
    return parsed


def day_bounds(value):
    if not isinstance(value, str) or DAY.fullmatch(value) is None:
        raise ValueError("day_requires_yyyy_mm_dd")
    selected = date.fromisoformat(value)
    start = datetime.combine(selected, time.min, BUSINESS_TZ)
    end = datetime.combine(selected + timedelta(days=1), time.min, BUSINESS_TZ)
    return start, end


def belongs_to_day(timestamp, day):
    start, end = day_bounds(day)
    converted = parse_timestamp(timestamp).astimezone(BUSINESS_TZ)
    return start <= converted < end


def select_rows(source, day):
    start, end = day_bounds(day)
    reader = csv.DictReader(source, strict=True)
    if tuple(reader.fieldnames or ()) != ("event_id", "occurred_at"):
        raise ValueError("unexpected_csv_header")
    included, excluded, seen = [], [], set()
    for row in reader:
        if None in row or row["event_id"] is None or row["occurred_at"] is None:
            raise ValueError("wrong_csv_field_count")
        event_id = row["event_id"]
        if re.fullmatch(r"E[0-9]{2}", event_id) is None or event_id in seen:
            raise ValueError("invalid_or_duplicate_event_id")
        seen.add(event_id)
        if len(seen) > 10000:
            raise ValueError("example_row_limit_exceeded")
        converted = parse_timestamp(row["occurred_at"]).astimezone(BUSINESS_TZ)
        (included if start <= converted < end else excluded).append(event_id)
    if not seen:
        raise ValueError("empty_table")
    return {
        "timezone": "UTC+08:00 (fixed offset)",
        "start_inclusive": start.isoformat(),
        "end_exclusive": end.isoformat(),
        "input_rows": len(seen),
        "included_ids": included,
        "excluded_ids": excluded,
    }


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("csv_file", type=Path)
    parser.add_argument("day")
    args = parser.parse_args()
    try:
        with args.csv_file.open(encoding="utf-8-sig", newline="") as source:
            result = select_rows(source, args.day)
    except (ValueError, OverflowError, csv.Error, OSError, UnicodeError) as error:
        print(json.dumps({"valid": False, "error": str(error)}))
        return 2
    print(json.dumps({"valid": True, **result}, indent=2))
    return 0


if __name__ == "__main__":
    raise SystemExit(main())