#!/usr/bin/env python3
"""Illustrative server-side adapter; beta documentation, not provider-tested."""
import argparse
from http.client import HTTPException
from datetime import datetime, timezone
import json
import os
from pathlib import Path
import sys
from urllib.request import Request, urlopen

ENDPOINT = 'https://api.density.io/v3/analytics/presence-health'
MAX_BYTES = 1_000_000


def decode_response(raw, space_ids):
    """Missing or uncertain measurements remain unknown, never vacant."""
    states = dict.fromkeys(space_ids, 'unknown')
    try:
        payload = json.loads(raw)
    except (ValueError, UnicodeError):
        return states
    data = payload.get('data') if isinstance(payload, dict) else None
    if not isinstance(data, dict):
        return states
    for space_id in space_ids:
        datum = data.get(space_id)
        if not isinstance(datum, dict):
            continue
        presence = datum.get('presence')
        if datum.get('space_health_status') == 'healthy' and type(presence) is bool:
            states[space_id] = 'occupied' if presence else 'vacant'
    return states


def fetch_states(space_ids, token, opener=urlopen, timeout=10):
    """One fixed-origin request; no retries, redirects, or upstream error output."""
    from urllib.request import HTTPRedirectHandler, build_opener

    class NoRedirect(HTTPRedirectHandler):
        def redirect_request(self, req, fp, code, msg, headers, newurl):
            return None

    if opener is urlopen:
        opener = build_opener(NoRedirect()).open
    request = Request(ENDPOINT, data=json.dumps({'space_ids': space_ids}).encode(),
                      headers={'Authorization': 'Bearer ' + token,
                               'Content-Type': 'application/json'}, method='POST')
    try:
        with opener(request, timeout=timeout) as response:
            if response.status != 200:
                return dict.fromkeys(space_ids, 'unknown'), False
            raw = response.read(MAX_BYTES + 1)
        if len(raw) > MAX_BYTES:
            return dict.fromkeys(space_ids, 'unknown'), False
        return decode_response(raw, space_ids), True
    except (OSError, ValueError, HTTPException):
        return dict.fromkeys(space_ids, 'unknown'), False


def main(argv=None):
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--space', action='append', required=True,
                        help='Explicit Density space ID; repeat for each configured space')
    mode = parser.add_mutually_exclusive_group(required=True)
    mode.add_argument('--fixture', type=Path, help='Read illustrative local JSON; no network')
    mode.add_argument('--live', action='store_true', help='Explicit provider call; token in server environment')
    args = parser.parse_args(argv)
    space_ids = list(dict.fromkeys(args.space))
    if any(not s.strip() for s in space_ids):
        parser.error('Use explicit nonempty space identifiers')
    if args.fixture:
        try:
            raw = args.fixture.read_bytes()
            states = decode_response(raw, space_ids) if len(raw) <= MAX_BYTES else dict.fromkeys(space_ids, 'unknown')
        except OSError:
            states = dict.fromkeys(space_ids, 'unknown')
        transport_ok = None
        mode_name = 'illustrative_fixture'
    else:
        token = os.environ.get('DENSITY_API_TOKEN', '')
        if not token.strip():
            parser.error('Set DENSITY_API_TOKEN in the server environment for --live')
        states, transport_ok = fetch_states(space_ids, token)
        mode_name = 'live_request'
    print(json.dumps({'mode': mode_name, 'processed_at': datetime.now(timezone.utc).isoformat(),
                      'transport_ok': transport_ok, 'states': states}))
    return 0


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