"""Decode a hex-encoded GetTagInfoFromName response into a sanitized field map.

USE: pipe one tag's hex on stdin (no spaces), one per line. Identity-bearing string
values are reported only as length + non-ASCII flags so the output stays commit-safe.
"""
import struct
import sys
import binascii


def is_printable_ascii(b: bytes) -> bool:
    return all(0x20 <= c < 0x7F for c in b)


def decode_one(hex_str: str) -> None:
    raw = binascii.unhexlify(hex_str)
    n = len(raw)
    cur = 0

    # Fixed prefix
    desc = raw[cur:cur+4]; cur += 4
    type_id = raw[cur:cur+16]; cur += 16
    tag_key = struct.unpack_from('<I', raw, cur)[0]; cur += 4

    print(f"  total_bytes      = {n}")
    print(f"  [00..03] descriptor    = {desc.hex().upper()}")
    print(f"  [04..19] typeId(GUID)  = (16 bytes)")
    print(f"  [20..23] tagKey(uint32)= {tag_key}")

    # Walk compact ASCII strings until we hit a byte != 0x09
    string_idx = 1
    while cur < n and raw[cur] == 0x09:
        marker_off = cur
        cur += 1
        length = struct.unpack_from('<H', raw, cur)[0]; cur += 2
        value = raw[cur:cur + length]
        cur += length
        is_ascii = is_printable_ascii(value)
        print(f"  [{marker_off:02X}..{cur-1:02X}] string{string_idx}      = "
              f"compactAscii(len={length}, ascii={is_ascii})")
        string_idx += 1

    # 4-byte fixed block (nativeTagClass, storageType, deadbandType, interpolationType)
    if cur + 4 <= n:
        block = raw[cur:cur+4]
        print(f"  [{cur:02X}..{cur+3:02X}] fixedBlock4   = "
              f"class={block[0]} storage={block[1]} deadband={block[2]} interp={block[3]}")
        cur += 4

    # Try to identify trailing fields by structure
    print(f"  trailing bytes from offset 0x{cur:02X} ({n - cur} bytes):")
    trailing = raw[cur:]
    # Look for FILETIME pattern (year-2025 = 0x01DCxxxxxxxxxxxx, byte 7 = 0x01)
    for off in range(min(len(trailing) - 7, 16)):
        if trailing[off + 7] == 0x01 and trailing[off + 6] in (0xDB, 0xDC, 0xDD):
            ft_bytes = trailing[off:off+8]
            ft_value = struct.unpack_from('<q', ft_bytes)[0]
            # FILETIME → year approximation
            seconds = ft_value / 10_000_000
            years_since_1601 = seconds / 31_557_600
            year = 1601 + int(years_since_1601)
            print(f"    candidate FILETIME at trailing+0x{off:X}: year~{year} "
                  f"(absolute offset 0x{cur + off:02X})")

    # Look for double 10.0 (0x4024000000000000) and other doubles
    for off in range(0, len(trailing) - 7, 1):
        try:
            d = struct.unpack_from('<d', trailing, off)[0]
            if d != 0 and abs(d) < 1e10 and abs(d) > 1e-5:
                print(f"    double @trailing+0x{off:X} (abs 0x{cur+off:02X}) = {d}")
        except Exception:
            pass

    # Look for plausible uint32s (small, non-zero)
    for off in range(0, len(trailing) - 3, 1):
        v = struct.unpack_from('<I', trailing, off)[0]
        if 0 < v < 1_000_000:
            print(f"    uint32 @trailing+0x{off:X} (abs 0x{cur+off:02X}) = {v}")

    # Look for trailing marker (FE 00 or 00)
    if len(trailing) >= 2:
        last2 = trailing[-2:]
        last1 = trailing[-1:]
        print(f"    last 2 bytes: {last2.hex().upper()}")

    print()


def main() -> int:
    for line in sys.stdin:
        line = line.strip()
        if not line:
            continue
        # Allow optional "TagName: HEX" prefix
        if ':' in line:
            label, hex_str = line.split(':', 1)
            print(f"=== {label.strip()} ===")
            decode_one(hex_str.strip())
        else:
            decode_one(line)
    return 0


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