trestle.core.canonicalization

def canonicalize_json_object(json_obj: Any) -> bytes:
    """Return RFC 8785 canonical UTF-8 bytes for a parsed JSON-compatible object."""
    try:
        return rfc8785.dumps(json_obj)
    except rfc8785.CanonicalizationError as error:
        raise TrestleError(f'Unable to canonicalize JSON object according to RFC 8785: {error}')

def canonicalize_json_text(json_text: str) -> Tuple[Any, bytes]:
    """Parse JSON text and return its parsed object and canonical bytes."""
    try:
        json_obj = json.loads(
            json_text, object_pairs_hook=_object_pairs_without_duplicates, parse_constant=_reject_json_constant
        )
    except json.JSONDecodeError as error:
        raise TrestleError(f'Input is not valid JSON: {error}')

    return json_obj, canonicalize_json_object(json_obj)

def digest_algorithm_name(algorithm: Algorithm) -> str:
    """Return the hashlib and in-toto name for a supported OSCAL digest algorithm."""
    # OSCAL's base model imports canonicalization, so defer this import to avoid a cycle.
    from trestle.oscal.common import Algorithm

    if not isinstance(algorithm, Algorithm):
        raise TrestleError(f'Unsupported digest algorithm: {algorithm}')
    return algorithm.value.lower().replace('sha-', 'sha').replace('-', '_')

def digest_hex(data: bytes, algorithm: Algorithm) -> str:
    """Return a hexadecimal digest using the selected OSCAL algorithm."""
    return hashlib.new(digest_algorithm_name(algorithm), data).hexdigest()

def load_canonical_json_file(path: pathlib.Path) -> Tuple[Any, bytes]:
    """Load a JSON document and return its parsed object and canonical bytes."""
    if not path.exists() or not path.is_file():
        raise TrestleError(f'JSON path does not exist or is not a file: {path}')

    return canonicalize_json_text(path.read_text(encoding=const.FILE_ENCODING))

def parse_digest_algorithm(name: Any) -> Algorithm:
    """Resolve an in-toto digest name to a supported OSCAL algorithm."""
    from trestle.oscal.common import Algorithm

    for algorithm in Algorithm:
        if digest_algorithm_name(algorithm) == name:
            return algorithm
    raise TrestleError(f'Unsupported digest algorithm: {name}')

def sha256_digest_hex(data: bytes) -> str:
    """Return a SHA-256 digest for compatibility with existing callers."""
    from trestle.oscal.common import Algorithm

    return digest_hex(data, Algorithm.SHA_256)