__init__.py

import os
from links.scitt import create_hashed_signed_statement, register_signed_statement
from fastapi import HTTPException
from lib.vcon_redis import VconRedis
from lib.logging_utils import init_logger
from starlette.status import HTTP_404_NOT_FOUND

logger = init_logger(__name__)

# Increment for any API/attribute changes
link_version = "0.3.0"

default_options = {
    "scrapi_url": "http://scittles:8000",
    "signing_key_path": "/etc/scitt/signing-key.pem",
    "issuer": "conserver",
    "key_id": "conserver-key-1",
    "vcon_operation": "vcon_created",
    "store_receipt": True,
}

def run(
    vcon_uuid: str,
    link_name: str,
    opts: dict = default_options
) -> str:
    """
    SCITT lifecycle registration link.

    Creates a COSE Sign1 signed statement from the vCon hash and registers
    it on a SCRAPI-compatible Transparency Service (SCITTLEs).

    The vcon_operation option controls the lifecycle event type:
    - "vcon_created": registered before transcription
    - "vcon_enhanced": registered after transcription

    Args:
        vcon_uuid: UUID of the vCon to process.
        link_name: Name of the link instance (for logging).
        opts: Configuration options.

    Returns:
        The UUID of the processed vCon.
    """
    module_name = __name__.split(".")[-1]
    logger.info(f"Starting {module_name}: {link_name} for: {vcon_uuid}")
    merged_opts = default_options.copy()
    merged_opts.update(opts)
    opts = merged_opts

    # Get the vCon from Redis
    vcon_redis = VconRedis()
    vcon = vcon_redis.get_vcon(vcon_uuid)
    if not vcon:
        logger.info(f"{link_name}: vCon not found: {vcon_uuid}")
        raise HTTPException(
            status_code=HTTP_404_NOT_FOUND,
            detail=f"vCon not found: {vcon_uuid}"
        )

    # Build per-participant SCITT registrations
    payload = vcon.hash
    operation = opts["vcon_operation"]

    signing_key_path = opts["signing_key_path"]
    signing_key = create_hashed_signed_statement.open_signing_key(signing_key_path)

    # Collect tel URIs from parties (Party objects use attrs, dicts use keys)
    party_tels = []
    for party in (vcon.parties or []):
        tel = party.get("tel") if isinstance(party, dict) else getattr(party, "tel", None)
        if tel:
            party_tels.append(tel)
        else:
            logger.warning(f"{link_name}: party without tel in {vcon_uuid}, skipping")

    # Fall back to vcon:// subject if no parties have tel
    if not party_tels:
        party_tels = [None]

    scrapi_url = opts["scrapi_url"]
    receipts = []

    for tel in party_tels:
        if tel:
            subject = f"tel:{tel}"
            operation_payload = f"{payload}:{operation}:{tel}"
            meta_map = {"vcon_operation": operation, "party_tel": tel}
        else:
            subject = f"vcon://{vcon_uuid}"
            operation_payload = f"{payload}:{operation}"
            meta_map = {"vcon_operation": operation}

        signed_statement = create_hashed_signed_statement.create_hashed_signed_statement(
            issuer=opts["issuer"],
            signing_key=signing_key,
            subject=subject,
            kid=opts["key_id"].encode("utf-8"),
            meta_map=meta_map,
            payload=operation_payload.encode("utf-8"),
            payload_hash_alg="SHA-256",
            payload_location="",
            pre_image_content_type="application/vcon+json",
        )
        logger.info(f"{link_name}: Created signed statement for {vcon_uuid} subject={subject} ({operation})")

        result = register_signed_statement.register_statement(scrapi_url, signed_statement)
        logger.info(f"{link_name}: Registered entry_id={result['entry_id']} subject={subject} for {vcon_uuid}")

        receipts.append({
            "entry_id": result["entry_id"],
            "vcon_operation": operation,
            "subject": subject,
            "vcon_hash": payload,
            "scrapi_url": scrapi_url,
        })

    # Store receipts as analysis entry on the vCon
    if opts.get("store_receipt", True):
        vcon.add_analysis(
            type="scitt_receipt",
            dialog=0,
            vendor="scittles",
            body=receipts if len(receipts) > 1 else receipts[0],
        )
        vcon_redis.store_vcon(vcon)
        logger.info(f"{link_name}: Stored {len(receipts)} SCITT receipt(s) for {vcon_uuid}")

    return vcon_uuid