"""GR-01 Python SDK 1.0.0. Importing this module makes no network calls."""
import json
import ssl
import urllib.error
import urllib.parse
import urllib.request

__version__ = "1.0.0"


class GR01Error(Exception):
    def __init__(self, message, status=None):
        super().__init__(message)
        self.status = status


class _NoRedirect(urllib.request.HTTPRedirectHandler):
    def redirect_request(self, req, fp, code, msg, headers, newurl):
        return None


class GR01Client:
    def __init__(self, base_url, token, ca_file=None, timeout=10):
        parsed = urllib.parse.urlsplit(base_url)
        if (parsed.scheme != "https" or not parsed.hostname or parsed.username
                or parsed.password or parsed.query or parsed.fragment
                or parsed.path not in ("", "/")):
            raise ValueError("base_url must be an HTTPS origin")
        if not token or any(c in token for c in "\r\n"):
            raise ValueError("a project token is required")
        if timeout <= 0:
            raise ValueError("timeout must be positive")
        self.base_url = base_url.rstrip("/")
        self.token = token
        self.timeout = timeout
        context = ssl.create_default_context(cafile=ca_file)
        self.opener = urllib.request.build_opener(
            _NoRedirect(), urllib.request.HTTPSHandler(context=context))

    def _get(self, path, params=None):
        url = self.base_url + path
        if params:
            url += "?" + urllib.parse.urlencode(params)
        req = urllib.request.Request(url, headers={
            "Accept": "application/json", "X-NEURALAN-Token": self.token})
        try:
            with self.opener.open(req, timeout=self.timeout) as response:
                if response.status != 200:
                    raise GR01Error("unexpected HTTP status", response.status)
                if response.headers.get_content_type() != "application/json":
                    raise GR01Error("expected application/json")
                data = response.read(1048577)
                if len(data) > 1048576:
                    raise GR01Error("response exceeds 1 MiB")
                return json.loads(data.decode("utf-8"))
        except urllib.error.HTTPError as exc:
            # Do not expose request headers, tokens, or untrusted response text.
            raise GR01Error("HTTP request failed", exc.code) from None
        except (urllib.error.URLError, TimeoutError, OSError) as exc:
            raise GR01Error("HTTPS connection failed") from None
        except (ValueError, UnicodeError):
            raise GR01Error("invalid JSON response") from None

    def capabilities(self):
        return self._get("/api/v1/capabilities")

    def events(self, stream_id, after=0, limit=100):
        if not stream_id or type(after) is not int or not 0 <= after <= 0xffffffff:
            raise ValueError("stream_id and uint32 after are required")
        if type(limit) is not int or not 1 <= limit <= 100:
            raise ValueError("limit must be 1..100")
        return self._get("/api/v1/events", {
            "streamId": stream_id, "after": after, "limit": limit})

    def event(self, stream_id, event_index):
        if not stream_id or type(event_index) is not int or not 1 <= event_index <= 0xffffffff:
            raise ValueError("stream_id and event index 1..4294967295 required")
        return self._get("/api/v1/events/" + str(event_index), {"streamId": stream_id})

    def report(self, report_id, revision):
        if not report_id or type(revision) is not int or revision < 1:
            raise ValueError("report_id and positive integer revision required")
        return self._get("/api/v1/reports/" + urllib.parse.quote(report_id, safe=""),
                         {"revision": revision})


def decode_can_event(arbitration_id, data, is_extended_id=True):
    """Decode one classic eight-byte latest-event frame; not a receipt."""
    node = arbitration_id & 0xff
    if (not is_extended_id or arbitration_id & 0xffffff00 != 0x18ff1100
            or not 1 <= node <= 127 or len(data) != 8):
        raise ValueError("expected GR-01 extended event frame")
    if data[0] != 1:
        raise ValueError("unsupported CAN major version")
    return {"node": node, "status": data[1], "flags": data[2],
            "revisionHint": data[3], "eventIndex": int.from_bytes(data[4:8], "big")}


def decode_modbus_snapshot(registers):
    """Decode 16 FC04 registers beginning at zero, from one response."""
    if len(registers) != 16 or any(type(r) is not int or not 0 <= r <= 65535 for r in registers):
        raise ValueError("expected 16 uint16 registers")
    if registers[0] >> 8 != 1:
        raise ValueError("unsupported Modbus major version")
    def u32(offset):
        return (registers[offset] << 16) | registers[offset + 1]
    return {"protocolVersion": registers[0], "deviceState": registers[1],
            "flags": registers[2], "status": registers[3], "eventIndex": u32(4),
            "reportRevision": u32(6), "uptimeSeconds": u32(8),
            "snapshotSequence": u32(10), "node": registers[12]}
