"""
Micropython NATS Bridge - Simple Example

This example demonstrates the basic usage of the NATSBridge for Micropython.
"""

import sys
sys.path.insert(0, "../src")

from nats_bridge import smartsend, smartreceive, log_trace
import json


def example_simple_chat():
    """
    Simple chat example: Send text messages via NATS.
    
    Sender (this script):
    - Sends a text message to NATS
    - Uses direct transport (no fileserver needed)
    
    Receiver (separate script):
    - Listens to NATS
    - Receives and processes the message
    """
    print("=== Simple Chat Example ===")
    print()
    
    # Define the message data as list of (dataname, data, type) tuples
    data = [
        ("message", "Hello from Micropython!", "text")
    ]
    
    # Send the message
    env = smartsend(
        "/chat/room1",
        data,
        nats_url="nats://localhost:4222",
        msg_purpose="chat",
        sender_name="micropython-client"
    )
    
    print("Message sent!")
    print("  Subject: {}".format(env.send_to))
    print("  Correlation ID: {}".format(env.correlation_id))
    print("  Payloads: {}".format(len(env.payloads)))
    print()
    
    # Expected receiver output:
    print("Expected receiver output:")
    print("  [timestamp] [Correlation: ...] Starting smartsend for subject: /chat/room1")
    print("  [timestamp] [Correlation: ...] Serialized payload 'message' (type: text) size: 22 bytes")
    print("  [timestamp] [Correlation: ...] Using direct transport for 22 bytes")
    print("  [timestamp] [Correlation: ...] Message published to /chat/room1")
    print()
    
    return env


def example_send_json():
    """
    Example: Send JSON configuration to a Micropython device.
    
    This demonstrates sending structured data (dictionary type).
    """
    print("\n=== Send JSON Configuration ===")
    print()
    
    # Define configuration as dictionary
    config = {
        "wifi_ssid": "MyNetwork",
        "wifi_password": "password123",
        "server_host": "mqtt.example.com",
        "server_port": 1883,
        "update_interval": 60
    }
    
    # Send configuration
    data = [
        ("device_config", config, "dictionary")
    ]
    
    env = smartsend(
        "/device/config",
        data,
        nats_url="nats://localhost:4222",
        msg_purpose="updateStatus",
        sender_name="server"
    )
    
    print("Configuration sent!")
    print("  Subject: {}".format(env.send_to))
    print("  Payloads: {}".format(len(env.payloads)))
    print()
    
    return env


def example_receive_message(msg):
    """
    Example: Receive and process a NATS message.
    
    Args:
        msg: The NATS message received (should be dict or JSON string)
    
    Returns:
        list: List of (dataname, data, type) tuples
    """
    print("\n=== Receive Message ===")
    print()
    
    # Process the message
    payloads = smartreceive(
        msg,
        fileserver_download_handler=None,  # Not needed for direct transport
        max_retries=3,
        base_delay=100,
        max_delay=1000
    )
    
    print("Received {} payload(s):".format(len(payloads)))
    for dataname, data, type in payloads:
        print("  - {}: {} (type: {})".format(dataname, data, type))
    
    return payloads


def example_mixed_content():
    """
    Example: Send mixed content (text + dictionary + binary).
    
    This demonstrates the multi-payload capability.
    """
    print("\n=== Mixed Content Example ===")
    print()
    
    # Create mixed content
    image_data = b"\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR"  # Example PNG header
    
    data = [
        ("message_text", "Hello with image!", "text"),
        ("user_config", {"theme": "dark", "notifications": True}, "dictionary"),
        ("user_avatar", image_data, "binary")
    ]
    
    env = smartsend(
        "/chat/mixed",
        data,
        nats_url="nats://localhost:4222",
        msg_purpose="chat",
        sender_name="micropython-client"
    )
    
    print("Mixed content sent!")
    print("  Subject: {}".format(env.send_to))
    print("  Payloads:")
    for p in env.payloads:
        print("    - {} (transport: {}, type: {}, size: {} bytes)".format(
            p.dataname, p.transport, p.type, p.size))
    
    return env


def example_reply():
    """
    Example: Send a message with reply-to functionality.
    
    This demonstrates request-response pattern.
    """
    print("\n=== Request-Response Example ===")
    print()
    
    # Send command
    data = [
        ("command", {"action": "read_sensor", "sensor_id": "temp1"}, "dictionary")
    ]
    
    env = smartsend(
        "/device/command",
        data,
        nats_url="nats://localhost:4222",
        msg_purpose="command",
        sender_name="server",
        reply_to="/device/response",
        reply_to_msg_id="cmd-001"
    )
    
    print("Command sent!")
    print("  Subject: {}".format(env.send_to))
    print("  Reply To: {}".format(env.reply_to))
    print("  Reply To Msg ID: {}".format(env.reply_to_msg_id))
    print()
    
    print("Expected receiver behavior:")
    print("  1. Receive command on /device/command")
    print("  2. Process command")
    print("  3. Send response to /device/response")
    print("  4. Include replyToMsgId in response")
    
    return env


if __name__ == "__main__":
    print("Micropython NATS Bridge Examples")
    print("================================")
    print()
    
    # Run examples
    example_simple_chat()
    example_send_json()
    example_mixed_content()
    example_reply()
    
    print("\n=== Examples Completed ===")
    print()
    print("To run these examples, you need:")
    print("  1. A running NATS server at nats://localhost:4222")
    print("  2. Import the nats_bridge module")
    print("  3. Call the desired example function")
    print()
    print("For more examples, see test/test_micropython_basic.py")