@startuml
title NATS — PROPALGATION_EVENT : Pair A propage vers Pair B

participant "App Pair A" as AppA
participant "NATS A" as NATSA
participant "Node A" as NodeA
participant "StreamService A" as StreamA
participant "Node B" as NodeB
participant "NATS B" as NATSB
participant "DB Pair B (oc-lib)" as DBB

AppA -> NATSA: Publish(PROPALGATION_EVENT, {Action, DataType, Payload})
NATSA -> NodeA: ListenNATS callback → PROPALGATION_EVENT
NodeA -> NodeA: resp.FromApp != "oc-discovery" ? → continuer
NodeA -> NodeA: json.Unmarshal → PropalgationMessage{Action, DataType, Payload}

alt Action == PB_DELETE
    NodeA -> StreamA: ToPartnerPublishEvent(PB_DELETE, dt, user, payload)
    StreamA -> StreamA: searchPeer(PARTNER) → [Pair B, ...]
    StreamA -> NodeB: write(PeerID_B, addr_B, dt, user, payload, ProtocolDeleteResource)
    note over NodeB: /opencloud/resource/delete/1.0

    NodeB -> NodeB: handleEventFromPartner(evt, ProtocolDeleteResource)
    NodeB -> NATSB: SetNATSPub(REMOVE_RESOURCE, {DataType, resource JSON})
    NATSB -> DBB: Supprimer ressource dans DB B

else Action == PB_UPDATE (via ProtocolUpdateResource)
    NodeA -> StreamA: ToPartnerPublishEvent(PB_UPDATE, dt, user, payload)
    StreamA -> NodeB: write → /opencloud/resource/update/1.0
    NodeB -> NATSB: SetNATSPub(CREATE_RESOURCE, {DataType, resource JSON})
    NATSB -> DBB: Upsert ressource dans DB B

else Action == PB_CONSIDERS + WORKFLOW_EXECUTION
    NodeA -> NodeA: Unmarshal → executionConsidersPayload{PeerIDs:[PeerID_B, ...]}
    loop Pour chaque peer_id cible
        NodeA -> StreamA: PublishCommon(dt, user, PeerID_B, ProtocolConsidersResource, payload)
        StreamA -> NodeB: write → /opencloud/resource/considers/1.0
        NodeB -> NodeB: passConsidering(evt)
        NodeB -> NATSB: SetNATSPub(PROPALGATION_EVENT, {PB_CONSIDERS, dt, payload})
        NATSB -> DBB: (traité par oc-workflow sur NATS B)
    end

else Action == PB_PLANNER (broadcast)
    NodeA -> NodeA: Unmarshal → {peer_id: nil, ...payload}
    loop Pour chaque stream ProtocolSendPlanner ouvert
        NodeA -> StreamA: PublishCommon(nil, user, pid, ProtocolSendPlanner, payload)
        StreamA -> NodeB: write → /opencloud/resource/planner/1.0
    end

else Action == PB_CLOSE_PLANNER
    NodeA -> NodeA: Unmarshal → {peer_id: PeerID_B}
    NodeA -> StreamA: Streams[ProtocolSendPlanner][PeerID_B].Stream.Close()
    NodeA -> StreamA: delete(Streams[ProtocolSendPlanner], PeerID_B)

else Action == PB_SEARCH + DataType == PEER
    NodeA -> NodeA: Unmarshal → {search: "..."}
    NodeA -> NodeA: GetPeerRecord(ctx, search)
    note over NodeA: Résolution via DB A + Indexer + DHT
    NodeA -> NATSA: SetNATSPub(SEARCH_EVENT, {PEER, PeerRecord JSON})
    NATSA -> NATSA: (AppA reçoit le résultat)

else Action == PB_SEARCH + autre DataType
    NodeA -> NodeA: Unmarshal → {type:"all"|"known"|"partner", search:"..."}
    NodeA -> NodeA: PubSubService.SearchPublishEvent(ctx, dt, type, user, search)
    note over NodeA: Voir diagrammes 10 et 11
end

@enduml