# Backend structure
backend/
├── __init__.py
├── server.py              # Main application
├── api/                   # API endpoints
│   ├── __init__.py
│   ├── devices.py        # Device endpoints
│   ├── auth.py           # Authentication
│   ├── costs.py          # Cost calculations
│   └── websocket.py      # WebSocket handlers
├── core/                  # Core functionality
│   ├── config.py         # Configuration
│   ├── security.py       # Security utilities
│   └── database.py       # Database setup
├── managers/              # Business logic
│   ├── device_manager.py # Device management
│   ├── auth_manager.py   # Authentication
│   └── rate_manager.py   # Rate calculations
├── models/                # Data models
│   ├── device.py         # Device models
│   ├── user.py           # User models
│   └── reading.py        # Reading models
├── services/              # External services
│   ├── discovery.py      # Device discovery
│   ├── audit_logging.py  # Audit logging service
│   ├── backup_manager.py # Backup management
│   ├── data_export.py    # Data export service
│   └── ssl_manager.py    # SSL certificate management
└── utils/                 # Utilities
    ├── scheduler.py      # Task scheduling
    └── logger.py         # Logging setup

# Request processing pipeline
from fastapi import FastAPI, Depends, HTTPException
from fastapi.middleware.cors import CORSMiddleware

app = FastAPI()

# Middleware stack
app.add_middleware(
    CORSMiddleware,
    allow_origins=["http://localhost:3000"],
    allow_methods=["*"],
    allow_headers=["*"]
)

@app.middleware("http")
async def log_requests(request: Request, call_next):
    start_time = time.time()
    response = await call_next(request)
    process_time = time.time() - start_time
    logger.info(f"{request.method} {request.url.path} - {process_time:.3f}s")
    return response

# Dependency injection
async def get_current_user(token: str = Depends(oauth2_scheme)):
    user = await verify_token(token)
    if not user:
        raise HTTPException(status_code=401)
    return user

# Route handler
@app.get("/api/devices")
async def get_devices(
    user: User = Depends(get_current_user),
    db: Session = Depends(get_db)
):
    return await device_manager.get_user_devices(user.id, db)

# Repository pattern
class DeviceRepository:
    def __init__(self, db: Session):
        self.db = db
    
    async def get_all(self) -> List[Device]:
        return self.db.query(DeviceModel).all()
    
    async def get_by_ip(self, device_ip: str) -> Optional[Device]:
        return self.db.query(DeviceModel).filter(
            DeviceModel.device_ip == device_ip
        ).first()
    
    async def create(self, device: DeviceCreate) -> Device:
        db_device = DeviceModel(**device.dict())
        self.db.add(db_device)
        self.db.commit()
        self.db.refresh(db_device)
        return db_device
    
    async def update(self, device_ip: str, data: DeviceUpdate) -> Device:
        device = await self.get_by_ip(device_ip)
        for key, value in data.dict(exclude_unset=True).items():
            setattr(device, key, value)
        self.db.commit()
        return device

# WebSocket manager
class ConnectionManager:
    def __init__(self):
        self.active_connections: Dict[str, WebSocket] = {}
    
    async def connect(self, websocket: WebSocket, client_id: str):
        await websocket.accept()
        self.active_connections[client_id] = websocket
    
    async def disconnect(self, client_id: str):
        del self.active_connections[client_id]
    
    async def broadcast(self, message: dict):
        for connection in self.active_connections.values():
            await connection.send_json(message)

manager = ConnectionManager()

@app.websocket("/ws/{client_id}")
async def websocket_endpoint(websocket: WebSocket, client_id: str):
    await manager.connect(websocket, client_id)
    try:
        while True:
            data = await websocket.receive_text()
            # Process incoming messages
            await manager.broadcast({"type": "update", "data": data})
    except WebSocketDisconnect:
        await manager.disconnect(client_id)

# Event system
from typing import Dict, List, Callable
import asyncio

class EventBus:
    def __init__(self):
        self.listeners: Dict[str, List[Callable]] = {}
    
    def on(self, event: str, callback: Callable):
        if event not in self.listeners:
            self.listeners[event] = []
        self.listeners[event].append(callback)
    
    async def emit(self, event: str, data: any):
        if event in self.listeners:
            tasks = [
                asyncio.create_task(callback(data))
                for callback in self.listeners[event]
            ]
            await asyncio.gather(*tasks)

# Usage
event_bus = EventBus()

# Register listeners
event_bus.on('device.connected', handle_device_connected)
event_bus.on('device.data', handle_device_data)
event_bus.on('alert.triggered', handle_alert)

# Emit events
await event_bus.emit('device.connected', {'ip': '192.168.1.100'})

# Token management
from datetime import datetime, timedelta
from jose import JWTError, jwt

SECRET_KEY = os.getenv("JWT_SECRET_KEY")
ALGORITHM = "HS256"
ACCESS_TOKEN_EXPIRE_MINUTES = 30

def create_access_token(data: dict):
    to_encode = data.copy()
    expire = datetime.utcnow() + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
    to_encode.update({"exp": expire})
    return jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)

def verify_token(token: str):
    try:
        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
        return payload
    except JWTError:
        return None