#!/usr/bin/env python3
"""Qualification prototype: read-only product CSV checks; no marketplace rules."""
import argparse
import csv
import json
import sys
from pathlib import Path

MAX_BYTES = 10 * 1024 * 1024
MAX_ROWS = 100000


def check(path, required, key, delimiter):
    if not required or any(not name.strip() for name in required) or len(set(required)) != len(required):
        raise ValueError("required columns must be nonempty and unique")
    if key and key not in required:
        raise ValueError("key must be one of the required columns")
    if len(delimiter) != 1 or delimiter in '\r\n\x00"':
        raise ValueError("unsupported delimiter")
    if path.stat().st_size > MAX_BYTES:
        raise ValueError("file exceeds 10 MiB")
    signals = []
    seen = {}
    count = 0
    with path.open(encoding="utf-8-sig", newline="") as stream:
        reader = csv.reader(stream, delimiter=delimiter, strict=True)
        headers = next(reader, None)
        if not headers:
            raise ValueError("CSV has no header")
        if any(not name.strip() for name in headers):
            raise ValueError("blank header")
        if len(set(headers)) != len(headers):
            raise ValueError("duplicate header")
        missing = [name for name in required if name not in headers]
        if missing:
            return {"status": "signals", "rows_checked": 0,
                    "signals": [{"kind": "missing_columns", "columns": missing}],
                    "scope": "configured_columns_only"}
        indexes = {name: headers.index(name) for name in required}
        for row_number, row in enumerate(reader, 2):
            count += 1
            if count > MAX_ROWS:
                raise ValueError("CSV exceeds 100000 data records")
            if len(row) != len(headers):
                signals.append({"kind": "row_width", "record": row_number,
                                "expected": len(headers), "actual": len(row)})
                continue
            for name, index in indexes.items():
                if not row[index].strip():
                    signals.append({"kind": "empty_required", "record": row_number, "column": name})
            if key:
                value = row[indexes[key]].strip()
                if value:
                    if value in seen:
                        signals.append({"kind": "duplicate_key", "record": row_number,
                                        "first_record": seen[value], "column": key})
                    else:
                        seen[value] = row_number
    if count == 0:
        signals.append({"kind": "no_products"})
    return {"status": "signals" if signals else "no_signals", "rows_checked": count,
            "signals": signals, "scope": "configured_columns_only"}


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("input", type=Path)
    parser.add_argument("--required", nargs="+", required=True)
    parser.add_argument("--key")
    parser.add_argument("--delimiter", default=",")
    args = parser.parse_args()
    try:
        result = check(args.input, args.required, args.key, args.delimiter)
    except (OSError, UnicodeError, csv.Error, ValueError) as error:
        print(json.dumps({"status": "input_error", "error": str(error)}, ensure_ascii=False))
        return 2
    print(json.dumps(result, ensure_ascii=False))
    return 1 if result["signals"] else 0


if __name__ == "__main__":
    sys.exit(main())