shadow_client.configureCredentials(
    root_ca_path,      # AWS 서버 검증용
    private_key_path,  # 디바이스 서명용
    cert_path         # 디바이스 신원 증명용
)

import json
import time
from AWSIoTPythonSDK.MQTTLib import AWSIoTMQTTShadowClient

# AWS IoT 설정
ENDPOINT = "your-endpoint.iot.ap-northeast-2.amazonaws.com"
CLIENT_ID = "my_device"
THING_NAME = "my_device"

# 인증서 파일 경로
CERT_PATH = "certificate.pem.crt"
PRIVATE_KEY_PATH = "private.pem.key"
ROOT_CA_PATH = "AmazonRootCA1.pem"

def shadow_callback_delta(payload, responseStatus, token):
    """desired 상태가 변경될 때 호출"""
    payload_dict = json.loads(payload)
    
    if "state" in payload_dict and "power" in payload_dict["state"]:
        desired_power = payload_dict["state"]["power"]
        print(f"원격 명령 수신: power = {desired_power}")
        
        # 실제 디바이스 상태 변경
        DEVICE_STATE["power"] = desired_power
        
        # 특별한 동작 수행
        if desired_power == "꺼짐":
            shutdown_device()

def shadow_callback_update(payload, responseStatus, token):
    """Shadow 업데이트 결과 처리"""
    if responseStatus == "accepted":
        print("Shadow 업데이트 성공")
    else:
        print(f"Shadow 업데이트 실패: {responseStatus}")

# 타임아웃 값을 여유있게 설정
shadow_client.configureConnectDisconnectTimeout(20)  # 기본 10초 → 20초
shadow_client.configureMQTTOperationTimeout(10)      # 기본 5초 → 10초

# 자동 재연결 설정
shadow_client.configureAutoReconnectBackoffTime(1, 32, 20)

try:
    shadow_client.connect()
    print("AWS IoT 연결 성공")
except Exception as e:
    print(f"연결 실패: {e}")
    # 재시도 로직 또는 로그 기록

def process_job(job_document):
    """Job 문서를 파싱하고 작업 수행"""
    operation = job_document.get("operation")
    
    if operation == "update-firmware":
        url = job_document.get("url")
        version = job_document.get("version")
        return download_and_install_firmware(url, version)
    
    elif operation == "update-config":
        config = job_document.get("config")
        return update_device_config(config)
    
    elif operation == "reboot":
        delay = job_document.get("delay", 0)
        return schedule_reboot(delay)
    
    else:
        return {"status": "FAILED", "reason": "Unknown operation"}

# 최적화 전: 8KB 메시지
message = {
    "deviceIdentifier": "sensor-temperature-basement-001",
    "measurementTimestamp": "2025-06-27T10:30:00.000Z",
    "temperatureReadings": [23.1, 23.2, 23.1, 23.0, 23.2, ...],  # 1000개 데이터
    "humidityReadings": [65.2, 65.1, 65.3, 65.0, 65.4, ...],     # 1000개 데이터
    "deviceMetadata": {
        "firmwareVersion": "v2.1.0",
        "batteryLevel": 85,
        "signalStrength": -45
    }
}
# 크기: 8KB → 2 메시지 요금 부과

# 최적화 후: 4.2KB 메시지
message = {
    "id": "st_b001",  # deviceIdentifier 축약
    "ts": 1719485400,  # unix timestamp 사용
    "temp": "23.1,23.2,23.1,23.0,23.2,...",  # 배열을 문자열로 압축
    "hum": "65.2,65.1,65.3,65.0,65.4,...",   # 배열을 문자열로 압축
    "meta": {
        "fw": "v2.1.0",  # 키 이름 축약
        "bat": 85,
        "sig": -45
    }
}
# 크기: 4.2KB → 1 메시지 요금만 부과

# Before: 장황한 키 이름 (가독성 좋지만 비효율)
{
    "deviceIdentifier": "sensor-001",
    "measurementTimestamp": "2025-06-27T10:30:00Z",
    "temperatureReading": 23.45,
    "humidityPercentage": 65.2,
    "batteryVoltageLevel": 3.7
}

# After: 축약된 키 이름 (크기 약 40% 절약)
{
    "id": "s001",
    "ts": 1719485400,
    "temp": 23.45,
    "hum": 65.2,
    "bat": 3.7
}

# Before: 문자열 타임스탬프 (29 bytes)
"timestamp": "2025-06-27T10:30:00.000Z"

# After: Unix 타임스탬프 (10 bytes)
"ts": 1719485400

# Before: JSON 배열 (크기 큼)
"readings": [23.1, 23.2, 23.0, 23.1, 23.2]

# After: 문자열 압축 (크기 작음)
"readings": "23.1,23.2,23.0,23.1,23.2"

import json
import gzip
import base64

def compress_message(data):
    """메시지를 GZIP으로 압축"""
    json_str = json.dumps(data)
    compressed = gzip.compress(json_str.encode())
    encoded = base64.b64encode(compressed).decode()
    
    return {
        "compressed": True,
        "data": encoded
    }

# 실제 측정 결과:
# Original: 8192 bytes (8KB)
# Compressed: 2048 bytes (2KB) → 75% 절약!

import json

def check_message_size(message, warn_threshold=4.5):
    """메시지 크기를 체크하고 경고"""
    json_str = json.dumps(message)
    size_kb = len(json_str.encode()) / 1024
    
    if size_kb > 5.0:
        print(f"🚨 CRITICAL: {size_kb:.2f}KB - 2배 요금 부과!")
        return False
    elif size_kb > warn_threshold:
        print(f"⚠️ WARNING: {size_kb:.2f}KB - 최적화 권장")
        return True
    else:
        print(f"✅ GOOD: {size_kb:.2f}KB - 최적화됨")
        return True

# 사용 예시
message = {"id": "sensor001", "data": "..."}
if not check_message_size(message):
    message = optimize_message(message)

def batch_messages(sensor_readings, max_size_kb=4.5):
    """메시지들을 4.5KB 이하 배치로 묶어서 전송"""
    batch = []
    current_size = 0
    
    for reading in sensor_readings:
        # 메시지 크기 계산
        test_batch = batch + [reading]
        test_size = len(json.dumps(test_batch).encode()) / 1024
        
        if test_size > max_size_kb and batch:
            # 현재 배치 전송
            publish_message(batch)
            batch = [reading]
        else:
            batch.append(reading)
    
    # 마지막 배치 전송
    if batch:
        publish_message(batch)

# Before: 100개 메시지 개별 전송 (1KB씩) = 100 메시지 요금
# After: 4개 배치로 묶어서 전송 (4KB씩) = 25 메시지 요금 (75% 절약!)

# Shadow 업데이트도 5KB 초과시 2배 요금
shadow_update = {
    "state": {
        "desired": {
            "config": very_large_config_data  # 5KB 초과 주의!
        }
    }
}

# Rule이 처리하는 메시지도 5KB 기준으로 계산
# 8KB 메시지 → 2개 Rule 실행 요금 부과