Fall Detection System

import asyncio
import json
import logging
from datetime import datetime
from telegram import Update
from telegram.ext import Application, CommandHandler, ContextTypes
from bleak import BleakClient, BleakScanner
from typing import Final
import time
import sys

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

# Telegram Configuration - REPLACE WITH YOUR VALUES
TOKEN: Final = "8200016643:AAGxX25lJHHTu8RKAIrmgXEJ_3Riutb94qU"  # Replace with your bot token
BOT_USERNAME: Final = '@detectmyfall_bot'  # Replace with your bot username

# BLE Configuration
SERVICE_UUID = "19B10000-E8F2-537E-4F6C-D104768A1215"
PREDICTION_CHAR_UUID = "19B10001-E8F2-537E-4F6C-D104768A1215"
CLASSES_CHAR_UUID = "19B10002-E8F2-537E-4F6C-D104768A1215"
DEVICE_NAME = "FallDetector"

# Global variables
subscribers = set()
emergency_contacts = set()  # Special subscribers for emergency alerts
chunk_buffer = {}
is_monitoring = False
auto_reconnect = True
ble_client = None
device_address = None
application = None
fall_alert_active = False
last_fall_time = 0
pending_fall_notified = False  # Track if we've already notified about pending fall

# Emergency settings
FALL_CONFIDENCE_THRESHOLD = 0.99  # Threshold for potential fall detection
EMERGENCY_COOLDOWN = 300  # 5 minutes cooldown between emergency alerts


def escape_html(text):
    """Escape HTML special characters"""
    if not isinstance(text, str):
        text = str(text)
    return text.replace('&', '&amp;').replace('<', '&lt;').replace('>', '&gt;')


def format_prediction_message(data, fall_state="normal", is_emergency=False):
    """Format prediction data for Telegram"""
    try:
        timestamp = datetime.now().strftime("%H:%M:%S")

        if is_emergency:
            message = f" <b>EMERGENCY: FALL CONFIRMED!</b>\n {timestamp}\n\n"
        elif fall_state == "pending":
            message = f" <b>POTENTIAL FALL DETECTED</b>\n {timestamp}\n\n"
        else:
            message = f" <b>Movement Detection</b>\n {timestamp}\n\n"

        # Top prediction
        top_activity = escape_html(data.get('top', 'Unknown'))
        confidence = data.get('conf', 0) * 100

        # Activity emojis (only for your two classes: Stand and Fall)
        activity_emojis = {
            'fall': '',
            'stand': ''
        }

        emoji = activity_emojis.get(top_activity.lower(), '')

        if is_emergency:
            message += f" <b>{top_activity.upper()}</b> ({confidence:.1f}%)\n\n"
            message += " <b>FALL CONFIRMED - IMMEDIATE ATTENTION REQUIRED!</b>\n"
            message += " Check on the person immediately\n"
            message += " Consider calling emergency services\n"
            message += " No button press detected within 30 seconds\n\n"
        elif fall_state == "pending":
            message += f"{emoji} <b>Potential {top_activity.title()}</b> ({confidence:.1f}%)\n\n"
            message += " <b>30-second confirmation window active</b>\n"
            message += " Person can press button to cancel false alarm\n"
            message += " Will become emergency if no button press\n\n"
        else:
            message += f"{emoji} <b>{top_activity.title()}</b> ({confidence:.1f}%)\n\n"

        # Top 2 predictions (since you only have Stand and Fall)
        predictions = data.get('predictions', [])
        if predictions:
            sorted_preds = sorted(predictions, key=lambda x: x.get('c', 0), reverse=True)
            message += "<b>Detection Breakdown:</b>\n"
            for pred in sorted_preds:  # Show all predictions (only 2)
                label = escape_html(pred.get('l', 'Unknown')).title()
                conf = pred.get('c', 0) * 100
                pred_emoji = activity_emojis.get(label.lower(), '')

                # Highlight falls with special formatting
                if label.lower() == 'fall' and conf > 50:
                    if fall_state == "pending":
                        message += f" <b>{label}: {conf:.1f}%</b> (Pending confirmation)\n"
                    elif is_emergency:
                        message += f" <b>{label}: {conf:.1f}%</b> (CONFIRMED)\n"
                    else:
                        message += f" <b>{label}: {conf:.1f}%</b>\n"
                else:
                    message += f"{pred_emoji} {label}: {conf:.1f}%\n"

        # Anomaly detection
        if 'anom' in data and data['anom'] > 0.7:
            message += f"\n <b>Unusual pattern detected:</b> {data['anom']:.2f}"

        # Add fall state specific information
        if fall_state == "pending":
            message += f"\n <i>Waiting for user confirmation...</i>"
        elif fall_state == "confirmed":
            message += f"\n <i>Fall confirmed - no button press within timeout</i>"
        elif fall_state == "normal" and top_activity.lower() == 'fall':
            message += f"\n <i>Confidence below threshold ({FALL_CONFIDENCE_THRESHOLD * 100}%)</i>"

        return message

    except Exception as e:
        logger.error(f"Error formatting message: {e}")
        timestamp = datetime.now().strftime("%H:%M:%S")
        if is_emergency:
            return f" <b>EMERGENCY ALERT at {timestamp}</b>\n(Error formatting details)"
        else:
            return f" <b>Detection at {timestamp}</b>\n(Error formatting details)"


def handle_chunked_data(chunk_data):
    """Handle chunked BLE data transmission"""
    global chunk_buffer

    try:
        if ':' not in chunk_data:
            return chunk_data

        parts = chunk_data.split(':', 2)
        if len(parts) != 3:
            return chunk_data

        try:
            chunk_index = int(parts[0])
            total_chunks = int(parts[1])
            chunk_content = parts[2]
        except ValueError:
            return chunk_data

        logger.info(f"Received chunk {chunk_index + 1}/{total_chunks}")

        # Initialize buffer for new transmission
        if chunk_index == 0:
            chunk_buffer = {
                'total': total_chunks,
                'chunks': {},
                'timestamp': time.time()
            }

        if 'total' not in chunk_buffer:
            return None

        # Store chunk
        chunk_buffer['chunks'][chunk_index] = chunk_content

        # Check if complete
        if len(chunk_buffer['chunks']) == total_chunks:
            complete_data = ""
            for i in range(total_chunks):
                if i in chunk_buffer['chunks']:
                    complete_data += chunk_buffer['chunks'][i]
                else:
                    chunk_buffer = {}
                    return None

            chunk_buffer = {}
            logger.info(f"Reconstructed complete data: {len(complete_data)} chars")
            return complete_data

        return None

    except Exception as e:
        logger.error(f"Error handling chunked data: {e}")
        chunk_buffer = {}
        return chunk_data


async def send_to_subscribers(message, emergency=False):
    """Send message to subscribers (emergency alerts go to emergency contacts too)"""
    global subscribers, emergency_contacts, application

    if not application:
        return

    target_subscribers = subscribers.copy()
    if emergency:
        target_subscribers.update(emergency_contacts)

    if not target_subscribers:
        return

    failed_subscribers = []
    for chat_id in list(target_subscribers):
        try:
            await application.bot.send_message(
                chat_id=chat_id,
                text=message,
                parse_mode='HTML'
            )
            logger.info(f"Message sent to {chat_id} (emergency: {emergency})")
        except Exception as e:
            logger.error(f"Failed to send to {chat_id}: {e}")
            failed_subscribers.append(chat_id)

    # Remove failed subscribers
    for chat_id in failed_subscribers:
        subscribers.discard(chat_id)
        emergency_contacts.discard(chat_id)


async def notification_handler(sender, data):
    """Handle BLE notifications - Respond to fall confirmation states"""
    global fall_alert_active, last_fall_time, pending_fall_notified

    try:
        decoded_data = data.decode('utf-8')
        logger.info(f"Received BLE data: {decoded_data}")

        # Handle chunked data
        complete_data = handle_chunked_data(decoded_data)
        if complete_data is None:
            return

        logger.info(f"Processing complete data: {complete_data}")

        # Parse JSON
        try:
            prediction_data = json.loads(complete_data)
            logger.info(f"Parsed prediction data: {prediction_data}")
        except json.JSONDecodeError as e:
            logger.error(f"Invalid JSON: {e}")
            return

        # Get fall state from Arduino
        fall_state = prediction_data.get('fall_state', 'normal')  # normal, pending, confirmed
        top_prediction = prediction_data.get('top', '').lower()
        confidence = prediction_data.get('conf', 0)
        current_time = time.time()

        logger.info(f"Fall state: {fall_state}, Prediction: {top_prediction}, Confidence: {confidence:.3f}")
        print(fall_state)
        # Handle different fall states
        if fall_state == "pending":
            # Fall detected, waiting for button confirmation
            if not pending_fall_notified:  # Only send once per pending event
                logger.warning(f"POTENTIAL FALL DETECTED! Waiting for confirmation. Confidence: {confidence:.3f}")

                # Send pending fall notification to all subscribers
                pending_message = format_prediction_message(prediction_data, fall_state="pending", is_emergency=False)
                await send_to_subscribers(pending_message, emergency=False)

                # Also notify emergency contacts about pending fall
                if emergency_contacts:
                    emergency_pending_message = format_prediction_message(prediction_data, fall_state="pending",
                                                                          is_emergency=False)
                    await send_to_subscribers(emergency_pending_message, emergency=True)

                pending_fall_notified = True
                logger.info("Pending fall notification sent")

        elif fall_state == "confirmed":
            # Fall confirmed after 30 seconds without button press
            logger.critical(f"FALL CONFIRMED! No button press detected. Confidence: {confidence:.3f}")

            fall_alert_active = True
            last_fall_time = current_time
            pending_fall_notified = False  # Reset for next event

            # Send emergency alert to all subscribers
            emergency_message = format_prediction_message(prediction_data, fall_state="confirmed", is_emergency=True)
            await send_to_subscribers(emergency_message, emergency=False)

            # Send to emergency contacts as well
            if emergency_contacts:
                await send_to_subscribers(emergency_message, emergency=True)

            logger.critical("CONFIRMED FALL - Emergency notifications sent")

        elif fall_state == "timeout" or fall_state == "confirmed_timeout":
            # Fall timed out without button press (same as confirmed)
            logger.critical(f"FALL TIMEOUT! No button press within 30 seconds. Confidence: {confidence:.3f}")

            fall_alert_active = True
            last_fall_time = current_time
            pending_fall_notified = False  # Reset for next event

            # Send emergency alert to all subscribers
            emergency_message = format_prediction_message(prediction_data, fall_state="confirmed", is_emergency=True)
            await send_to_subscribers(emergency_message, emergency=False)

            # Send to emergency contacts as well
            if emergency_contacts:
                await send_to_subscribers(emergency_message, emergency=True)

            logger.critical("FALL TIMEOUT - Emergency notifications sent")

        elif fall_state == "cancelled" or fall_state == "canceled":
            # Fall was cancelled by button press
            logger.info("Fall was cancelled by button press")

            if pending_fall_notified:
                # Send cancellation message
                cancellation_message = f" <b>Fall Alert Cancelled</b>\n {datetime.now().strftime('%H:%M:%S')}\n\n"
                cancellation_message += " Button pressed - false alarm cancelled\n"
                cancellation_message += " Returning to normal monitoring"

                await send_to_subscribers(cancellation_message, emergency=False)
                if emergency_contacts:
                    await send_to_subscribers(cancellation_message, emergency=True)

                logger.info("Fall cancellation notification sent")

            pending_fall_notified = False

        elif fall_state == "normal":
            # Normal state - reset pending notification flag if transitioning from pending
            if pending_fall_notified:
                # This might be a transition from pending to normal (button press)
                logger.info("Fall was cancelled - returning to normal state")

                # Send cancellation message
                cancellation_message = f" <b>Fall Alert Cancelled</b>\n {datetime.now().strftime('%H:%M:%S')}\n\n"
                cancellation_message += " Button pressed - false alarm cancelled\n"
                cancellation_message += " Returning to normal monitoring"

                await send_to_subscribers(cancellation_message, emergency=False)
                if emergency_contacts:
                    await send_to_subscribers(cancellation_message, emergency=True)

                pending_fall_notified = False
                logger.info("Fall cancellation notification sent")

            # For normal high-confidence falls below emergency threshold, optionally notify
            elif top_prediction == 'fall' and confidence >= 0.5 and confidence < FALL_CONFIDENCE_THRESHOLD:
                logger.info(f"Low-confidence fall detected but below emergency threshold: {confidence:.3f}")
                # Uncomment below if you want notifications for lower-confidence falls
                # message = format_prediction_message(prediction_data, fall_state="normal", is_emergency=False)
                # await send_to_subscribers(message, emergency=False)

            # For all other normal cases (standing, very low confidence falls), do nothing
            else:
                logger.info(f"Normal activity detected: {top_prediction} ({confidence:.3f}) - No notification sent")

        elif fall_state.lower() == "stopped":
            # Arduino has stopped fall detection (button pressed to stop system)
            logger.info("Fall detection system stopped by user")

            if pending_fall_notified:
                # If there was a pending fall, treat this as cancellation
                cancellation_message = f" <b>Fall Detection Stopped</b>\n {datetime.now().strftime('%H:%M:%S')}\n\n"
                cancellation_message += " System stopped by user button press\n"
                cancellation_message += " Fall detection is now inactive\n"
                cancellation_message += "Press button again to resume monitoring"

                await send_to_subscribers(cancellation_message, emergency=False)
                if emergency_contacts:
                    await send_to_subscribers(cancellation_message, emergency=True)

                pending_fall_notified = False
                logger.info("Fall detection stopped notification sent")
            else:
                # Just a regular stop
                stop_message = f" <b>Fall Detection Stopped</b>\n {datetime.now().strftime('%H:%M:%S')}\n\n"
                stop_message += "Fall detection has been paused\n"
                stop_message += "Press button to resume monitoring"

                await send_to_subscribers(stop_message, emergency=False)
                logger.info("System stop notification sent")

        elif fall_state.lower() == "resumed" or fall_state.lower() == "active":
            # Arduino has resumed fall detection
            logger.info("Fall detection system resumed")

            resume_message = f" <b>Fall Detection Resumed</b>\n {datetime.now().strftime('%H:%M:%S')}\n\n"
            resume_message += " Fall detection is now active\n"
            resume_message += " Monitoring for falls..."

            await send_to_subscribers(resume_message, emergency=False)
            logger.info("Fall detection resumed notification sent")

            # Reset any pending states
            pending_fall_notified = False
            fall_alert_active = False

        else:
            # Handle any other unknown states
            logger.warning(f"Unknown fall state received: {fall_state}")

            # If we had a pending fall and got an unknown state, assume timeout
            if pending_fall_notified and fall_state not in ["normal", "pending", "cancelled", "canceled"]:
                logger.warning(f"Pending fall timeout with unknown state: {fall_state}")

                # Treat as confirmed fall
                fall_alert_active = True
                last_fall_time = current_time
                pending_fall_notified = False

                emergency_message = format_prediction_message(prediction_data, fall_state="confirmed",
                                                              is_emergency=True)
                await send_to_subscribers(emergency_message, emergency=False)

                if emergency_contacts:
                    await send_to_subscribers(emergency_message, emergency=True)

                logger.critical("Unknown state treated as confirmed fall")

    except Exception as e:
        logger.error(f"Notification handler error: {e}")


async def connect_to_device():
    """Connect to BLE device with improved connection handling"""
    global ble_client, device_address, is_monitoring

    max_retries = 5
    discovery_timeout = 20.0

    for attempt in range(max_retries):
        try:
            print(f'Looking for {DEVICE_NAME}... (Attempt {attempt + 1}/{max_retries})')

            # Scan for devices with longer timeout and more attempts
            devices = await BleakScanner.discover(timeout=discovery_timeout)
            target_device = None

            print(f"Found {len(devices)} BLE devices:")
            for device in devices:
                device_name = device.name or "None"
                print(f"  - {device_name} ({device.address})")
                if device.name and DEVICE_NAME in device.name:
                    print(f' Found target device: {DEVICE_NAME} at {device.address}')
                    target_device = device
                    device_address = device.address
                    break

            if not target_device:
                print(f' Could not find {DEVICE_NAME} in attempt {attempt + 1}')
                if attempt < max_retries - 1:
                    print(f'Waiting 3 seconds before retry...')
                    await asyncio.sleep(3)
                    continue
                else:
                    return False

            # Disconnect any existing client first
            if ble_client and ble_client.is_connected:
                try:
                    await ble_client.disconnect()
                    await asyncio.sleep(1)  # Give it time to disconnect
                except:
                    pass

            # Create new client with connection parameters
            print(f' Attempting to connect to {device_address}...')
            ble_client = BleakClient(
                target_device.address,
                timeout=30.0,  # 30 second timeout
                disconnected_callback=lambda client: print(" Device disconnected callback triggered")
            )

            # Try connection with multiple attempts
            connection_attempts = 3
            connected = False

            for conn_attempt in range(connection_attempts):
                try:
                    print(f'   Connection attempt {conn_attempt + 1}/{connection_attempts}...')
                    await ble_client.connect()

                    # Verify connection
                    if ble_client.is_connected:
                        print(f' Successfully connected to {device_address}')
                        connected = True
                        break
                    else:
                        print(f' Connection reported success but is_connected is False')

                except Exception as conn_e:
                    print(f' Connection attempt {conn_attempt + 1} failed: {conn_e}')
                    if conn_attempt < connection_attempts - 1:
                        await asyncio.sleep(2)
                        continue

            if not connected:
                print(f' All connection attempts failed for attempt {attempt + 1}')
                if ble_client:
                    try:
                        await ble_client.disconnect()
                    except:
                        pass
                    ble_client = None

                if attempt < max_retries - 1:
                    print(f'Waiting 5 seconds before next device discovery...')
                    await asyncio.sleep(5)
                continue

            # Verify services are available with retry
            service_attempts = 3
            service_found = False

            for svc_attempt in range(service_attempts):
                try:
                    print(f' Checking available services (attempt {svc_attempt + 1})...')

                    # Add small delay before checking services
                    await asyncio.sleep(1)

                    services = ble_client.services

                    if not services:
                        print(f' No services found on attempt {svc_attempt + 1}')
                        if svc_attempt < service_attempts - 1:
                            await asyncio.sleep(2)
                            continue
                        else:
                            break

                    for service in services:
                        print(f"  Service: {service.uuid}")
                        if str(service.uuid).upper() == SERVICE_UUID.upper():
                            service_found = True
                            print(f"   Found required service: {SERVICE_UUID}")
                            break

                    if service_found:
                        break
                    else:
                        print(f' Required service not found on attempt {svc_attempt + 1}')
                        if svc_attempt < service_attempts - 1:
                            await asyncio.sleep(2)

                except Exception as service_e:
                    print(f' Error checking services on attempt {svc_attempt + 1}: {service_e}')
                    if svc_attempt < service_attempts - 1:
                        await asyncio.sleep(2)

            if not service_found:
                print(f' Required service {SERVICE_UUID} not found after all attempts')
                await ble_client.disconnect()
                ble_client = None
                if attempt < max_retries - 1:
                    await asyncio.sleep(5)
                continue

            # Set up notifications with retry
            notification_attempts = 3
            notifications_started = False

            for notif_attempt in range(notification_attempts):
                try:
                    print(f' Setting up notifications (attempt {notif_attempt + 1})...')
                    await asyncio.sleep(1)  # Small delay

                    await ble_client.start_notify(PREDICTION_CHAR_UUID, notification_handler)
                    is_monitoring = True
                    notifications_started = True
                    print(' Notifications started successfully')
                    break

                except Exception as notify_e:
                    print(f' Failed to start notifications on attempt {notif_attempt + 1}: {notify_e}')
                    if notif_attempt < notification_attempts - 1:
                        await asyncio.sleep(2)

            if not notifications_started:
                print(f' Failed to start notifications after all attempts')
                await ble_client.disconnect()
                ble_client = None
                if attempt < max_retries - 1:
                    await asyncio.sleep(5)
                continue

            # Read classes if available (optional)
            try:
                print(' Reading available classes...')
                await asyncio.sleep(1)
                classes_data = await ble_client.read_gatt_char(CLASSES_CHAR_UUID)
                classes_json = classes_data.decode('utf-8')
                logger.info(f"Available classes: {classes_json}")
                print(' Classes read successfully')
            except Exception as e:
                logger.warning(f"Could not read classes (this is optional): {e}")
                print(' Could not read classes (this is optional)')

            await send_to_subscribers(
                " <b>Fall Detector Connected</b>\n Monitoring with button confirmation system active!")
            print(' BLE connection successful!')
            return True

        except Exception as e:
            logger.error(f"Connection attempt {attempt + 1} failed: {e}")
            print(f" Connection attempt {attempt + 1} failed: {e}")

            if ble_client:
                try:
                    await ble_client.disconnect()
                except:
                    pass
                ble_client = None

            if attempt < max_retries - 1:
                print(f'Waiting 5 seconds before retry...')
                await asyncio.sleep(5)

    print(f' Could not connect to {DEVICE_NAME} after {max_retries} attempts')
    return False


async def disconnect_device():
    """Disconnect from BLE device"""
    global ble_client, is_monitoring, fall_alert_active, pending_fall_notified

    try:
        is_monitoring = False
        fall_alert_active = False
        pending_fall_notified = False
        if ble_client and ble_client.is_connected:
            await ble_client.disconnect()
            ble_client = None
        await send_to_subscribers(" <b>Fall Detector Disconnected</b>")
        logger.info("Disconnected from device")

    except Exception as e:
        logger.error(f"Disconnect error: {e}")


# Command handlers
async def start_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Start command handler"""
    chat_id = update.message.chat.id
    subscribers.add(chat_id)

    message = " <b>Fall Detector Bot with Button Confirmation</b>\n\n"
    message += "Welcome! This bot monitors for falls using an Arduino sensor with push button confirmation.\n\n"
    message += "<b>How the confirmation system works:</b>\n"
    message += " When a potential fall is detected, you have 30 seconds to press the button\n"
    message += " Button press = False alarm cancelled\n"
    message += " No button press = Fall confirmed, emergency alert sent\n\n"
    message += "<b>Commands:</b>\n"
    message += " /start - Subscribe to notifications\n"
    message += " /stop - Unsubscribe\n"
    message += " /emergency - Subscribe to emergency alerts\n"
    message += " /status - Check status\n"
    message += " /connect - Connect to device\n"
    message += " /disconnect - Disconnect\n"
    message += " /reconnect - Toggle auto-reconnect\n"
    message += " /silence - Silence current fall alert\n"
    message += " /help - Show help\n\n"
    message += " Make sure your Arduino is powered on!\n\n"
    message += " <b>Important:</b> This is a monitoring tool, not a replacement for professional medical alert systems."

    await update.message.reply_text(message, parse_mode='HTML')
    logger.info(f"User {chat_id} subscribed")


async def stop_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Stop command handler"""
    chat_id = update.message.chat.id
    subscribers.discard(chat_id)
    emergency_contacts.discard(chat_id)
    await update.message.reply_text(
        " <b>Unsubscribed</b>\n\nYou've been removed from both regular and emergency notifications.\nUse /start to subscribe again",
        parse_mode='HTML'
    )
    logger.info(f"User {chat_id} unsubscribed")


async def emergency_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Emergency subscription command"""
    chat_id = update.message.chat.id
    subscribers.add(chat_id)  # Also add to regular subscribers
    emergency_contacts.add(chat_id)

    message = " <b>Emergency Contact Added</b>\n\n"
    message += " You'll receive ALL notifications including:\n"
    message += " Pending fall alerts (30-second countdown)\n"
    message += " Confirmed fall emergencies\n"
    message += " Fall cancellation notifications\n"
    message += " System status updates\n\n"
    message += " <b>Emergency alerts are only sent AFTER fall confirmation (30 seconds without button press).</b>\n\n"
    message += "Use /stop to unsubscribe from all notifications."

    await update.message.reply_text(message, parse_mode='HTML')
    logger.info(f"User {chat_id} added as emergency contact")


async def status_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Status command handler"""
    connection_status = " Connected" if is_monitoring else " Disconnected"
    subscriber_count = len(subscribers)
    emergency_count = len(emergency_contacts)
    auto_reconnect_status = " Enabled" if auto_reconnect else " Disabled"
    device_addr = escape_html(device_address or "Not found")
    alert_status = " ACTIVE" if fall_alert_active else " Clear"
    pending_status = " PENDING" if pending_fall_notified else " None"

    message = f"<b> Fall Detector Status</b>\n\n"
    message += f"<b>Device:</b> {connection_status}\n"
    message += f"<b>Address:</b> <code>{device_addr}</code>\n"
    message += f"<b>Alert Status:</b> {alert_status}\n"
    message += f"<b>Pending Falls:</b> {pending_status}\n"
    message += f"<b>Subscribers:</b> {subscriber_count}\n"
    message += f"<b>Emergency Contacts:</b> {emergency_count}\n"
    message += f"<b>Auto-reconnect:</b> {auto_reconnect_status}\n\n"

    if is_monitoring:
        message += " Monitoring with button confirmation system!\n"
        message += " 30-second confirmation window active\n"
        if fall_alert_active:
            message += " <b>Fall alert is currently active</b>\n"
            message += "Use /silence to acknowledge"
        elif pending_fall_notified:
            message += " <b>Fall confirmation pending</b>\n"
            message += "Waiting for button press or timeout"
    else:
        message += " Use /connect to start monitoring"

    await update.message.reply_text(message, parse_mode='HTML')


async def connect_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Connect command"""
    await update.message.reply_text(" <b>Connecting...</b>\n\nThis may take up to 60 seconds...", parse_mode='HTML')

    if await connect_to_device():
        await update.message.reply_text(
            " <b>Connected!</b>\n Monitoring with button confirmation system active...\n 30-second confirmation window enabled",
            parse_mode='HTML'
        )
    else:
        await update.message.reply_text(
            " <b>Connection failed</b>\n\n"
            "<b>Troubleshooting:</b>\n"
            " Make sure Arduino is powered on and advertising\n"
            " Reset the Arduino (power cycle)\n"
            " Check that device is nearby (&lt; 5m for connection)\n"
            " Ensure no other devices are connected to it\n"
            " Make sure the Arduino sketch is running properly\n"
            " Try restarting this bot\n"
            " Check Arduino serial monitor for BLE status",
            parse_mode='HTML'
        )


async def disconnect_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Disconnect command"""
    await disconnect_device()
    await update.message.reply_text(
        " <b>Disconnected</b>\n\nUse /connect to reconnect",
        parse_mode='HTML'
    )


async def reconnect_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Toggle auto-reconnect"""
    global auto_reconnect
    auto_reconnect = not auto_reconnect
    status = "enabled" if auto_reconnect else "disabled"
    emoji = "" if auto_reconnect else ""

    await update.message.reply_text(
        f"{emoji} <b>Auto-reconnect {status}</b>",
        parse_mode='HTML'
    )


async def silence_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Silence current fall alert"""
    global fall_alert_active, pending_fall_notified

    if fall_alert_active:
        fall_alert_active = False
        await update.message.reply_text(
            " <b>Fall alert silenced</b>\n\n Alert acknowledged\n Monitoring continues...",
            parse_mode='HTML'
        )
        # Notify all subscribers that alert was acknowledged
        await send_to_subscribers(
            f" <b>Fall Alert Acknowledged</b>\n\n Alert silenced by user\n {datetime.now().strftime('%H:%M:%S')}"
        )
        logger.info("Fall alert silenced by user")
    elif pending_fall_notified:
        await update.message.reply_text(
            " <b>Fall confirmation pending</b>\n\n Waiting for physical button press on device\n Cannot silence from Telegram during confirmation window",
            parse_mode='HTML'
        )
    else:
        await update.message.reply_text(
            " <b>No active fall alert</b>\n\nThere's currently no fall alert to silence.",
            parse_mode='HTML'
        )


async def help_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Help command"""
    message = " <b>Fall Detector Bot with Button Confirmation</b>\n\n"
    message += "<b>How it works:</b>\n"
    message += "Connects to Arduino Nano BLE Sense 33 with IMU sensor for real-time fall detection using AI with button confirmation system.\n\n"
    message += "<b>Button Confirmation System:</b>\n"
    message += "1 AI detects potential fall\n"
    message += "2 30-second countdown begins\n"
    message += "3 Press button to cancel false alarm\n"
    message += "4 No button press = Emergency alert sent\n\n"
    message += "<b>Setup:</b>\n"
    message += "1 Flash Arduino code to your device\n"
    message += "2 Connect push button to Arduino\n"
    message += "3 Power on Arduino\n"
    message += "4 Use /start to subscribe\n"
    message += "5 Use /emergency for critical alerts\n"
    message += "6 Use /connect to connect\n"
    message += "7 Test the system!\n\n"
    message += "<b>Commands:</b>\n"
    message += "/start - Subscribe to notifications\n"
    message += "/stop - Unsubscribe\n"
    message += "/emergency - Subscribe to emergency alerts\n"
    message += "/status - Check system status\n"
    message += "/connect - Connect to Arduino\n"
    message += "/disconnect - Disconnect\n"
    message += "/reconnect - Toggle auto-reconnect\n"
    message += "/silence - Acknowledge fall alert\n"
    message += "/help - Show this help\n\n"
    message += "<b>Alert Types:</b>\n"
    message += " <b>Pending Fall:</b> 30-second confirmation window\n"
    message += " <b>Confirmed Fall:</b> No button press detected\n"
    message += " <b>Cancelled Fall:</b> Button pressed in time\n\n"
    message += "<b>Detection Classes:</b>\n"
    message += "The system detects two states:\n"
    message += " <b>Stand</b> - Person is standing upright\n"
    message += " <b>Fall</b> - Person has fallen down\n\n"
    message += "<b>Safety Features:</b>\n"
    message += " Physical button confirmation prevents false alarms\n"
    message += " Emergency contacts get immediate notifications\n"
    message += " Configurable confirmation timeout (default: 30s)\n"
    message += " Alerts can be acknowledged with /silence\n"
    message += " Auto-reconnection for reliability\n\n"
    message += "<b>Troubleshooting:</b>\n"
    message += " Keep Arduino within 5m range for connection\n"
    message += " Only one connection at a time\n"
    message += " Power cycle Arduino if issues persist\n"
    message += " Connection may take up to 60 seconds\n"
    message += " Check battery/power supply\n"
    message += " Ensure Arduino sketch is running\n"
    message += " Test button functionality regularly\n"
    message += " Check BLE advertisement status\n\n"
    message += "<b>Hardware Requirements:</b>\n"
    message += " Arduino Nano 33 BLE Sense\n"
    message += " Push button (normally open)\n"
    message += " 10k pull-up resistor (optional, internal pull-up used)\n"
    message += " Stable power supply\n\n"
    message += " <b>Important:</b> This is a monitoring tool with confirmation system, not a replacement for professional medical alert systems."

    await update.message.reply_text(message, parse_mode='HTML')


async def error_handler(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Handle errors"""
    logger.error(f"Update {update} caused error {context.error}")


def check_event_loop():
    """Check if there's already an event loop running"""
    try:
        loop = asyncio.get_running_loop()
        return True
    except RuntimeError:
        return False


async def auto_reconnect_loop():
    """Auto-reconnect loop that runs in background"""
    global auto_reconnect, is_monitoring, ble_client

    while True:
        try:
            await asyncio.sleep(30)  # Check every 30 seconds

            if auto_reconnect and not is_monitoring:
                logger.info("Auto-reconnect: Attempting to reconnect...")
                if await connect_to_device():
                    logger.info("Auto-reconnect: Successfully reconnected")
                else:
                    logger.warning("Auto-reconnect: Failed to reconnect, will try again")

        except Exception as e:
            logger.error(f"Auto-reconnect loop error: {e}")
            await asyncio.sleep(60)  # Wait longer on error


async def connection_monitor():
    """Monitor BLE connection and handle disconnections"""
    global ble_client, is_monitoring, auto_reconnect

    while True:
        try:
            await asyncio.sleep(10)  # Check every 10 seconds

            if is_monitoring and ble_client:
                if not ble_client.is_connected:
                    logger.warning("Connection lost! Device disconnected")
                    is_monitoring = False
                    await send_to_subscribers(" <b>Connection Lost</b>\n Device disconnected unexpectedly")

                    if auto_reconnect:
                        logger.info("Attempting auto-reconnect...")
                        await asyncio.sleep(5)  # Wait a bit before reconnecting

        except Exception as e:
            logger.error(f"Connection monitor error: {e}")
            await asyncio.sleep(30)


async def main():
    """Main function"""
    global application

    print(" Starting Fall Detector Bot with Button Confirmation...")
    print(f"   Bot Token: {'Set' if TOKEN != 'YOUR_TELEGRAM_BOT_TOKEN' else 'NOT SET'}")

    if TOKEN == "YOUR_TELEGRAM_BOT_TOKEN":
        print(" ERROR: Please set your Telegram bot token!")
        return

    # Create application
    application = Application.builder().token(TOKEN).build()

    # Add handlers
    application.add_handler(CommandHandler('start', start_command))
    application.add_handler(CommandHandler('stop', stop_command))
    application.add_handler(CommandHandler('emergency', emergency_command))
    application.add_handler(CommandHandler('status', status_command))
    application.add_handler(CommandHandler('connect', connect_command))
    application.add_handler(CommandHandler('disconnect', disconnect_command))
    application.add_handler(CommandHandler('reconnect', reconnect_command))
    application.add_handler(CommandHandler('silence', silence_command))
    application.add_handler(CommandHandler('help', help_command))
    application.add_error_handler(error_handler)

    print(" Bot initialized!")
    print(" Starting bot...")
    print(" Send /help to your bot for instructions")

    # Initialize and start the application
    try:
        await application.initialize()
        await application.start()
        await application.updater.start_polling(drop_pending_updates=True)

        print(" Bot is running! Press Ctrl+C to stop.")

        # Start background tasks
        auto_reconnect_task = asyncio.create_task(auto_reconnect_loop())
        connection_monitor_task = asyncio.create_task(connection_monitor())

        # Keep the bot running
        try:
            while True:
                await asyncio.sleep(1)
        except KeyboardInterrupt:
            print('\n Received Keyboard Interrupt')

        # Cancel background tasks
        auto_reconnect_task.cancel()
        connection_monitor_task.cancel()

        try:
            await auto_reconnect_task
        except asyncio.CancelledError:
            pass

        try:
            await connection_monitor_task
        except asyncio.CancelledError:
            pass

    except Exception as e:
        print(f" Error starting bot: {e}")

    finally:
        print(" Cleaning up...")
        try:
            # Disconnect BLE device
            await disconnect_device()

            if application.updater.running:
...

This file has been truncated, please download it to see its full contents.