client_dashboard.py

#!/usr/bin/env python3
"""
SonicWave Client Dashboard - Flask Edition
Web-based interface for sending and receiving emergency communications.
"""

import logging
import threading
from flask import Flask, render_template, request, jsonify
from flask_socketio import SocketIO, emit

from sonicwave.ggwave_transport import GGWaveTransport
from sonicwave.packet import EmergencyPacket, PacketManager

# Configure logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

# Flask & SocketIO App
app = Flask(__name__)
app.config['SECRET_KEY'] = 'secret!'
socketio = SocketIO(app, async_mode='threading')

# SonicWave Components
packet_manager = PacketManager()
ggwave_transport = None

# --- Packet Handling ---
def on_packet_received(packet):
    """Callback function for when a packet is received."""
    logger.info(f"Packet received via GGWave: {packet.to_json()}")
    # Broadcast the received packet to all connected web clients
    socketio.emit('new_packet', packet.to_dict(), namespace='/dashboard')

# --- Transport Initialization ---
def initialize_ggwave():
    """Initializes and starts the GGWave transport."""
    global ggwave_transport
    try:
        ggwave_transport = GGWaveTransport(on_packet_received=on_packet_received)
        if ggwave_transport.initialize():
            ggwave_transport.start_listening()
            logger.info("GGWave transport initialized and listening.")
            socketio.emit('status_update', {'transport': 'ggwave', 'status': 'active'}, namespace='/dashboard')
        else:
            logger.error("Failed to initialize GGWave transport.")
            socketio.emit('status_update', {'transport': 'ggwave', 'status': 'error', 'message': 'Initialization failed'}, namespace='/dashboard')
    except Exception as e:
        logger.error(f"Error initializing GGWave: {e}")
        socketio.emit('status_update', {'transport': 'ggwave', 'status': 'error', 'message': str(e)}, namespace='/dashboard')

# --- Flask Routes ---
@app.route('/')
def index():
    """Serve the main client dashboard page."""
    return render_template('client_dashboard.html')

@app.route('/api/send', methods=['POST'])
def send_message():
    """API endpoint to send a message."""
    data = request.json
    if not data or 'message' not in data:
        return jsonify({'status': 'error', 'message': 'Invalid data'}), 400

    if not ggwave_transport or not ggwave_transport.is_listening():
        return jsonify({'status': 'error', 'message': 'GGWave transport is not active'}), 500

    try:
        packet = EmergencyPacket(
            emergency_type=data.get('emergency_type', 'GENERAL'),
            priority=data.get('priority', 'MEDIUM'),
            message=data['message'],
            location=data.get('location', 'Web Dashboard')
        )

        # Send the packet in a separate thread to avoid blocking the request
        threading.Thread(target=ggwave_transport.send_packet, args=(packet,)).start()

        logger.info(f"Queued packet for sending via GGWave: {packet.to_json()}")
        return jsonify({'status': 'success', 'message': 'Message queued for sending'})
    except Exception as e:
        logger.error(f"Error sending packet: {e}")
        return jsonify({'status': 'error', 'message': str(e)}), 500

# --- SocketIO Events ---
@socketio.on('connect', namespace='/dashboard')
def on_connect():
    """Handle new client connections."""
    logger.info("Web client connected.")
    emit('status_update', {'message': 'Connected to SonicWave server.'})
    # Report current ggwave status
    if ggwave_transport and ggwave_transport.is_listening():
        emit('status_update', {'transport': 'ggwave', 'status': 'active'})
    else:
        emit('status_update', {'transport': 'ggwave', 'status': 'inactive'})

@socketio.on('disconnect', namespace='/dashboard')
def on_disconnect():
    """Handle client disconnections."""
    logger.info("Web client disconnected.")

if __name__ == '__main__':
    # Initialize and start GGWave transport in a background thread
    init_thread = threading.Thread(target=initialize_ggwave)
    init_thread.daemon = True
    init_thread.start()

    logger.info("Starting Flask-SocketIO server on http://127.0.0.1:5000")
    socketio.run(app, host='127.0.0.1', port=5000, allow_unsafe_werkzeug=True)