# 라이브러리 설치
pip install paho-mqtt
pip install requests  # HTTP 업로드용
pip install python-dotenv  # 환경변수 관리용

import paho.mqtt.client as mqtt
import json
import time
import random
import ssl
from datetime import datetime

# ===== 설정값 =====
BROKER_HOST = "your-broker.example.com"  # MQTT 브로커 주소
BROKER_PORT = 8883                        # TLS 포트 (일반은 1883)
CLIENT_ID = "sensor_device_001"
TOPIC = "home/livingroom/sensors"
USERNAME = "your_username"
PASSWORD = "your_password"

# TLS 인증서 경로 (보안 연결 시 필요)
CA_CERT = "./certs/ca.crt"
CLIENT_CERT = "./certs/client.crt"
CLIENT_KEY = "./certs/client.key"

# ===== 콜백 함수들 =====
def on_connect(client, userdata, flags, rc):
    """브로커 연결 성공/실패 콜백"""
    if rc == 0:
        print(f"✅ 브로커 연결 성공! 코드: {rc}")
    else:
        print(f"❌ 연결 실패. 코드: {rc}")
        # rc 코드 의미:
        # 1: 잘못된 프로토콜 버전
        # 2: 클라이언트 ID 거부
        # 3: 서버 사용 불가
        # 4: 잘못된 사용자명/비밀번호
        # 5: 권한 없음

def on_publish(client, userdata, mid):
    """메시지 발행 완료 콜백"""
    print(f"📤 메시지 발행 완료. MID: {mid}")

def on_disconnect(client, userdata, rc):
    """연결 해제 콜백"""
    if rc != 0:
        print(f"⚠️ 예상치 못한 연결 해제. 재연결 시도...")

# ===== 센서 데이터 읽기 함수 =====
def read_sensor_data():
    """
    실제 환경에서는 GPIO, I2C, SPI 등으로 센서 읽기
    여기서는 시뮬레이션 데이터 사용
    """
    return {
        "device_id": CLIENT_ID,
        "timestamp": datetime.utcnow().isoformat() + "Z",
        "temperature": round(random.uniform(18.0, 35.0), 2),  # 섭씨
        "humidity": round(random.uniform(30.0, 80.0), 2),      # %
        "pressure": round(random.uniform(1000.0, 1020.0), 2),  # hPa
        "battery": round(random.uniform(3.0, 4.2), 2),         # V
        "rssi": random.randint(-90, -40)                        # dBm (신호 강도)
    }

# ===== MQTT 클라이언트 설정 =====
def setup_mqtt_client():
    client = mqtt.Client(
        client_id=CLIENT_ID,
        clean_session=True,
        protocol=mqtt.MQTTv311  # MQTT 3.1.1 버전 사용
    )
    
    # 인증 설정
    client.username_pw_set(USERNAME, PASSWORD)
    
    # TLS/SSL 설정 (보안 연결)
    client.tls_set(
        ca_certs=CA_CERT,
        certfile=CLIENT_CERT,
        keyfile=CLIENT_KEY,
        tls_version=ssl.PROTOCOL_TLSv1_2
    )
    
    # 콜백 등록
    client.on_connect = on_connect
    client.on_publish = on_publish
    client.on_disconnect = on_disconnect
    
    # Last Will Testament (LWT) 설정
    # 디바이스가 갑자기 끊겼을 때 브로커가 자동으로 발행하는 메시지
    lwt_payload = json.dumps({
        "device_id": CLIENT_ID,
        "status": "offline",
        "timestamp": datetime.utcnow().isoformat() + "Z"
    })
    client.will_set(
        topic=f"home/devices/{CLIENT_ID}/status",
        payload=lwt_payload,
        qos=1,
        retain=True
    )
    
    return client

# ===== 메인 실행 =====
def main():
    client = setup_mqtt_client()
    
    # 브로커 연결 (비동기)
    client.connect(BROKER_HOST, BROKER_PORT, keepalive=60)
    
    # 백그라운드 네트워크 루프 시작
    client.loop_start()
    
    # 온라인 상태 발행
    online_payload = json.dumps({
        "device_id": CLIENT_ID,
        "status": "online",
        "timestamp": datetime.utcnow().isoformat() + "Z"
    })
    client.publish(
        topic=f"home/devices/{CLIENT_ID}/status",
        payload=online_payload,
        qos=1,
        retain=True
    )
    
    print("🚀 센서 데이터 전송 시작!")
    
    try:
        while True:
            # 센서 데이터 읽기
            sensor_data = read_sensor_data()
            
            # JSON 직렬화
            payload = json.dumps(sensor_data, ensure_ascii=False)
            
            # MQTT 발행
            # QoS 레벨:
            # 0: 최대 1회 전달 (빠르지만 유실 가능)
            # 1: 최소 1회 전달 (중복 가능하지만 유실 없음)
            # 2: 정확히 1회 전달 (가장 안전하지만 느림)
            result = client.publish(
                topic=TOPIC,
                payload=payload,
                qos=1,
                retain=False
            )
            
            if result.rc == mqtt.MQTT_ERR_SUCCESS:
                print(f"✅ 전송 성공: {sensor_data['temperature']}°C, {sensor_data['humidity']}%")
            else:
                print(f"❌ 전송 실패. 에러 코드: {result.rc}")
            
            time.sleep(5)  # 5초마다 전송
            
    except KeyboardInterrupt:
        print("\n⛔ 종료 신호 감지. 정리 중...")
    finally:
        client.loop_stop()
        client.disconnect()
        print("👋 연결 종료 완료")

if __name__ == "__main__":
    main()

import paho.mqtt.client as mqtt
import json
import time
import threading
from datetime import datetime

class RobustMQTTPublisher:
    """
    재연결 기능이 포함된 안정적인 MQTT 퍼블리셔
    지수 백오프(Exponential Backoff) 방식으로 재연결 시도
    """
    
    def __init__(self, broker_host, broker_port, client_id, topic):
        self.broker_host = broker_host
        self.broker_port = broker_port
        self.client_id = client_id
        self.topic = topic
        self.is_connected = False
        self.reconnect_delay = 1      # 초기 재연결 대기 시간 (초)
        self.max_reconnect_delay = 60 # 최대 재연결 대기 시간 (초)
        self.message_queue = []       # 오프라인 중 쌓인 메시지 큐
        self.max_queue_size = 100     # 최대 큐 크기
        
        self.client = mqtt.Client(client_id=client_id)
        self.client.on_connect = self._on_connect
        self.client.on_disconnect = self._on_disconnect
        self.client.on_publish = self._on_publish
        
    def _on_connect(self, client, userdata, flags, rc):
        if rc == 0:
            self.is_connected = True
            self.reconnect_delay = 1  # 성공 시 딜레이 리셋
            print(f"✅ [{datetime.now().strftime('%H:%M:%S')}] 연결 성공!")
            
            # 오프라인 중 쌓인 메시지 처리
            self._flush_queue()
        else:
            print(f"❌ 연결 실패. RC: {rc}")
    
    def _on_disconnect(self, client, userdata, rc):
        self.is_connected = False
        if rc != 0:
            print(f"⚠️ 예상치 못한 연결 해제. {self.reconnect_delay}초 후 재연결...")
            threading.Thread(target=self._reconnect, daemon=True).start()
    
    def _on_publish(self, client, userdata, mid):
        pass  # 발행 완료 처리
    
    def _reconnect(self):
        """지수 백오프 방식 재연결"""
        while not self.is_connected:
            try:
                self.client.reconnect()
                break
            except Exception as e:
                print(f"🔄 재연결 실패: {e}. {self.reconnect_delay}초 후 재시도...")
                time.sleep(self.reconnect_delay)
                # 지수 백오프: 1 → 2 → 4 → 8 → ... → 60초
                self.reconnect_delay = min(
                    self.reconnect_delay * 2,
                    self.max_reconnect_delay
                )
    
    def _flush_queue(self):
        """오프라인 중 쌓인 메시지 일괄 전송"""
        if self.message_queue:
            print(f"📦 큐에 쌓인 {len(self.message_queue)}개 메시지 전송 중...")
            while self.message_queue and self.is_connected:
                msg = self.message_queue.pop(0)
                self.client.publish(self.topic, msg, qos=1)
                time.sleep(0.1)  # 브로커 과부하 방지
    
    def publish(self, data: dict):
        """데이터 발행 (오프라인 시 큐에 저장)"""
        payload = json.dumps(data, ensure_ascii=False)
        
        if self.is_connected:
            result = self.client.publish(self.topic, payload, qos=1)
            return result.rc == mqtt.MQTT_ERR_SUCCESS
        else:
            # 오프라인 상태: 큐에 저장
            if len(self.message_queue) < self.max_queue_size:
                self.message_queue.append(payload)
                print(f"📥 오프라인 큐 저장. 현재 큐 크기: {len(self.message_queue)}")
            else:
                print("⚠️ 큐 가득 참! 가장 오래된 메시지 삭제")
                self.message_queue.pop(0)
                self.message_queue.append(payload)
            return False
    
    def connect(self):
        self.client.connect(self.broker_host, self.broker_port, keepalive=60)
        self.client.loop_start()
    
    def disconnect(self):
        self.client.loop_stop()
        self.client.disconnect()

# 사용 예시
publisher = RobustMQTTPublisher(
    broker_host="broker.example.com",
    broker_port=1883,
    client_id="sensor_001",
    topic="sensors/data"
)
publisher.connect()

# 데이터 전송
publisher.publish({
    "temperature": 25.3,
    "humidity": 60.5,
    "timestamp": datetime.utcnow().isoformat() + "Z"
})

# AWS CLI로 IoT Thing 생성 및 인증서 발급
# (AWS CLI 설치 및 자격증명 설정 필요)

# 1. Thing 생성
aws iot create-thing --thing-name "MySensor001"

# 2. 인증서 생성 및 활성화
aws iot create-keys-and-certificate \
    --set-as-active \
    --certificate-pem-outfile "device.cert.pem" \
    --public-key-outfile "device.public.key" \
    --private-key-outfile "device.private.key"

# 3. 정책 생성 (JSON 파일로 저장 후 실행)
# iot-policy.json 내용:
# {
#   "Version": "2012-10-17",
#   "Statement": [{
#     "Effect": "Allow",
#     "Action": ["iot:Connect", "iot:Publish", "iot:Subscribe", "iot:Receive"],
#     "Resource": ["arn:aws:iot:ap-northeast-2:*:*"]
#   }]
# }

aws iot create-policy \
    --policy-name "SensorPolicy" \
    --policy-document file://iot-policy.json

# 4. 정책을 인증서에 연결
aws iot attach-policy \
    --policy-name "SensorPolicy" \
    --target "arn:aws:iot:ap-northeast-2:123456789:cert/your-cert-id"

# 5. 인증서를 Thing에 연결
aws iot attach-thing-principal \
    --thing-name "MySensor001" \
    --principal "arn:aws:iot:ap-northeast-2:123456789:cert/your-cert-id"

# 6. AWS IoT 엔드포인트 확인
aws iot describe-endpoint --endpoint-type iot:Data-ATS
# 결과: "xxxxx-ats.iot.ap-northeast-2.amazonaws.com"

"""
AWS IoT Core MQTT 연결 및 데이터 업로드
필요 라이브러리: pip install awsiotsdk
"""

from awscrt import mqtt
from awsiot import mqtt_connection_builder
import json
import time
import threading
from datetime import datetime

# ===== AWS IoT 설정 =====
ENDPOINT = "xxxxx-ats.iot.ap-northeast-2.amazonaws.com"
CLIENT_ID = "MySensor001"
TOPIC = "sensors/MySensor001/data"
CERT_FILEPATH = "./certs/device.cert.pem"
PRI_KEY_FILEPATH = "./certs/device.private.key"
CA_FILEPATH = "./certs/AmazonRootCA1.pem"  # AWS 루트 CA 인증서

# 연결 완료 이벤트
connected_future = threading.Event()
disconnect_future = threading.Event()

def on_connection_interrupted(connection, error, **kwargs):
    """연결 중단 콜백"""
    print(f"⚠️ 연결 중단: {error}")

def on_connection_resumed(connection, return_code, session_present, **kwargs):
    """연결 재개 콜백"""
    print(f"✅ 연결 재개. 세션 유지: {session_present}")

def on_connection_success(connection, callback_data):
    """연결 성공 콜백"""
    print(f"🎉 AWS IoT Core 연결 성공!")
    connected_future.set()

def on_connection_failure(connection, callback_data):
    """연결 실패 콜백"""
    print(f"❌ 연결 실패: {callback_data.error}")

def on_connection_closed(connection, callback_data):
    """연결 종료 콜백"""
    print("👋 연결 종료")
    disconnect_future.set()

# ===== MQTT 연결 빌드 =====
mqtt_connection = mqtt_connection_builder.mtls_from_path(
    endpoint=ENDPOINT,
    port=8883,
    cert_filepath=CERT_FILEPATH,
    pri_key_filepath=PRI_KEY_FILEPATH,
    ca_filepath=CA_FILEPATH,
    client_id=CLIENT_ID,
    clean_session=False,  # 세션 유지 (QoS 1 메시지 보장)
    keep_alive_secs=30,
    on_connection_interrupted=on_connection_interrupted,
    on_connection_resumed=on_connection_resumed,
    on_connection_success=on_connection_success,
    on_connection_failure=on_connection_failure,
    on_connection_closed=on_connection_closed
)

print(f"🔌 AWS IoT Core 연결 중... ({ENDPOINT})")
connect_future = mqtt_connection.connect()
connect_future.result()  # 연결 완료까지 대기

print("✅ 연결 완료! 데이터 전송 시작")

# ===== 센서 데이터 전송 =====
def send_sensor_data(temperature, humidity, pressure):
    """센서 데이터를 AWS IoT Core로 전송"""
    payload = {
        "device_id": CLIENT_ID,
        "timestamp": datetime.utcnow().isoformat() + "Z",
        "location": {
            "building": "A동",
            "floor": 3,
            "room": "서버실"
        },
        "sensors": {
            "temperature": {
                "value": temperature,
                "unit": "celsius"
            },
            "humidity": {
                "value": humidity,
                "unit": "percent"
            },
            "pressure": {
                "value": pressure,
                "unit": "hPa"
            }
        },
        "metadata": {
            "firmware_version": "1.2.3",
            "battery_level": 85,
            "signal_strength": -65
        }
    }
    
    message_json = json.dumps(payload, ensure_ascii=False)
    
    # MQTT 발행
    publish_future, packet_id = mqtt_connection.publish(
        topic=TOPIC,
        payload=message_json,
        qos=mqtt.QoS.AT_LEAST_ONCE  # QoS 1
    )
    
    publish_future.result()  # 발행 완료 대기
    print(f"📤 전송 완료 (패킷 ID: {packet_id}): {temperature}°C, {humidity}%")

# ===== 디바이스 섀도우 업데이트 =====
def update_device_shadow(state: dict):
    """
    AWS IoT 디바이스 섀도우 업데이트
    섀도우: 디바이스의 현재 상태를 클라우드에 저장하는 기능
    오프라인 디바이스의 상태도 클라우드에서 확인 가능
    """
    shadow_topic = f"$aws/things/{CLIENT_ID}/shadow/update"
    shadow_payload = {
        "state": {
            "reported": state  # 디바이스가 실제로 보고하는 상태
        }
    }
    
    mqtt_connection.publish(
        topic=shadow_topic,
        payload=json.dumps(shadow_payload),
        qos=mqtt.QoS.AT_LEAST_ONCE
    )
    print(f"🔄 디바이스 섀도우 업데이트 완료")

# 메인 루프
try:
    import random
    while True:
        temp = round(random.uniform(18.0, 35.0), 2)
        hum = round(random.uniform(30.0, 80.0), 2)
        pres = round(random.uniform(1000.0, 1020.0), 2)
        
        send_sensor_data(temp, hum, pres)
        
        # 섀도우도 주기적으로 업데이트
        update_device_shadow({
            "temperature": temp,
            "humidity": hum,
            "status": "active"
        })
        
        time.sleep(10)

except KeyboardInterrupt:
    print("\n⛔ 종료 중...")
    disconnect_future_result = mqtt_connection.disconnect()
    disconnect_future_result.result()
    print("✅ 정상 종료")

"""
Firebase Realtime Database / Firestore IoT 데이터 업로드
pip install firebase-admin
"""

import firebase_admin
from firebase_admin import credentials, db, firestore
import json
import time
from datetime import datetime
import random

# ===== Firebase 초기화 =====
# Firebase 콘솔에서 서비스 계정 키 다운로드 필요
cred = credentials.Certificate("./firebase-service-account.json")

firebase_admin.initialize_app(cred, {
    'databaseURL': 'https://your-project-id-default-rtdb.firebaseio.com/'
})

# Firestore 클라이언트
firestore_db = firestore.client()

# ===== Realtime Database 업로드 =====
def upload_to_realtime_db(device_id: str, sensor_data: dict):
    """
    Firebase Realtime Database에 센서 데이터 업로드
    구조: /devices/{device_id}/latest 에 최신 데이터 저장
          /devices/{device_id}/history/{timestamp} 에 이력 저장
    """
    ref = db.reference(f'/devices/{device_id}')
    
    # 최신 데이터 업데이트 (덮어쓰기)
    ref.child('latest').set(sensor_data)
    
    # 이력 데이터 추가 (타임스탬프를 키로 사용)
    timestamp_key = datetime.utcnow().strftime('%Y%m%d_%H%M%S_%f')
    ref.child('history').child(timestamp_key).set(sensor_data)
    
    print(f"✅ Realtime DB 업로드 완료: {device_id}")

# ===== Firestore 업로드 =====
def upload_to_firestore(device_id: str, sensor_data: dict):
    """
    Firestore에 센서 데이터 업로드
    컬렉션: sensor_readings
    문서: 자동 ID 생성
    """
    # 타임스탬프 추가
    sensor_data['created_at'] = firestore.SERVER_TIMESTAMP
    sensor_data['device_id'] = device_id
    
    # 컬렉션에 문서 추가
    doc_ref = firestore_db.collection('sensor_readings').add(sensor_data)
    print(f"✅ Firestore 업로드 완료. 문서 ID: {doc_ref[1].id}")
    
    # 디바이스 상태 문서 업데이트 (upsert)
    device_ref = firestore_db.collection('devices').document(device_id)
    device_ref.set({
        'last_seen': firestore.SERVER_TIMESTAMP,
        'latest_data': sensor_data,
        'status': 'online'
    }, merge=True)  # merge=True: 기존 필드 유지하면서 업데이트

# ===== 배치 업로드 (여러 센서 동시 처리) =====
def batch_upload_to_firestore(readings: list):
    """
    여러 센서 데이터를 배치로 한 번에 업로드
    Firestore 배치 쓰기: 최대 500개 문서 동시 처리
    """
    batch = firestore_db.batch()
    collection_ref = firestore_db.collection('sensor_readings')
    
    for reading in readings[:500]:  # 최대 500개 제한
        doc_ref = collection_ref.document()  # 자동 ID
        reading['created_at'] = firestore.SERVER_TIMESTAMP
        batch.set(doc_ref, reading)
    
    batch.commit()
    print(f"✅ 배치 업로드 완료: {len(readings)}개 문서")

# ===== 실시간 리스너 (클라우드 → 디바이스 명령 수신) =====
def setup_command_listener(device_id: str):
    """
    Firestore에서 디바이스 명령을 실시간으로 수신
    클라우드에서 디바이스를 원격 제어할 때 사용
    """
    def on_snapshot(doc_snapshot, changes, read_time):
        for change in changes:
            if change.type.name == 'ADDED' or change.type.name == 'MODIFIED':
                command = change.document.to_dict()
                print(f"📩 명령 수신: {command}")
                
                # 명령 처리
                if command.get('action') == 'reboot':
                    print("🔄 재부팅 명령 실행!")
                elif command.get('action') == 'update_interval':
                    new_interval = command.get('interval', 10)
                    print(f"⏱️ 전송 주기 변경: {new_interval}초")
                
                # 명령 처리 완료 표시
                change.document.reference.update({
                    'status': 'executed',
                    'executed_at': firestore.SERVER_TIMESTAMP
                })
    
    # 명령 컬렉션 구독
    commands_ref = firestore_db.collection('devices').document(device_id)\
                               .collection('commands')\
                               .where('status', '==', 'pending')
    
    watch = commands_ref.on_snapshot(on_snapshot)
    return watch

# ===== 메인 실행 =====
DEVICE_ID = "sensor_001"

# 명령 리스너 시작
command_watcher = setup_command_listener(DEVICE_ID)

print("🚀 Firebase 데이터 업로드 시작!")

try:
    while True:
        sensor_data = {
            "temperature": round(random.uniform(18.0, 35.0), 2),
            "humidity": round(random.uniform(30.0, 80.0), 2),
            "co2": round(random.uniform(400, 1200), 0),
            "lux": round(random.uniform(0, 1000), 1),
            "timestamp": datetime.utcnow().isoformat() + "Z"
        }
        
        # Realtime DB와 Firestore 동시 업로드
        upload_to_realtime_db(DEVICE_ID, sensor_data)
        upload_to_firestore(DEVICE_ID, sensor_data)
        
        time.sleep(10)

except KeyboardInterrupt:
    command_watcher.unsubscribe()
    print("✅ 종료 완료")

"""
Azure IoT Hub 데이터 업로드
pip install azure-iot-device
"""

import asyncio
import json
import random
from datetime import datetime
from azure.iot.device.aio import IoTHubDeviceClient
from azure.iot.device import Message

# ===== Azure IoT Hub 연결 문자열 =====
# Azure 포털 → IoT Hub → 디바이스 → 연결 문자열 복사
CONNECTION_STRING = "HostName=your-hub.azure-devices.net;DeviceId=MySensor001;SharedAccessKey=your-key=="

# ===== 직접 메서드 핸들러 (클라우드 → 디바이스 명령) =====
async def method_request_handler(method_request):
    """
    Azure IoT Hub 직접 메서드 수신 핸들러
    클라우드에서 디바이스로 직접 함수를 호출하는 기능
    """
    print(f"📩 직접 메서드 수신: {method_request.name}")
    print(f"   페이로드: {method_request.payload}")
    
    if method_request.name == "reboot":
        print("🔄 재부팅 명령 실행!")
        response_payload = {"result": "reboot_initiated", "status": "success"}
        status_code = 200
        
    elif method_request.name == "get_status":
        response_payload = {
            "device_id": "MySensor001",
            "uptime": 3600,
            "firmware": "v1.2.3",
            "status": "healthy"
        }
        status_code = 200
        
    elif method_request.name == "set_interval":
        new_interval = method_request.payload.get("interval", 10)
        print(f"⏱️ 전송 주기 변경: {new_interval}초")
        response_payload = {"result": f"interval_set_to_{new_interval}s"}
        status_code = 200
        
    else:
        response_payload = {"error": "unknown_method"}
        status_code = 404
    
    # 응답 반환
    from azure.iot.device import MethodResponse
    method_response = MethodResponse.create_from_method_request(
        method_request, status_code, response_payload
    )
    await client.send_method_response(method_response)

# ===== 트윈 패치 핸들러 (원하는 속성 수신) =====
async def twin_patch_handler(patch):
    """
    Azure IoT 디바이스 트윈의 desired 속성 변경 수신
    클라우드에서 디바이스 설정을 원격으로 변경할 때 사용
    """
    print(f"🔧 트윈 패치 수신: {patch}")
    
    if "telemetry_interval" in patch:
        print(f"⏱️ 텔레메트리 주기 변경: {patch['telemetry_interval']}초")
    
    if "threshold" in patch:
        print(f"🌡️ 임계값 변경: {patch['threshold']}")
    
    # reported 속성 업데이트 (설정 적용 확인)
    reported_patch = {
        "telemetry_interval": patch.get("telemetry_interval", 10),
        "last_config_update": datetime.utcnow().isoformat() + "Z"
    }
    await client.patch_twin_reported_properties(reported_patch)

# ===== 메인 비동기 함수 =====
async def main():
    global client
    
    # 클라이언트 생성 및 연결
    client = IoTHubDeviceClient.create_from_connection_string(CONNECTION_STRING)
    
    # 핸들러 등록
    client.on_method_request_received = method_request_handler
    client.on_twin_desired_properties_patch_received = twin_patch_handler
    
    await client.connect()
    print("✅ Azure IoT Hub 연결 완료!")
    
    # 초기 트윈 reported 속성 설정
    await client.patch_twin_reported_properties({
        "firmware_version": "1.2.3",
        "hardware_version": "rev_B",
        "startup_time": datetime.utcnow().isoformat() + "Z",
        "capabilities": ["temperature", "humidity", "pressure"]
    })
    
    try:
        while True:
            # 센서 데이터 생성
            temperature = round(random.uniform(18.0, 35.0), 2)
            humidity = round(random.uniform(30.0, 80.0), 2)
            
            # Azure IoT Hub 메시지 생성
            telemetry = {
                "temperature": temperature,
                "humidity": humidity,
                "timestamp": datetime.utcnow().isoformat() + "Z"
            }
            
            message = Message(json.dumps(telemetry))
            
            # 메시지 속성 설정 (라우팅에 활용)
            message.content_encoding = "utf-8"
            message.content_type = "application/json"
            
            # 커스텀 속성 추가 (IoT Hub 메시지 라우팅 조건으로 사용 가능)
            message.custom_properties["device_type"] = "temperature_sensor"
            message.custom_properties["location"] = "building_A"
            
            # 온도 임계값 초과 시 알람 속성 추가
            if temperature > 30.0:
                message.custom_properties["alert"] = "high_temperature"
                print(f"🚨 고온 경보! {temperature}°C")
            
            # 메시지 전송
            await client.send_message(message)
            print(f"📤 Azure IoT Hub 전송: {temperature}°C, {humidity}%")
            
            await asyncio.sleep(10)
            
    except KeyboardInterrupt:
        print("\n⛔ 종료 중...")
    finally:
        await client.disconnect()
        print("✅ 연결 종료")

# 실행
asyncio.run(main())

/*
 * ESP32 IoT 센서 데이터 HTTP 업로드
 * 필요 라이브러리:
 * - WiFi (내장)
 * - HTTPClient (내장)
 * - ArduinoJson (라이브러리 매니저에서 설치)
 * - DHT sensor library (온습도 센서용)
 */

#include <WiFi.h>
#include <HTTPClient.h>
#include <ArduinoJson.h>
#include <DHT.h>
#include <time.h>

// ===== WiFi 설정 =====
const char* WIFI_SSID = "your_wifi_ssid";
const char* WIFI_PASSWORD = "your_wifi_password";

// ===== 서버 설정 =====
const char* SERVER_URL = "https://api.yourserver.com/v1/sensors/data";
const char* API_KEY = "your_api_key_here";
const char* DEVICE_ID = "esp32_sensor_001";

// ===== 센서 설정 =====
#define DHT_PIN 4
#define DHT_TYPE DHT22
DHT dht(DHT_PIN, DHT_TYPE);

// ===== 전송 주기 =====
const unsigned long SEND_INTERVAL = 30000;  // 30초
unsigned long lastSendTime = 0;

// ===== WiFi 연결 함수 =====
void connectWiFi() {
    Serial.print("WiFi 연결 중: ");
    Serial.println(WIFI_SSID);
    
    WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
    
    int attempts = 0;
    while (WiFi.status() != WL_CONNECTED && attempts < 30) {
        delay(1000);
        Serial.print(".");
        attempts++;
    }
    
    if (WiFi.status() == WL_CONNECTED) {
        Serial.println("\n✅ WiFi 연결 성공!");
        Serial.print("IP 주소: ");
        Serial.println(WiFi.localIP());
    } else {
        Serial.println("\n❌ WiFi 연결 실패. 재시작...");
        ESP.restart();
    }
}

// ===== NTP 시간 동기화 =====
void syncTime() {
    configTime(9 * 3600, 0, "pool.ntp.org", "time.nist.gov");
    Serial.print("시간 동기화 중");
    
    struct tm timeinfo;
    while (!getLocalTime(&timeinfo)) {
        Serial.print(".");
        delay(500);
    }
    Serial.println("\n✅ 시간 동기화 완료");
}

// ===== ISO 8601 타임스탬프 생성 =====
String getTimestamp() {
    struct tm timeinfo;
    if (!getLocalTime(&timeinfo)) {
        return "1970-01-01T00:00:00Z";
    }
    
    char timestamp[30];
    strftime(timestamp, sizeof(timestamp), "%Y-%m-%dT%H:%M:%SZ", &timeinfo);
    return String(timestamp);
}

// ===== HTTP POST 데이터 전송 =====
bool sendSensorData(float temperature, float humidity) {
    if (WiFi.status() != WL_CONNECTED) {
        Serial.println("⚠️ WiFi 연결 끊김. 재연결...");
        connectWiFi();
        return false;
    }
    
    HTTPClient http;
    
    // HTTPS 연결 설정
    http.begin(SERVER_URL);
    http.addHeader("Content-Type", "application/json");
    http.addHeader("X-API-Key", API_KEY);
    http.addHeader("X-Device-ID", DEVICE_ID);
    http.setTimeout(10000);  // 10초 타임아웃
    
    // JSON 페이로드 생성
    StaticJsonDocument<512> doc;
    doc["device_id"] = DEVICE_ID;
    doc["timestamp"] = getTimestamp();
    
    JsonObject sensors = doc.createNestedObject("sensors");
    sensors["temperature"] = round(temperature * 100) / 100.0;
    sensors["humidity"] = round(humidity * 100) / 100.0;
    
    JsonObject meta = doc.createNestedObject("metadata");
    meta["wifi_rssi"] = WiFi.RSSI();
    meta["free_heap"] = ESP.getFreeHeap();
    meta["uptime"] = millis() / 1000;
    
    String payload;
    serializeJson(doc, payload);
    
    Serial.println("📤 전송 중: " + payload);
    
    // POST 요청
    int httpCode = http.POST(payload);
    
    if (httpCode > 0) {
        String response = http.getString();
        Serial.printf("✅ HTTP 응답: %d\n", httpCode);
        Serial.println("응답 본문: " + response);
        http.end();
        return httpCode == 200 || httpCode == 201;
    } else {
        Serial.printf("❌ HTTP 오류: %s\n", http.errorToString(httpCode).c_str());
        http.end();
        return false;
    }
}

// ===== 재시도 로직 포함 전송 =====
void sendWithRetry(float temperature, float humidity, int maxRetries = 3) {
    for (int i = 0; i < maxRetries; i++) {
        if (sendSensorData(temperature, humidity)) {
            return;  // 성공
        }
        
        Serial.printf("⚠️ 전송 실패. %d/%d 재시도...\n", i + 1, maxRetries);
        delay(2000 * (i + 1));  // 점진적 대기
    }
    
    Serial.println("❌ 최대 재시도 횟수 초과. 데이터 유실");
    // 실제 환경에서는 SPIFFS/LittleFS에 로컬 저장 후 나중에 재전송
}

// ===== 딥슬립 모드 (배터리 절약) =====
void enterDeepSleep(int seconds) {
    Serial.printf("💤 딥슬립 진입: %d초\n", seconds);
    esp_sleep_enable_timer_wakeup(seconds * 1000000ULL);  // 마이크로초 단위
    esp_deep_sleep_start();
}

// ===== Setup =====
void setup() {
    Serial.begin(115200);
    Serial.println("\n🚀 ESP32 IoT 센서 시작!");
    
    dht.begin();
    connectWiFi();
    syncTime();
    
    Serial.println("✅ 초기화 완료");
}

// ===== Loop =====
void loop() {
    unsigned long currentTime = millis();
    
    if (currentTime - lastSendTime >= SEND_INTERVAL) {
        // 센서 읽기
        float humidity = dht.readHumidity();
        float temperature = dht.readTemperature();
        
        // 센서 읽기 실패 체크
        if (isnan(humidity) || isnan(temperature)) {
            Serial.println("❌ 센서 읽기 실패!");
        } else {
            Serial.printf("🌡️ 온도: %.2f°C, 💧 습도: %.2f%%\n", temperature, humidity);
            sendWithRetry(temperature, humidity);
        }
        
        lastSendTime = currentTime;
    }
    
    // 배터리 구동 시 딥슬립 사용 (아래 주석 해제)
    // sendWithRetry(temperature, humidity);
    // enterDeepSleep(30);  // 30초 슬립 후 깨어남
}

/*
 * ESP32 MQTT 데이터 업로드 (PubSubClient 라이브러리)
 * 라이브러리 매니저에서 "PubSubClient" 설치 필요
 */

#include <WiFi.h>
#include <PubSubClient.h>
#include <ArduinoJson.h>
#include <WiFiClientSecure.h>

const char* WIFI_SSID = "your_ssid";
const char* WIFI_PASSWORD = "your_password";

// MQTT 브로커 설정 (HiveMQ Cloud 예시)
const char* MQTT_BROKER = "your-cluster.hivemq.cloud";
const int MQTT_PORT = 8883;  // TLS 포트
const char* MQTT_USER = "your_username";
const char* MQTT_PASSWORD = "your_password";
const char* MQTT_CLIENT_ID = "esp32_001";
const char* MQTT_TOPIC = "sensors/esp32_001/data";

// HiveMQ Cloud 루트 CA 인증서
const char* ROOT_CA = \
"-----BEGIN CERTIFICATE-----\n" \
"MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw\n" \
"... (실제 인증서 내용) ...\n" \
"-----END CERTIFICATE-----\n";

WiFiClientSecure espClient;
PubSubClient mqttClient(espClient);

// MQTT 메시지 수신 콜백 (구독 시 사용)
void mqttCallback(char* topic, byte* payload, unsigned int length) {
    String message = "";
    for (int i = 0; i < length; i++) {
        message += (char)payload[i];
    }
    
    Serial.println("📩 수신 토픽: " + String(topic));
    Serial.println("   메시지: " + message);
    
    // JSON 파싱
    StaticJsonDocument<256> doc;
    DeserializationError error = deserializeJson(doc, message);
    
    if (!error) {
        if (doc.containsKey("command")) {
            String cmd = doc["command"].as<String>();
            if (cmd == "reboot") {
                Serial.println("🔄 재부팅 명령!");
                delay(1000);
                ESP.restart();
            }
        }
    }
}

void reconnectMQTT() {
    int retries = 0;
    while (!mqttClient.connected() && retries < 5) {
        Serial.print("MQTT 연결 시도...");
        
        if (mqttClient.connect(MQTT_CLIENT_ID, MQTT_USER, MQTT_PASSWORD)) {
            Serial.println("✅ 연결 성공!");
            
            // 명령 수신을 위한 구독
            String cmdTopic = "sensors/" + String(MQTT_CLIENT_ID) + "/commands";
            mqttClient.subscribe(cmdTopic.c_str());
            
        } else {
            Serial.printf("❌ 실패. 상태: %d. 5초 후 재시도...\n", mqttClient.state());
            delay(5000);
            retries++;
        }
    }
}

void setup() {
    Serial.begin(115200);
    
    WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
    while (WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.print(".");
    }
    Serial.println("\n✅ WiFi 연결!");
    
    // TLS 설정
    espClient.setCACert(ROOT_CA);
    
    mqttClient.setServer(MQTT_BROKER, MQTT_PORT);
    mqttClient.setCallback(mqttCallback);
    mqttClient.setBufferSize(1024);  // 버퍼 크기 증가
    
    reconnectMQTT();
}

void loop() {
    if (!mqttClient.connected()) {
        reconnectMQTT();
    }
    mqttClient.loop();
    
    static unsigned long lastMsg = 0;
    if (millis() - lastMsg > 10000) {
        lastMsg = millis();
        
        // JSON 페이로드
        StaticJsonDocument<256> doc;
        doc["device_id"] = MQTT_CLIENT_ID;
        doc["temperature"] = 25.3;
        doc["humidity"] = 60.5;
        doc["uptime"] = millis() / 1000;
        
        char payload[256];
        serializeJson(doc, payload);
        
        if (mqttClient.publish(MQTT_TOPIC, payload, true)) {
            Serial.println("📤 MQTT 전송 완료: " + String(payload));
        } else {
            Serial.println("❌ MQTT 전송 실패");
        }
    }
}

/**
 * Node.js IoT 게이트웨이 서버
 * 여러 센서에서 데이터 수집 → 처리 → 클라우드 업로드
 * 
 * npm install mqtt axios winston node-cron
 */

const mqtt = require('mqtt');
const axios = require('axios');
const winston = require('winston');
const cron = require('node-cron');

// ===== 로거 설정 =====
const logger = winston.createLogger({
    level: 'info',
    format: winston.format.combine(
        winston.format.timestamp(),
        winston.format.colorize(),
        winston.format.printf(({ timestamp, level, message }) => {
            return `[${timestamp}] ${level}: ${message}`;
        })
    ),
    transports: [
        new winston.transports.Console(),
        new winston.transports.File({ filename: 'gateway.log' })
    ]
});

// ===== 설정 =====
const CONFIG = {
    mqtt: {
        broker: 'mqtt://localhost:1883',
        topics: ['sensors/#'],  // 모든 센서 토픽 구독
        clientId: 'gateway_server_001'
    },
    cloud: {
        endpoint: 'https://api.yourcloud.com/v1/telemetry',
        apiKey: process.env.CLOUD_API_KEY,
        batchSize: 50,          // 배치 크기
        flushInterval: 5000     // 5초마다 배치 전송
    }
};

// ===== 데이터 버퍼 (배치 처리용) =====
class DataBuffer {
    constructor(maxSize, flushInterval, flushCallback) {
        this.buffer = [];
        this.maxSize = maxSize;
        this.flushCallback = flushCallback;
        
        // 주기적 플러시
        setInterval(() => {
            if (this.buffer.length > 0) {
                this.flush();
            }
        }, flushInterval);
    }
    
    add(data) {
        this.buffer.push(data);
        
        // 버퍼 가득 차면 즉시 플러시
        if (this.buffer.length >= this.maxSize) {
            this.flush();
        }
    }
    
    flush() {
        if (this.buffer.length === 0) return;
        
        const batch = [...this.buffer];
        this.buffer = [];
        
        this.flushCallback(batch).catch(err => {
            logger.error(`배치 전송 실패: ${err.message}`);
            // 실패한 데이터 다시 버퍼에 추가 (재시도)
            this.buffer.unshift(...batch);
        });
    }
}

// ===== 데이터 검증 및 정제 =====
function validateAndClean(rawData) {
    const required = ['device_id', 'timestamp'];
    
    for (const field of required) {
        if (!rawData[field]) {
            throw new Error(`필수 필드 누락: ${field}`);
        }
    }
    
    // 온도 범위 검증 (-50°C ~ 100°C)
    if (rawData.temperature !== undefined) {
        if (rawData.temperature < -50 || rawData.temperature > 100) {
            throw new Error(`온도 범위 초과: ${rawData.temperature}`);
        }
    }
    
    // 습도 범위 검증 (0% ~ 100%)
    if (rawData.humidity !== undefined) {
        if (rawData.humidity < 0 || rawData.humidity > 100) {
            throw new Error(`습도 범위 초과: ${rawData.humidity}`);
        }
    }
    
    // 타임스탬프 정규화
    const ts = new Date(rawData.timestamp);
    if (isNaN(ts.getTime())) {
        rawData.timestamp = new Date().toISOString();
    }
    
    // 게이트웨이 메타데이터 추가
    rawData.gateway_id = CONFIG.mqtt.clientId;
    rawData.received_at = new Date().toISOString();
    
    return rawData;
}

// ===== 클라우드 배치 업로드 =====
async function uploadBatch(batch) {
    const payload = {
        batch_id: `batch_${Date.now()}`,
        count: batch.length,
        data: batch
    };
    
    const response = await axios.post(CONFIG.cloud.endpoint, payload, {
        headers: {
            'Content-Type': 'application/json',
            'X-API-Key': CONFIG.cloud.apiKey,
            'X-Gateway-ID': CONFIG.mqtt.clientId
        },
        timeout: 30000  // 30초 타임아웃
    });
    
    logger.info(`✅ 배치 업로드 완료: ${batch.length}개 → HTTP ${response.status}`);
    return response.data;
}

// ===== 재시도 래퍼 =====
async function withRetry(fn, maxRetries = 3, delay = 1000) {
    for (let i = 0; i < maxRetries; i++) {
        try {
            return await fn();
        } catch (error) {
            if (i === maxRetries - 1) throw error;
            logger.warn(`재시도 ${i + 1}/${maxRetries}: ${error.message}`);
            await new Promise(resolve => setTimeout(resolve, delay * Math.pow(2, i)));
        }
    }
}

// ===== 통계 수집 =====
const stats = {
    received: 0,
    processed: 0,
    failed: 0,
    uploaded: 0
};

// 1분마다 통계 출력
cron.schedule('* * * * *', () => {
    logger.info(`📊 통계 | 수신: ${stats.received} | 처리: ${stats.processed} | 실패: ${stats.failed} | 업로드: ${stats.uploaded}`);
});

// ===== 메인 게이트웨이 =====
const dataBuffer = new DataBuffer(
    CONFIG.cloud.batchSize,
    CONFIG.cloud.flushInterval,
    (batch) => withRetry(() => uploadBatch(batch))
);

// MQTT 클라이언트 연결
const mqttClient = mqtt.connect(CONFIG.mqtt.broker, {
    clientId: CONFIG.mqtt.clientId,
    clean: false,
    reconnectPeriod: 5000,
    connectTimeout: 30000
});

mqttClient.on('connect', () => {
    logger.info('✅ MQTT 브로커 연결 완료');
    
    // 모든 센서 토픽 구독
    CONFIG.mqtt.topics.forEach(topic => {
        mqttClient.subscribe(topic, { qos: 1 }, (err) => {
            if (!err) logger.info(`📡 구독 시작: ${topic}`);
        });
    });
});

mqttClient.on('message', (topic, message) => {
    stats.received++;
    
    try {
        const rawData = JSON.parse(message.toString());
        const cleanData = validateAndClean(rawData);
        
        dataBuffer.add(cleanData);
        stats.processed++;
        
        logger.debug(`📥 수신: ${topic} → ${cleanData.device_id}`);
        
    } catch (error) {
        stats.failed++;
        logger.error(`❌ 데이터 처리 실패 [${topic}]: ${error.message}`);
    }
});

mqttClient.on('error', (error) => {
    logger.error(`MQTT 오류: ${error.message}`);
});

mqttClient.on('reconnect', () => {
    logger.warn('🔄 MQTT 재연결 중...');
});

logger.info('🚀 IoT 게이트웨이 서버 시작!');

"""
민감 정보를 코드에 하드코딩하면 절대 안 됩니다!
.env 파일과 python-dotenv를 사용하세요.
"""

# .env 파일 (절대 Git에 커밋하지 마세요!)
# .gitignore에 .env 추가 필수!
"""
AWS_IOT_ENDPOINT=xxxxx-ats.iot.ap-northeast-2.amazonaws.com
AWS_IOT_CLIENT_ID=MySensor001
MQTT_USERNAME=your_username
MQTT_PASSWORD=your_secure_password
FIREBASE_PROJECT_ID=your-project-id
AZURE_CONNECTION_STRING=HostName=...
"""

# Python 코드에서 환경변수 사용
from dotenv import load_dotenv
import os

load_dotenv()  # .env 파일 로드

AWS_ENDPOINT = os.getenv('AWS_IOT_ENDPOINT')
CLIENT_ID = os.getenv('AWS_IOT_CLIENT_ID')
MQTT_USER = os.getenv('MQTT_USERNAME')
MQTT_PASS = os.getenv('MQTT_PASSWORD')

# 환경변수 누락 체크
required_vars = ['AWS_IOT_ENDPOINT', 'AWS_IOT_CLIENT_ID', 'MQTT_USERNAME', 'MQTT_PASSWORD']
missing = [var for var in required_vars if not os.getenv(var)]
if missing:
    raise EnvironmentError(f"필수 환경변수 누락: {', '.join(missing)}")

print("✅ 환경변수 로드 완료")

# ===== HMAC 서명으로 데이터 무결성 검증 =====
import hmac
import hashlib
import base64

SECRET_KEY = os.getenv('HMAC_SECRET_KEY', 'default_secret').encode()

def sign_payload(payload: str) -> str:
    """페이로드에 HMAC-SHA256 서명 추가"""
    signature = hmac.new(SECRET_KEY, payload.encode(), hashlib.sha256).digest()
    return base64.b64encode(signature).decode()

def verify_payload(payload: str, signature: str) -> bool:
    """서명 검증"""
    expected = sign_payload(payload)
    return hmac.compare_digest(expected, signature)

# 사용 예시
import json
data = {"temperature": 25.3, "timestamp": "2024-01-01T00:00:00Z"}
payload_str = json.dumps(data, sort_keys=True)
sig = sign_payload(payload_str)

# 전송 시 서명 포함
message = {
    "payload": data,
    "signature": sig
}

# 수신 측에서 검증
is_valid = verify_payload(payload_str, sig)
print(f"서명 검증: {'✅ 유효' if is_valid else '❌ 위조 감지!'}")

"""
MessagePack으로 IoT 데이터 압축 전송
pip install msgpack
"""

import msgpack
import json
import gzip
import time

# 샘플 센서 데이터
sensor_data = {
    "device_id": "sensor_001",
    "timestamp": "2024-01-15T09:30:00Z",
    "temperature": 25.34,
    "humidity": 60.12,
    "pressure": 1013.25,
    "co2": 450,
    "lux": 320.5,
    "battery": 3.85,
    "rssi": -65
}

# ===== 크기 비교 =====
# 1. JSON (일반)
json_bytes = json.dumps(sensor_data).encode('utf-8')
print(f"JSON: {len(json_bytes)} bytes")

# 2. JSON + gzip
json_gzip = gzip.compress(json_bytes, compresslevel=6)
print(f"JSON + gzip: {len(json_gzip)} bytes ({len(json_gzip)/len(json_bytes)*100:.1f}%)")

# 3. MessagePack
msgpack_bytes = msgpack.packb(sensor_data, use_bin_type=True)
print(f"MessagePack: {len(msgpack_bytes)} bytes ({len(msgpack_bytes)/len(json_bytes)*100:.1f}%)")

# 4. MessagePack + gzip
msgpack_gzip = gzip.compress(msgpack_bytes, compresslevel=6)
print(f"MessagePack + gzip: {len(msgpack_gzip)} bytes ({len(msgpack_gzip)/len(json_bytes)*100:.1f}%)")

# ===== 배치 데이터 압축 전송 =====
def compress_batch(data_list: list) -> bytes:
    """배치 데이터를 MessagePack + gzip으로 압축"""
    packed = msgpack.packb(data_list, use_bin_type=True)
    compressed = gzip.compress(packed, compresslevel=6)
    return compressed

def decompress_batch(compressed: bytes) -> list:
    """압축 해제"""
    decompressed = gzip.decompress(compressed)
    return msgpack.unpackb(decompressed, raw=False)

# 100개 데이터 배치 압축 테스트
batch = [sensor_data.copy() for _ in range(100)]
compressed = compress_batch(batch)
original_size = len(json.dumps(batch).encode())
print(f"\n배치 100개:")
print(f"  원본 JSON: {original_size:,} bytes")
print(f"  압축 후: {len(compressed):,} bytes ({len(compressed)/original_size*100:.1f}%)")

# ===== 델타 인코딩 (변화량만 전송) =====
class DeltaEncoder:
    """
    이전 값과의 차이(델타)만 전송하는 인코더
    센서 값이 천천히 변할 때 매우 효과적
    """
    def __init__(self, threshold=0.1):
        self.last_values = {}
        self.threshold = threshold  # 변화 임계값
    
    def encode(self, device_id: str, data: dict) -> dict:
        """변화가 있는 필드만 반환"""
        if device_id not in self.last_values:
            self.last_values[device_id] = data.copy()
            return data  # 첫 번째는 전체 전송
        
        delta = {
            "device_id": device_id,
            "timestamp": data.get("timestamp"),
            "type": "delta"
        }
        
        changed = False
        for key, value in data.items():
            if key in ("device_id", "timestamp"):
                continue
            
            last_val = self.last_values[device_id].get(key)
            if last_val is None or abs(value - last_val) > self.threshold:
                delta[key] = value
                self.last_values[device_id][key] = value
                changed = True
        
        if not changed:
            return None  # 변화 없으면 전송 안 함
        
        return delta

# 사용 예시
encoder = DeltaEncoder(threshold=0.5)

readings = [
    {"device_id": "s001", "timestamp": "T1", "temperature": 25.0, "humidity": 60.0},
    {"device_id": "s001", "timestamp": "T2", "temperature": 25.1, "humidity": 60.0},  # 변화 없음
    {"device_id": "s001", "timestamp": "T3", "temperature": 25.8, "humidity": 61.2},  # 온도 변화
    {"device_id": "s001", "timestamp": "T4", "temperature": 25.9, "humidity": 61.3},  # 미세 변화
]

for reading in readings:
    delta = encoder.encode("s001", reading)
    if delta:
        print(f"📤 전송: {delta}")
    else:
        print(f"⏭️ 스킵 (변화 없음): {reading['timestamp']}")

"""
스마트홈 IoT 센서 시스템 - 완성 소스
파일 구조:
  smart_home/
  ├── config.py          # 설정 관리
  ├── sensors.py         # 센서 추상화 레이어
  ├── uploader.py        # 클라우드 업로드 모듈
  ├── local_storage.py   # 로컬 임시 저장
  └── main.py            # 메인 실행 파일
"""

# ===== config.py =====
import os
from dataclasses import dataclass
from dotenv import load_dotenv

load_dotenv()

@dataclass
class Config:
    # AWS IoT
    aws_endpoint: str = os.getenv('AWS_IOT_ENDPOINT', '')
    aws_client_id: str = os.getenv('AWS_IOT_CLIENT_ID', 'smart_home_001')
    aws_cert_path: str = os.getenv('AWS_CERT_PATH', './certs/device.cert.pem')
    aws_key_path: str = os.getenv('AWS_KEY_PATH', './certs/device.private.key')
    aws_ca_path: str = os.getenv('AWS_CA_PATH', './certs/AmazonRootCA1.pem')
    
    # 센서 설정
    send_interval: int = int(os.getenv('SEND_INTERVAL', '30'))  # 초
    
    # 로컬 저장소
    local_db_path: str = os.getenv('LOCAL_DB_PATH', './data/sensor_cache.db')
    max_local_records: int = int(os.getenv('MAX_LOCAL_RECORDS', '10000'))

config = Config()

# ===== sensors.py =====
import json
from datetime import datetime
from abc import ABC, abstractmethod

class BaseSensor(ABC):
    """센서 추상 기본 클래스"""
    
    def __init__(self, sensor_id: str, location: str):
        self.sensor_id = sensor_id
        self.location = location
    
    @abstractmethod
    def read(self) -> dict:
        """센서 값 읽기 (서브클래스에서 구현)"""
        pass
    
    def get_reading(self) -> dict:
        """표준화된 센서 데이터 반환"""
        raw = self.read()
        return {
            "sensor_id": self.sensor_id,
            "location": self.location,
            "timestamp": datetime.utcnow().isoformat() + "Z",
            "data": raw,
            "metadata": {
                "sensor_type": self.__class__.__name__,
                "firmware": "1.0.0"
            }
        }

class DHT22Sensor(BaseSensor):
    """DHT22 온습도 센서"""
    
    def __init__(self, sensor_id: str, location: str, pin: int):
        super().__init__(sensor_id, location)
        self.pin = pin
        # 실제 환경: import Adafruit_DHT
        # self.dht = Adafruit_DHT.DHT22
    
    def read(self) -> dict:
        # 실제 환경:
        # humidity, temperature = Adafruit_DHT.read_retry(self.dht, self.pin)
        import random
        return {
            "temperature": round(random.uniform(18.0, 35.0), 2),
            "humidity": round(random.uniform(30.0, 80.0), 2),
            "unit": {"temperature": "celsius", "humidity": "percent"}
        }

class MQ135Sensor(BaseSensor):
    """MQ-135 공기질 센서 (CO2, VOC)"""
    
    def __init__(self, sensor_id: str, location: str, adc_channel: int):
        super().__init__(sensor_id, location)
        self.adc_channel = adc_channel
    
    def read(self) -> dict:
        import random
        return {
            "co2_ppm": round(random.uniform(400, 1500), 0),
            "air_quality_index": random.randint(0, 500),
            "status": "good" if random.random() > 0.3 else "moderate"
        }

class SensorManager:
    """다중 센서 관리자"""
    
    def __init__(self):
        self.sensors = []
    
    def add_sensor(self, sensor: BaseSensor):
        self.sensors.append(sensor)
        return self
    
    def read_all(self) -> list:
        """모든 센서 동시 읽기"""
        import concurrent.futures
        
        readings = []
        with concurrent.futures.ThreadPoolExecutor(max_workers=len(self.sensors)) as executor:
            futures = {executor.submit(sensor.get_reading): sensor for sensor in self.sensors}
            
            for future in concurrent.futures.as_completed(futures):
                try:
                    reading = future.result(timeout=5)
                    readings.append(reading)
                except Exception as e:
                    sensor = futures[future]
                    print(f"❌ 센서 읽기 실패 [{sensor.sensor_id}]: {e}")
        
        return readings

# ===== local_storage.py =====
import sqlite3
import json
from datetime import datetime

class LocalStorage:
    """오프라인 시 로컬 SQLite 임시 저장소"""
    
    def __init__(self, db_path: str):
        self.db_path = db_path
        self._init_db()
    
    def _init_db(self):
        with sqlite3.connect(self.db_path) as conn:
            conn.execute("""
                CREATE TABLE IF NOT EXISTS sensor_cache (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    data TEXT NOT NULL,
                    created_at TEXT NOT NULL,
                    uploaded INTEGER DEFAULT 0
                )
            """)
            conn.execute("CREATE INDEX IF NOT EXISTS idx_uploaded ON sensor_cache(uploaded)")
    
    def save(self, readings: list):
        """센서 데이터 로컬 저장"""
        with sqlite3.connect(self.db_path) as conn:
            for reading in readings:
                conn.execute(
                    "INSERT INTO sensor_cache (data, created_at) VALUES (?, ?)",
                    (json.dumps(reading), datetime.utcnow().isoformat())
                )
        print(f"💾 로컬 저장: {len(readings)}개")
    
    def get_pending(self, limit: int = 100) -> list:
        """업로드 대기 중인 데이터 조회"""
        with sqlite3.connect(self.db_path) as conn:
            rows = conn.execute(
                "SELECT id, data FROM sensor_cache WHERE uploaded = 0 ORDER BY id LIMIT ?",
                (limit,)
            ).fetchall()
        
        return [(row[0], json.loads(row[1])) for row in rows]
    
    def mark_uploaded(self, ids: list):
        """업로드 완료 표시"""
        with sqlite3.connect(self.db_path) as conn:
            conn.execute(
                f"UPDATE sensor_cache SET uploaded = 1 WHERE id IN ({','.join('?' * len(ids))})",
                ids
            )
    
    def cleanup(self, keep_days: int = 7):
        """오래된 업로드 완료 데이터 삭제"""
        with sqlite3.connect(self.db_path) as conn:
            result = conn.execute(
                """DELETE FROM sensor_cache 
                   WHERE uploaded = 1 
                   AND created_at < datetime('now', ?)""",
                (f'-{keep_days} days',)
            )
            print(f"🗑️ 정리 완료: {result.rowcount}개 삭제")

# ===== main.py =====
import time
import signal
import threading
from datetime import datetime

class SmartHomeIoT:
    """스마트홈 IoT 메인 시스템"""
    
    def __init__(self):
        self.running = True
        self.sensor_manager = SensorManager()
        self.local_storage = LocalStorage('./data/cache.db')
        
        # 센서 등록
        self.sensor_manager\
            .add_sensor(DHT22Sensor("dht22_living", "거실", pin=4))\
            .add_sensor(DHT22Sensor("dht22_bedroom", "침실", pin=17))\
            .add_sensor(MQ135Sensor("mq135_kitchen", "주방", adc_channel=0))
        
        # 시그널 핸들러 (Ctrl+C 처리)
        signal.signal(signal.SIGINT, self._shutdown)
        signal.signal(signal.SIGTERM, self._shutdown)
        
        print("🏠 스마트홈 IoT 시스템 시작!")
    
    def _shutdown(self, signum, frame):
        print("\n⛔ 종료 신호 수신. 안전하게 종료 중...")
        self.running = False
    
    def _upload_pending(self):
        """로컬에 쌓인 데이터 재전송 (백그라운드)"""
        while self.running:
            pending = self.local_storage.get_pending(limit=50)
            if pending:
                print(f"📤 대기 중인 {len(pending)}개 데이터 재전송 시도...")
                # 실제 업로드 로직 (AWS IoT 등)
                ids = [item[0] for item in pending]
                self.local_storage.mark_uploaded(ids)
            
            time.sleep(60)  # 1분마다 체크
    
    def run(self):
        """메인 루프"""
        # 백그라운드 재전송 스레드
        retry_thread = threading.Thread(target=self._upload_pending, daemon=True)
        retry_thread.start()
        
        # 정기 정리 작업
        cleanup_counter = 0
        
        while self.running:
            try:
                # 모든 센서 읽기
                readings = self.sensor_manager.read_all()
                print(f"📊 {len(readings)}개 센서 데이터 수집 완료")
                
                # 로컬 저장 (백업)
                self.local_storage.save(readings)
                
                # 클라우드 업로드 (여기서 AWS IoT, Firebase 등 연동)
                # publisher.publish_batch(readings)
                
                # 7일마다 정리
                cleanup_counter += 1
                if cleanup_counter >= 20160:  # 30초 * 20160 = 7일
                    self.local_storage.cleanup(keep_days=7)
                    cleanup_counter = 0
                
                time.sleep(30)  # 30초 대기
                
            except Exception as e:
                print(f"❌ 오류 발생: {e}")
                time.sleep(5)
        
        print("✅ 시스템 종료 완료")

if __name__ == "__main__":
    system = SmartHomeIoT()
    system.run()

"""
Prometheus 메트릭 수집으로 IoT 시스템 모니터링
pip install prometheus_client
"""

from prometheus_client import Counter, Gauge, Histogram, start_http_server
import time

# ===== 메트릭 정의 =====
# 전송 성공/실패 카운터
messages_sent_total = Counter(
    'iot_messages_sent_total',
    'Total messages sent to cloud',
    ['device_id', 'status']  # 레이블
)

# 현재 센서 값 게이지
sensor_temperature = Gauge(
    'iot_sensor_temperature_celsius',
    'Current temperature reading',
    ['device_id', 'location']
)

sensor_humidity = Gauge(
    'iot_sensor_humidity_percent',
    'Current humidity reading',
    ['device_id', 'location']
)

# 전송 지연 히스토그램
upload_duration = Histogram(
    'iot_upload_duration_seconds',
    'Time spent uploading data to cloud',
    ['cloud_provider'],
    buckets=[0.1, 0.5, 1.0, 2.0, 5.0, 10.0]
)

# 연결 상태 게이지
connection_status = Gauge(
    'iot_connection_status',
    'MQTT connection status (1=connected, 0=disconnected)',
    ['broker']
)

# ===== 메트릭 업데이트 예시 =====
def record_upload(device_id: str, success: bool, duration: float, provider: str):
    """업로드 결과 기록"""
    status = 'success' if success else 'failure'
    messages_sent_total.labels(device_id=device_id, status=status).inc()
    upload_duration.labels(cloud_provider=provider).observe(duration)

def update_sensor_metrics(device_id: str, location: str, temp: float, hum: float):
    """센서 값 메트릭 업데이트"""
    sensor_temperature.labels(device_id=device_id, location=location).set(temp)
    sensor_humidity.labels(device_id=device_id, location=location).set(hum)

# Prometheus 메트릭 서버 시작 (포트 8000)
start_http_server(8000)
print("📊 Prometheus 메트릭 서버 시작: http://localhost:8000/metrics")

# 시뮬레이션
import random
while True:
    temp = random.uniform(20, 30)
    hum = random.uniform(40, 70)
    
    start = time.time()
    # 실제 업로드 로직...
    time.sleep(random.uniform(0.1, 0.5))  # 업로드 시뮬레이션
    duration = time.time() - start
    
    update_sensor_metrics("sensor_001", "거실", temp, hum)
    record_upload("sensor_001", True, duration, "aws_iot")
    connection_status.labels(broker="aws_iot_core").set(1)
    
    print(f"📊 메트릭 업데이트: {temp:.1f}°C, {hum:.1f}%")
    time.sleep(10)

"""
MQTT 연결 문제 디버깅 도구
"""

import paho.mqtt.client as mqtt
import logging

# 상세 로깅 활성화
logging.basicConfig(level=logging.DEBUG)
mqtt_logger = logging.getLogger('mqtt')
mqtt_logger.setLevel(logging.DEBUG)

def debug_mqtt_connection(broker, port, username=None, password=None):
    """MQTT 연결 문제 진단"""
    
    client = mqtt.Client()
    
    if username:
        client.username_pw_set(username, password)
    
    # 모든 이벤트 로깅
    def on_log(client, userdata, level, buf):
        print(f"[MQTT LOG] {buf}")
    
    def on_connect(client, userdata, flags, rc):
        rc_messages = {
            0: "✅ 연결 성공",
            1: "❌ 잘못된 프로토콜 버전",
            2: "❌ 클라이언트 ID 거부됨",
            3: "❌ 서버 사용 불가",
            4: "❌ 잘못된 사용자명 또는 비밀번호",
            5: "❌ 권한 없음 (인증 실패)"
        }
        print(f"연결 결과: {rc_messages.get(rc, f'알 수 없는 오류: {rc}')}")
    
    client.on_log = on_log
    client.on_connect = on_connect
    
    print(f"🔍 연결 시도: {broker}:{port}")
    
    try:
        client.connect(broker, port, keepalive=10)
        client.loop_start()
        
        import time
        time.sleep(5)  # 5초 대기
        
        client.loop_stop()
        client.disconnect()
        
    except ConnectionRefusedError:
        print(f"❌ 연결 거부됨. 브로커 주소/포트 확인: {broker}:{port}")
    except TimeoutError:
        print(f"❌ 연결 타임아웃. 방화벽 또는 네트워크 확인")
    except Exception as e:
        print(f"❌ 예상치 못한 오류: {e}")

# 사용
debug_mqtt_connection("broker.example.com", 1883, "user", "pass")