#!/bin/bash

# Event Utilities for Superball Protocol Tests

# Create a test event (kind 1 text note)
create_test_event() {
    local privkey=$1
    local content=$2
    local timestamp=${3:-$(date +%s)}
    
    echo "{\"content\":\"$content\",\"created_at\":$timestamp}" | \
        nak event --sec "$privkey" -k 1 --tag ""
}

# Create routing payload (Type 1)
create_routing_payload() {
    local event_json=$1
    local relays=$2  # Comma-separated relay URLs
    local delay=$3
    local next_hop_pubkey=${4:-null}
    local audit_tag=$5
    local add_padding_bytes=${6:-0}
    
    # Convert relays to JSON array
    local relay_array="["
    IFS=',' read -ra RELAY_ARRAY <<< "$relays"
    for i in "${!RELAY_ARRAY[@]}"; do
        if [ $i -gt 0 ]; then
            relay_array+=","
        fi
        relay_array+="\"${RELAY_ARRAY[$i]}\""
    done
    relay_array+="]"
    
    # Build routing payload
    local routing_payload=$(cat <<EOF
{
  "event": $event_json,
  "relays": $relay_array,
  "delay": $delay,
  "next_hop_pubkey": $([ "$next_hop_pubkey" = "null" ] && echo "null" || echo "\"$next_hop_pubkey\""),
  "audit_tag": "$audit_tag"
EOF
)
    
    if [ $add_padding_bytes -gt 0 ]; then
        routing_payload+=",\n  \"add_padding_bytes\": $add_padding_bytes"
    fi
    
    routing_payload+=$'\n}'
    
    echo "$routing_payload"
}

# Create padding payload (Type 2)
create_padding_payload() {
    local event_json=$1
    local padding_bytes=$2
    
    # Generate random padding
    local padding=$(head -c "$padding_bytes" /dev/urandom | base64 -w 0)
    
    cat <<EOF
{
  "event": $event_json,
  "padding": "$padding"
}
EOF
}

# Encrypt payload with NIP-44
encrypt_payload() {
    local sender_privkey=$1
    local recipient_pubkey=$2
    local payload=$3
    
    echo "$payload" | nak encrypt --sec "$sender_privkey" --recipient-pubkey "$recipient_pubkey"
}

# Create kind 22222 routing event
create_routing_event() {
    local sender_privkey=$1
    local recipient_pubkey=$2
    local encrypted_content=$3
    local timestamp=${4:-$(date +%s)}
    
    # Create event with p-tag for recipient
    nak event --sec "$sender_privkey" -k 22222 \
        --tag "p,$recipient_pubkey" \
        --content "$encrypted_content" \
        --created-at "$timestamp"
}

# Extract event ID from event JSON
get_event_id() {
    local event_json=$1
    echo "$event_json" | jq -r '.id'
}

# Extract pubkey from event JSON
get_event_pubkey() {
    local event_json=$1
    echo "$event_json" | jq -r '.pubkey'
}

# Extract content from event JSON
get_event_content() {
    local event_json=$1
    echo "$event_json" | jq -r '.content'
}

# Verify event signature
verify_event_signature() {
    local event_json=$1
    
    # Use nak to verify (it will exit with error if invalid)
    echo "$event_json" | nak verify 2>/dev/null
    return $?
}

# Publish event to relay
publish_event() {
    local event_json=$1
    local relay=$2
    
    echo "$event_json" | nak event "$relay" 2>&1
}

# Query event from relay
query_event() {
    local event_id=$1
    local relay=$2
    local timeout=${3:-5}
    
    nak req --relay "$relay" -i "$event_id" --timeout "$timeout" 2>/dev/null
}

# Monitor relay for specific event kind
monitor_relay_for_kind() {
    local relay=$1
    local kind=$2
    local timeout=${3:-30}
    
    timeout "$timeout" nak req --stream --relay "$relay" -k "$kind" 2>/dev/null
}

# Get pubkey from private key
get_pubkey_from_privkey() {
    local privkey=$1
    nak key public "$privkey"
}