"""Field technician: one member of a share group that works through fault tickets.

Each ticket is handed to one technician at a time. The technician accepts it when done,
releases it for someone else if it can't handle it (--skip-codes), or rejects it as broken
(--reject-ids). Uses the confluent-kafka ShareConsumer, which is in preview in version 2.15.
From the code/ folder:

    python module-03/technician.py --name ana --topic m03l04-tickets --work-ms 300

Stop it with Ctrl+C.
"""
import argparse
import json
import signal
import sys
import time
from datetime import datetime
from pathlib import Path

sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
from confluent_kafka import AcknowledgeType, KafkaException, ShareConsumer  # noqa: E402
from common import settings  # noqa: E402


def now():
    return datetime.now().strftime("%H:%M:%S.%f")[:-3]


def main():
    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    ap.add_argument("--name", required=True)
    ap.add_argument("--topic", default="m03l04-tickets")
    ap.add_argument("--group", default="m03l04-technicians")
    ap.add_argument("--work-ms", type=float, default=300, help="time to fix one ticket (default 300)")
    ap.add_argument("--skip-codes", default="", help="error codes this technician can't fix, comma-separated")
    ap.add_argument("--reject-ids", default="", help="ticket ids to reject as broken, comma-separated")
    ap.add_argument("--max-records", type=int, default=1, help="tickets taken per poll (default 1)")
    ap.add_argument("--release-pause-ms", type=float, default=500,
                    help="pause after releasing a ticket before taking the next (default 500)")
    args = ap.parse_args()
    skip = {c for c in args.skip_codes.split(",") if c}
    reject = {t for t in args.reject_ids.split(",") if t}

    stop = False

    def on_signal(*_):
        nonlocal stop
        stop = True

    signal.signal(signal.SIGINT, on_signal)
    signal.signal(signal.SIGTERM, on_signal)

    consumer = ShareConsumer({"bootstrap.servers": settings.KAFKA_BOOTSTRAP, "group.id": args.group,
                              "client.id": args.name, "share.acknowledgement.mode": "explicit",
                              "max.poll.records": args.max_records})
    consumer.subscribe([args.topic])
    print(f"{now()} {args.name} joined share group {args.group} on {args.topic}", flush=True)

    done = 0
    while not stop:
        try:
            for msg in consumer.poll(1.0):
                if msg.error():
                    print(f"{now()} {args.name} ERROR {msg.error()}", flush=True)
                    continue
                ticket = json.loads(msg.value())
                tid, code, count = ticket["ticket_id"], ticket["error_code"], msg.delivery_count()
                print(f"{now()} {args.name} GOT {tid} {code} delivery={count} p{msg.partition()}", flush=True)
                if tid in reject:
                    consumer.acknowledge(msg, AcknowledgeType.REJECT)
                    print(f"{now()} {args.name} REJECTED {tid}", flush=True)
                elif code in skip:
                    consumer.acknowledge(msg, AcknowledgeType.RELEASE)
                    print(f"{now()} {args.name} RELEASED {tid}", flush=True)
                    consumer.commit_sync()                            # hand it back at once
                    time.sleep(args.release_pause_ms / 1000)          # walk back to the van
                else:
                    time.sleep(args.work_ms / 1000)                   # fixing the charger
                    consumer.acknowledge(msg, AcknowledgeType.ACCEPT)
                    done += 1
                    print(f"{now()} {args.name} DONE {tid}", flush=True)
            for tp, err in (consumer.commit_sync() or {}).items():      # send the acknowledgements
                if err:
                    print(f"{now()} {args.name} ACK FAILED p{tp.partition}: {err}", flush=True)
        except KafkaException as e:
            print(f"{now()} {args.name} ERROR {e}", flush=True)

    consumer.close()
    print(f"{now()} {args.name} stopped: fixed {done} tickets", flush=True)


if __name__ == "__main__":
    main()
