// MQTT를 사용한 기기 제어 예시 (JavaScript)
const mqtt = require('mqtt');
const client = mqtt.connect('mqtt://broker.example.com');

client.on('connect', () => {
  // 거실 조명 상태 구독
  client.subscribe('home/livingroom/light/status');
  
  // 조명 켜기 명령 발행
  client.publish('home/livingroom/light/control', JSON.stringify({
    action: 'turn_on',
    brightness: 80,
    color: '#FFD700'
  }));
});

client.on('message', (topic, message) => {
  console.log(`받은 메시지: ${topic} - ${message.toString()}`);
});

// Flutter에서 다크 모드 구현 예시
MaterialApp(
  theme: ThemeData(
    brightness: Brightness.light,
    primaryColor: Color(0xFF66BB6A),
    scaffoldBackgroundColor: Color(0xFFF5F5F5),
    cardColor: Colors.white,
  ),
  darkTheme: ThemeData(
    brightness: Brightness.dark,
    primaryColor: Color(0xFF81C784),
    scaffoldBackgroundColor: Color(0xFF121212),
    cardColor: Color(0xFF1E1E1E),
  ),
  themeMode: ThemeMode.system, // 시스템 설정 따르기
);

// React Native에서 햅틱 피드백 구현
import ReactNativeHapticFeedback from "react-native-haptic-feedback";

const handleLightToggle = async () => {
  // 햅틱 피드백 실행
  ReactNativeHapticFeedback.trigger("impactLight");
  
  // 로딩 상태 표시
  setIsLoading(true);
  
  try {
    // IoT 기기 제어 API 호출
    await toggleLight(deviceId);
    
    // 성공 피드백
    ReactNativeHapticFeedback.trigger("notificationSuccess");
    showToast("조명이 켜졌습니다");
  } catch (error) {
    // 실패 피드백
    ReactNativeHapticFeedback.trigger("notificationError");
    showToast("제어에 실패했습니다");
  } finally {
    setIsLoading(false);
  }
};

// Firebase Authentication을 활용한 로그인 구현 (Flutter)
import 'package:firebase_auth/firebase_auth.dart';
import 'package:local_auth/local_auth.dart';

class AuthService {
  final FirebaseAuth _auth = FirebaseAuth.instance;
  final LocalAuthentication _localAuth = LocalAuthentication();
  
  // 이메일/비밀번호 로그인
  Future<user?> signInWithEmail(String email, String password) async {
    try {
      UserCredential result = await _auth.signInWithEmailAndPassword(
        email: email,
        password: password,
      );
      return result.user;
    } catch (e) {
      print('로그인 실패: $e');
      return null;
    }
  }
  
  // 생체 인증 확인
  Future<bool> authenticateWithBiometrics() async {
    try {
      bool canCheckBiometrics = await _localAuth.canCheckBiometrics;
      if (!canCheckBiometrics) return false;
      
      return await _localAuth.authenticate(
        localizedReason: '스마트홈 제어를 위해 인증이 필요합니다',
        options: const AuthenticationOptions(
          stickyAuth: true,
          biometricOnly: true,
        ),
      );
    } catch (e) {
      print('생체 인증 실패: $e');
      return false;
    }
  }
  
  // 2단계 인증 설정
  Future<void> enableTwoFactorAuth() async {
    User? user = _auth.currentUser;
    if (user != null) {
      await user.sendEmailVerification();
      // SMS 인증 코드 전송 로직 추가
    }
  }
}</void></bool></user?>

// WebSocket을 활용한 실시간 동기화 (React Native)
import { useEffect, useState } from 'react';

const useDeviceStatus = (deviceId) => {
  const [status, setStatus] = useState(null);
  const [isConnected, setIsConnected] = useState(false);
  
  useEffect(() => {
    // WebSocket 연결
    const ws = new WebSocket(`wss://api.smarthome.com/devices/${deviceId}`);
    
    ws.onopen = () => {
      console.log('WebSocket 연결됨');
      setIsConnected(true);
      
      // 초기 상태 요청
      ws.send(JSON.stringify({ action: 'getStatus' }));
    };
    
    ws.onmessage = (event) => {
      const data = JSON.parse(event.data);
      
      // 상태 업데이트
      setStatus({
        isOn: data.power,
        brightness: data.brightness,
        temperature: data.temperature,
        lastUpdate: new Date(data.timestamp),
      });
    };
    
    ws.onerror = (error) => {
      console.error('WebSocket 에러:', error);
      setIsConnected(false);
    };
    
    ws.onclose = () => {
      console.log('WebSocket 연결 종료');
      setIsConnected(false);
      
      // 재연결 시도 (5초 후)
      setTimeout(() => {
        console.log('재연결 시도...');
      }, 5000);
    };
    
    // 클린업
    return () => {
      ws.close();
    };
  }, [deviceId]);
  
  // 기기 제어 함수
  const controlDevice = (command) => {
    if (ws && ws.readyState === WebSocket.OPEN) {
      ws.send(JSON.stringify(command));
    }
  };
  
  return { status, isConnected, controlDevice };
};

// 시나리오 데이터 구조 및 실행 엔진 (TypeScript)
interface Trigger {
  type: 'time' | 'location' | 'sensor' | 'device';
  condition: any;
}

interface Condition {
  type: 'weather' | 'presence' | 'dayOfWeek';
  value: any;
}

interface Action {
  deviceId: string;
  command: string;
  parameters: any;
}

interface Scenario {
  id: string;
  name: string;
  enabled: boolean;
  trigger: Trigger;
  conditions?: Condition[];
  actions: Action[];
}

class ScenarioEngine {
  private scenarios: Scenario[] = [];
  
  // 시나리오 등록
  addScenario(scenario: Scenario) {
    this.scenarios.push(scenario);
    this.setupTrigger(scenario);
  }
  
  // 트리거 설정
  private setupTrigger(scenario: Scenario) {
    switch (scenario.trigger.type) {
      case 'time':
        this.setupTimeTrigger(scenario);
        break;
      case 'location':
        this.setupLocationTrigger(scenario);
        break;
      case 'sensor':
        this.setupSensorTrigger(scenario);
        break;
      case 'device':
        this.setupDeviceTrigger(scenario);
        break;
    }
  }
  
  // 시간 기반 트리거
  private setupTimeTrigger(scenario: Scenario) {
    const { hour, minute } = scenario.trigger.condition;
    
    // 매일 지정된 시간에 실행
    const checkTime = () => {
      const now = new Date();
      if (now.getHours() === hour && now.getMinutes() === minute) {
        this.executeScenario(scenario);
      }
    };
    
    setInterval(checkTime, 60000); // 1분마다 체크
  }
  
  // 위치 기반 트리거
  private setupLocationTrigger(scenario: Scenario) {
    // Geofencing API 활용
    navigator.geolocation.watchPosition(
      (position) => {
        const { latitude, longitude } = position.coords;
        const homeLocation = scenario.trigger.condition;
        
        // 집 근처 100m 이내 진입 시
        const distance = this.calculateDistance(
          latitude, longitude,
          homeLocation.lat, homeLocation.lng
        );
        
        if (distance < 100) {
          this.executeScenario(scenario);
        }
      },
      (error) => console.error('위치 추적 에러:', error),
      { enableHighAccuracy: true }
    );
  }
  
  // 시나리오 실행
  private async executeScenario(scenario: Scenario) {
    if (!scenario.enabled) return;
    
    // 조건 확인
    if (scenario.conditions) {
      const conditionsMet = await this.checkConditions(scenario.conditions);
      if (!conditionsMet) return;
    }
    
    console.log(`시나리오 실행: ${scenario.name}`);
    
    // 액션 순차 실행
    for (const action of scenario.actions) {
      try {
        await this.executeAction(action);
        await this.delay(500); // 액션 간 0.5초 딜레이
      } catch (error) {
        console.error(`액션 실행 실패:`, error);
      }
    }
  }
  
  // 액션 실행
  private async executeAction(action: Action) {
    const response = await fetch(`https://api.smarthome.com/devices/${action.deviceId}/control`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        command: action.command,
        parameters: action.parameters,
      }),
    });
    
    if (!response.ok) {
      throw new Error(`액션 실행 실패: ${response.statusText}`);
    }
  }
  
  private delay(ms: number) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
  
  private calculateDistance(lat1: number, lon1: number, lat2: number, lon2: number): number {
    // Haversine 공식으로 거리 계산
    const R = 6371e3; // 지구 반지름 (미터)
    const φ1 = lat1 * Math.PI / 180;
    const φ2 = lat2 * Math.PI / 180;
    const Δφ = (lat2 - lat1) * Math.PI / 180;
    const Δλ = (lon2 - lon1) * Math.PI / 180;
    
    const a = Math.sin(Δφ/2) * Math.sin(Δφ/2) +
              Math.cos(φ1) * Math.cos(φ2) *
              Math.sin(Δλ/2) * Math.sin(Δλ/2);
    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
    
    return R * c;
  }
}

// Chart.js를 활용한 에너지 사용량 시각화 (React Native)
import { LineChart } from 'react-native-chart-kit';

const EnergyMonitor = ({ deviceId }) => {
  const [energyData, setEnergyData] = useState([]);
  
  useEffect(() => {
    // 에너지 데이터 가져오기
    const fetchEnergyData = async () => {
      const response = await fetch(
        `https://api.smarthome.com/devices/${deviceId}/energy?period=week`
      );
      const data = await response.json();
      setEnergyData(data);
    };
    
    fetchEnergyData();
    
    // 1시간마다 업데이트
    const interval = setInterval(fetchEnergyData, 3600000);
    return () => clearInterval(interval);
  }, [deviceId]);
  
  // 전기요금 계산 (kWh당 평균 요금 적용)
  const calculateCost = (kwh) => {
    const ratePerKwh = 120; // 원/kWh (예시)
    return (kwh * ratePerKwh).toFixed(0);
  };
  
  const totalEnergy = energyData.reduce((sum, day) => sum + day.kwh, 0);
  const estimatedCost = calculateCost(totalEnergy);
  
  return (
    <view>
      <text style="{styles.title}">이번 주 에너지 사용량</text>
      
      <linechart data="{{" labels:="" energydata.map(d=""> d.day),
          datasets: [{
            data: energyData.map(d => d.kwh),
          }],
        }}
        width={Dimensions.get('window').width - 40}
        height={220}
        chartConfig={{
          backgroundColor: '#ffffff',
          backgroundGradientFrom: '#f0f0f0',
          backgroundGradientTo: '#f0f0f0',
          decimalPlaces: 1,
          color: (opacity = 1) => `rgba(102, 187, 106, ${opacity})`,
          style: { borderRadius: 16 },
        }}
        bezier
        style={{ marginVertical: 8, borderRadius: 16 }}
      />
      
      <view style="{styles.summary}">
        <text>총 사용량: {totalEnergy.toFixed(2)} kWh</text>
        <text>예상 요금: {estimatedCost}원</text>
        <text>전주 대비: -12% 절약 🎉</text>
      </view>
    </linechart></view>
  );
};

// SmartThings API 연동 예시 (Node.js)
const axios = require('axios');

class SmartThingsAPI {
  constructor(accessToken) {
    this.accessToken = accessToken;
    this.baseURL = 'https://api.smartthings.com/v1';
  }
  
  // 모든 기기 목록 가져오기
  async getDevices() {
    try {
      const response = await axios.get(`${this.baseURL}/devices`, {
        headers: {
          'Authorization': `Bearer ${this.accessToken}`,
          'Content-Type': 'application/json',
        },
      });
      return response.data.items;
    } catch (error) {
      console.error('기기 목록 조회 실패:', error);
      throw error;
    }
  }
  
  // 기기 상태 조회
  async getDeviceStatus(deviceId) {
    try {
      const response = await axios.get(
        `${this.baseURL}/devices/${deviceId}/status`,
        {
          headers: {
            'Authorization': `Bearer ${this.accessToken}`,
          },
        }
      );
      return response.data.components.main;
    } catch (error) {
      console.error('상태 조회 실패:', error);
      throw error;
    }
  }
  
  // 기기 제어
  async controlDevice(deviceId, capability, command, args = []) {
    try {
      const response = await axios.post(
        `${this.baseURL}/devices/${deviceId}/commands`,
        {
          commands: [{
            component: 'main',
            capability: capability,
            command: command,
            arguments: args,
          }],
        },
        {
          headers: {
            'Authorization': `Bearer ${this.accessToken}`,
            'Content-Type': 'application/json',
          },
        }
      );
      return response.data;
    } catch (error) {
      console.error('기기 제어 실패:', error);
      throw error;
    }
  }
  
  // 조명 켜기/끄기
  async toggleLight(deviceId, turnOn) {
    return this.controlDevice(
      deviceId,
      'switch',
      turnOn ? 'on' : 'off'
    );
  }
  
  // 조명 밝기 조절
  async setLightBrightness(deviceId, level) {
    return this.controlDevice(
      deviceId,
      'switchLevel',
      'setLevel',
      [level]
    );
  }
  
  // 온도 조절기 설정
  async setThermostat(deviceId, mode, temperature) {
    await this.controlDevice(deviceId, 'thermostatMode', 'setThermostatMode', [mode]);
    
    if (mode === 'heat') {
      await this.controlDevice(deviceId, 'thermostatHeatingSetpoint', 'setHeatingSetpoint', [temperature]);
    } else if (mode === 'cool') {
      await this.controlDevice(deviceId, 'thermostatCoolingSetpoint', 'setCoolingSetpoint', [temperature]);
    }
  }
}

// 사용 예시
const api = new SmartThingsAPI('YOUR_ACCESS_TOKEN');

// 모든 기기 조회
const devices = await api.getDevices();
console.log('연결된 기기:', devices);

// 거실 조명 켜기
await api.toggleLight('living-room-light-id', true);

// 침실 조명 밝기 50%로 설정
await api.setLightBrightness('bedroom-light-id', 50);

// 에어컨 냉방 24도로 설정
await api.setThermostat('ac-id', 'cool', 24);

// Matter SDK를 활용한 기기 페어링 (iOS Swift 예시)
import Matter

class MatterDeviceManager {
    let controller: MTRDeviceController
    
    init() {
        let factory = MTRDeviceControllerFactory.sharedInstance()
        let storage = MTRDeviceControllerLocalTestStorage()
        
        let params = MTRDeviceControllerStartupParams(
            ipk: Data(),
            operationalKeypair: nil,
            operationalCertificate: nil,
            intermediateCertificate: nil,
            rootCertificate: nil
        )
        
        controller = try! factory.createController(
            onNewFabric: params,
            storage: storage
        )
    }
    
    // QR 코드로 기기 페어링
    func pairDevice(qrCode: String, completion: @escaping (Bool) -> Void) {
        let payload = try! MTRSetupPayload(qrCodeString: qrCode)
        
        controller.setupCommissioningSession(
            with: payload,
            newNodeID: NSNumber(value: generateNodeID())
        ) { error in
            if let error = error {
                print("페어링 실패: \(error)")
                completion(false)
            } else {
                print("페어링 성공!")
                completion(true)
            }
        }
    }
    
    // 조명 제어
    func controlLight(nodeID: UInt64, endpoint: UInt16, isOn: Bool) {
        let device = MTRBaseDevice(
            nodeID: NSNumber(value: nodeID),
            controller: controller
        )
        
        let cluster = MTRBaseClusterOnOff(
            device: device,
            endpointID: NSNumber(value: endpoint),
            queue: DispatchQueue.main
        )
        
        if isOn {
            cluster.on { error in
                if let error = error {
                    print("조명 켜기 실패: \(error)")
                }
            }
        } else {
            cluster.off { error in
                if let error = error {
                    print("조명 끄기 실패: \(error)")
                }
            }
        }
    }
    
    private func generateNodeID() -> UInt64 {
        return UInt64.random(in: 1...UInt64.max)
    }
}

// React Native에서 음성 인식 구현
import Voice from '@react-native-voice/voice';
import { useState, useEffect } from 'react';

const VoiceControl = () => {
  const [isListening, setIsListening] = useState(false);
  const [recognizedText, setRecognizedText] = useState('');
  
  useEffect(() => {
    // 음성 인식 이벤트 리스너 등록
    Voice.onSpeechStart = () => {
      console.log('음성 인식 시작');
      setIsListening(true);
    };
    
    Voice.onSpeechEnd = () => {
      console.log('음성 인식 종료');
      setIsListening(false);
    };
    
    Voice.onSpeechResults = (event) => {
      const text = event.value[0];
      setRecognizedText(text);
      processVoiceCommand(text);
    };
    
    Voice.onSpeechError = (error) => {
      console.error('음성 인식 에러:', error);
      setIsListening(false);
    };
    
    return () => {
      Voice.destroy().then(Voice.removeAllListeners);
    };
  }, []);
  
  // 음성 인식 시작
  const startListening = async () => {
    try {
      await Voice.start('ko-KR'); // 한국어 설정
    } catch (error) {
      console.error('음성 인식 시작 실패:', error);
    }
  };
  
  // 음성 인식 중지
  const stopListening = async () => {
    try {
      await Voice.stop();
    } catch (error) {
      console.error('음성 인식 중지 실패:', error);
    }
  };
  
  // 음성 명령 처리
  const processVoiceCommand = (text) => {
    const lowerText = text.toLowerCase();
    
    // 조명 제어
    if (lowerText.includes('불') || lowerText.includes('조명')) {
      if (lowerText.includes('켜') || lowerText.includes('on')) {
        controlLight('living-room', true);
        speak('거실 조명을 켰습니다');
      } else if (lowerText.includes('꺼') || lowerText.includes('off')) {
        controlLight('living-room', false);
        speak('거실 조명을 껐습니다');
      }
    }
    
    // 온도 제어
    else if (lowerText.includes('온도') || lowerText.includes('에어컨')) {
      const tempMatch = lowerText.match(/(\d+)도/);
      if (tempMatch) {
        const temperature = parseInt(tempMatch[1]);
        setTemperature('ac', temperature);
        speak(`온도를 ${temperature}도로 설정했습니다`);
      }
    }
    
    // 시나리오 실행
    else if (lowerText.includes('외출') || lowerText.includes('나갈게')) {
      executeScenario('leaving-home');
      speak('외출 모드를 실행합니다');
    }
    
    else if (lowerText.includes('잘게') || lowerText.includes('굿나잇')) {
      executeScenario('good-night');
      speak('좋은 밤 되세요');
    }
    
    // 상태 조회
    else if (lowerText.includes('상태') || lowerText.includes('어때')) {
      const status = getHomeStatus();
      speak(`현재 온도는 ${status.temperature}도이고, 
             ${status.lightsOn}개의 조명이 켜져 있습니다`);
    }
    
    else {
      speak('죄송합니다. 명령을 이해하지 못했습니다');
    }
  };
  
  // TTS (Text-to-Speech)로 응답
  const speak = (text) => {
    // react-native-tts 라이브러리 사용
    Tts.speak(text, {
      iosVoiceId: 'com.apple.ttsbundle.Yuna-compact',
      rate: 0.5,
      androidParams: {
        KEY_PARAM_PAN: -1,
        KEY_PARAM_VOLUME: 0.5,
        KEY_PARAM_STREAM: 'STREAM_MUSIC',
      },
    });
  };
  
  return (
    <view style="{styles.container}">
      <touchableopacity style="{[styles.micButton," islistening="" &&="" styles.listening]}="" onpress="{isListening" ?="" stoplistening="" :="" startlistening}="">
        <icon name="microphone" size="{40}" color="#fff">
      </icon></touchableopacity>
      
      {recognizedText && (
        <text style="{styles.recognizedText}">
          "{recognizedText}"
        </text>
      )}
      
      <text style="{styles.hint}">
        {isListening ? '듣고 있습니다...' : '마이크를 눌러 말씀하세요'}
      </text>
    </view>
  );
};

// Dialogflow를 활용한 고급 음성 명령 처리
const dialogflow = require('@google-cloud/dialogflow');

class SmartHomeNLP {
  constructor(projectId, sessionId) {
    this.projectId = projectId;
    this.sessionId = sessionId;
    this.sessionClient = new dialogflow.SessionsClient();
    this.sessionPath = this.sessionClient.projectAgentSessionPath(
      projectId,
      sessionId
    );
  }
  
  async processCommand(text) {
    const request = {
      session: this.sessionPath,
      queryInput: {
        text: {
          text: text,
          languageCode: 'ko',
        },
      },
    };
    
    try {
      const responses = await this.sessionClient.detectIntent(request);
      const result = responses[0].queryResult;
      
      console.log(`인식된 의도: ${result.intent.displayName}`);
      console.log(`신뢰도: ${result.intentDetectionConfidence}`);
      
      // 의도에 따른 액션 실행
      return this.executeIntent(result);
    } catch (error) {
      console.error('NLP 처리 실패:', error);
      return { success: false, message: '명령을 이해하지 못했습니다' };
    }
  }
  
  executeIntent(result) {
    const intent = result.intent.displayName;
    const parameters = result.parameters.fields;
    
    switch (intent) {
      case 'control.light':
        return this.handleLightControl(parameters);
      
      case 'control.temperature':
        return this.handleTemperatureControl(parameters);
      
      case 'query.status':
        return this.handleStatusQuery(parameters);
      
      case 'execute.scenario':
        return this.handleScenarioExecution(parameters);
      
      default:
        return {
          success: false,
          message: result.fulfillmentText,
        };
    }
  }
  
  handleLightControl(params) {
    const room = params.room?.stringValue || 'living-room';
    const action = params.action?.stringValue; // 'on' or 'off'
    const brightness = params.brightness?.numberValue;
    
    // 실제 기기 제어 로직
    if (action) {
      controlLight(room, action === 'on', brightness);
      return {
        success: true,
        message: `${room} 조명을 ${action === 'on' ? '켰' : '껐'}습니다`,
      };
    }
    
    return { success: false, message: '명령을 확인해주세요' };
  }
  
  handleTemperatureControl(params) {
    const device = params.device?.stringValue || 'ac';
    const temperature = params.temperature?.numberValue;
    const mode = params.mode?.stringValue; // 'cool', 'heat', 'auto'
    
    if (temperature) {
      setTemperature(device, temperature, mode);
      return {
        success: true,
        message: `온도를 ${temperature}도로 설정했습니다`,
      };
    }
    
    return { success: false, message: '온도를 말씀해주세요' };
  }
  
  handleStatusQuery(params) {
    const target = params.target?.stringValue;
    
    if (target === 'temperature') {
      const temp = getCurrentTemperature();
      return {
        success: true,
        message: `현재 온도는 ${temp}도입니다`,
      };
    } else if (target === 'lights') {
      const count = getLightsOnCount();
      return {
        success: true,
        message: `현재 ${count}개의 조명이 켜져 있습니다`,
      };
    } else {
      const status = getHomeStatus();
      return {
        success: true,
        message: `온도 ${status.temperature}도, 
                  조명 ${status.lightsOn}개 켜짐, 
                  에너지 사용량 ${status.energyUsage}kWh`,
      };
    }
  }
  
  handleScenarioExecution(params) {
    const scenarioName = params.scenario?.stringValue;
    
    if (scenarioName) {
      executeScenario(scenarioName);
      return {
        success: true,
        message: `${scenarioName} 시나리오를 실행합니다`,
      };
    }
    
    return { success: false, message: '시나리오 이름을 말씀해주세요' };
  }
}

// 사용 예시
const nlp = new SmartHomeNLP('your-project-id', 'user-session-123');

// 다양한 표현 처리 가능
await nlp.processCommand('거실 불 좀 켜줘');
await nlp.processCommand('침실 조명 50%로 낮춰');
await nlp.processCommand('에어컨 24도로 맞춰줘');
await nlp.processCommand('지금 집 안 온도 어때?');
await nlp.processCommand('외출할게');

// Certificate Pinning 구현 (React Native)
import axios from 'axios';
import { sha256 } from 'react-native-sha256';

class SecureAPIClient {
  constructor() {
    this.baseURL = 'https://api.smarthome.com';
    this.pinnedCertificates = [
      // 서버 인증서의 SHA-256 해시
      'AA:BB:CC:DD:EE:FF:00:11:22:33:44:55:66:77:88:99:AA:BB:CC:DD:EE:FF:00:11:22:33:44:55:66:77:88:99',
    ];
  }
  
  async request(endpoint, method = 'GET', data = null) {
    try {
      // SSL Pinning 검증
      await this.verifyCertificate();
      
      const config = {
        method,
        url: `${this.baseURL}${endpoint}`,
        headers: {
          'Content-Type': 'application/json',
          'Authorization': `Bearer ${await this.getAccessToken()}`,
        },
        data,
      };
      
      const response = await axios(config);
      return response.data;
    } catch (error) {
      if (error.message.includes('certificate')) {
        // 인증서 검증 실패 - 보안 위협!
        this.handleSecurityThreat();
      }
      throw error;
    }
  }
  
  async verifyCertificate() {
    // 실제 구현에서는 네이티브 모듈 사용
    // react-native-ssl-pinning 라이브러리 활용
    const certHash = await this.getServerCertificateHash();
    
    if (!this.pinnedCertificates.includes(certHash)) {
      throw new Error('Certificate pinning failed');
    }
  }
  
  handleSecurityThreat() {
    // 보안 위협 감지 시 조치
    Alert.alert(
      '보안 경고',
      '안전하지 않은 연결이 감지되었습니다. 앱을 종료합니다.',
      [{ text: '확인', onPress: () => RNExitApp.exitApp() }]
    );
  }
  
  async getAccessToken() {
    // Secure Storage에서 토큰 가져오기
    const token = await SecureStore.getItemAsync('access_token');
    
    if (!token || this.isTokenExpired(token)) {
      // 토큰 갱신
      return await this.refreshAccessToken();
    }
    
    return token;
  }
  
  isTokenExpired(token) {
    const decoded = jwtDecode(token);
    return decoded.exp < Date.now() / 1000;
  }
  
  async refreshAccessToken() {
    const refreshToken = await SecureStore.getItemAsync('refresh_token');
    
    const response = await axios.post(`${this.baseURL}/auth/refresh`, {
      refresh_token: refreshToken,
    });
    
    const { access_token, refresh_token } = response.data;
    
    // 새 토큰 저장
    await SecureStore.setItemAsync('access_token', access_token);
    await SecureStore.setItemAsync('refresh_token', refresh_token);
    
    return access_token;
  }
}

// 민감 데이터 암호화
import CryptoJS from 'crypto-js';

class DataEncryption {
  constructor(secretKey) {
    this.secretKey = secretKey;
  }
  
  encrypt(data) {
    const jsonString = JSON.stringify(data);
    return CryptoJS.AES.encrypt(jsonString, this.secretKey).toString();
  }
  
  decrypt(encryptedData) {
    const bytes = CryptoJS.AES.decrypt(encryptedData, this.secretKey);
    const decryptedString = bytes.toString(CryptoJS.enc.Utf8);
    return JSON.parse(decryptedString);
  }
  
  // 비밀번호 해싱 (저장 전)
  hashPassword(password) {
    return CryptoJS.SHA256(password).toString();
  }
}

// 사용 예시
const encryption = new DataEncryption('your-secret-key-here');

// 민감한 설정 정보 암호화 저장
const sensitiveData = {
  wifiPassword: 'myWifiPass123',
  doorLockPin: '1234',
  cameraStreamUrl: 'rtsp://192.168.1.100/stream',
};

const encrypted = encryption.encrypt(sensitiveData);
await SecureStore.setItemAsync('sensitive_config', encrypted);

// 복호화해서 사용
const encryptedData = await SecureStore.getItemAsync('sensitive_config');
const decrypted = encryption.decrypt(encryptedData);

// 프라이버시 친화적인 카메라 스트리밍 구현
class PrivacyAwareCameraStream {
  constructor(cameraId) {
    this.cameraId = cameraId;
    this.isStreaming = false;
    this.privacyMode = false;
  }
  
  async startStream(options = {}) {
    // 사용자 동의 확인
    const hasPermission = await this.checkCameraPermission();
    if (!hasPermission) {
      throw new Error('카메라 권한이 필요합니다');
    }
    
    // 프라이버시 모드 확인
    if (options.privacyMode) {
      this.enablePrivacyMode();
    }
    
    // 로컬 네트워크에서만 스트리밍 (클라우드 전송 X)
    if (options.localOnly) {
      return this.startLocalStream();
    }
    
    // End-to-End 암호화된 스트리밍
    return this.startEncryptedStream();
  }
  
  enablePrivacyMode() {
    this.privacyMode = true;
    
    // 프라이버시 모드 옵션
    // 1. 얼굴 블러 처리
    // 2. 움직임 감지만 표시 (실제 영상 X)
    // 3. 특정 영역 마스킹
  }
  
  async startLocalStream() {
    // mDNS/Bonjour로 로컬 네트워크에서 카메라 찾기
    const cameraIP = await this.discoverLocalCamera();
    
    // 로컬 네트워크 내에서만 스트리밍
    return {
      streamUrl: `rtsp://${cameraIP}:554/stream`,
      isLocal: true,
      encrypted: false,
    };
  }
  
  async startEncryptedStream() {
    // WebRTC를 활용한 P2P 암호화 스트리밍
    const peerConnection = new RTCPeerConnection({
      iceServers: [{ urls: 'stun:stun.l.google.com:19302' }],
    });
    
    // DTLS-SRTP로 자동 암호화
    const stream = await navigator.mediaDevices.getUserMedia({
      video: { deviceId: this.cameraId },
    });
    
    stream.getTracks().forEach(track => {
      peerConnection.addTrack(track, stream);
    });
    
    return {
      peerConnection,
      stream,
      encrypted: true,
    };
  }
  
  // 녹화 데이터 자동 삭제
  async scheduleDataDeletion(recordingId, daysToKeep = 7) {
    const deleteAt = new Date();
    deleteAt.setDate(deleteAt.getDate() + daysToKeep);
    
    await scheduleTask({
      id: `delete-recording-${recordingId}`,
      executeAt: deleteAt,
      action: async () => {
        await this.deleteRecording(recordingId);
        console.log(`녹화 데이터 자동 삭제: ${recordingId}`);
      },
    });
  }
  
  async deleteRecording(recordingId) {
    // 클라우드 및 로컬 저장소에서 완전 삭제
    await cloudStorage.delete(`recordings/${recordingId}`);
    await localStorage.delete(`recordings/${recordingId}`);
    
    // 메타데이터도 삭제
    await database.delete('recordings', { id: recordingId });
  }
}

// iOS Info.plist에 권한 설명 추가
<key>NSCameraUsageDescription</key>
<string>스마트 카메라 영상을 확인하기 위해 카메라 권한이 필요합니다.</string>

<key>NSMicrophoneUsageDescription</key>
<string>음성 명령 기능을 사용하기 위해 마이크 권한이 필요합니다.</string>

<key>NSLocationWhenInUseUsageDescription</key>
<string>집에 도착하면 자동으로 조명을 켜는 등의 위치 기반 자동화를 위해 위치 권한이 필요합니다.</string>

<key>NSLocationAlwaysAndWhenInUseUsageDescription</key>
<string>백그라운드에서도 위치 기반 자동화가 작동하도록 하기 위해 항상 위치 권한이 필요합니다.</string>

<key>NSBluetoothAlwaysUsageDescription</key>
<string>Bluetooth 기반 스마트 기기와 연결하기 위해 Bluetooth 권한이 필요합니다.</string>

// Android AndroidManifest.xml에 권한 추가
<uses-permission android:name="android.permission.INTERNET">
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION">
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION">
<uses-permission android:name="android.permission.BLUETOOTH">
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN">
<uses-permission android:name="android.permission.CAMERA">
<uses-permission android:name="android.permission.RECORD_AUDIO">
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"></uses-permission></uses-permission></uses-permission></uses-permission></uses-permission></uses-permission></uses-permission></uses-permission>

# GitHub Actions 워크플로우 예시 (.github/workflows/deploy.yml)
name: Deploy Smart Home App

on:
  push:
    branches:
      - main
  pull_request:
    branches:
      - main

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '18'
          cache: 'npm'
      
      - name: Install dependencies
        run: npm ci
      
      - name: Run tests
        run: npm test -- --coverage
      
      - name: Upload coverage
        uses: codecov/codecov-action@v3
        with:
          files: ./coverage/lcov.info

  build-android:
    needs: test
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main'
    steps:
      - uses: actions/checkout@v3
      
      - name: Setup Java
        uses: actions/setup-java@v3
        with:
          distribution: 'temurin'
          java-version: '11'
      
      - name: Setup Android SDK
        uses: android-actions/setup-android@v2
      
      - name: Install dependencies
        run: npm ci
      
      - name: Build Android APK
        run: |
          cd android
          ./gradlew assembleRelease
      
      - name: Sign APK
        uses: r0adkll/sign-android-release@v1
        with:
          releaseDirectory: android/app/build/outputs/apk/release
          signingKeyBase64: ${{ secrets.ANDROID_SIGNING_KEY }}
          alias: ${{ secrets.ANDROID_KEY_ALIAS }}
          keyStorePassword: ${{ secrets.ANDROID_KEYSTORE_PASSWORD }}
          keyPassword: ${{ secrets.ANDROID_KEY_PASSWORD }}
      
      - name: Upload to Play Store
        uses: r0adkll/upload-google-play@v1
        with:
          serviceAccountJsonPlainText: ${{ secrets.PLAY_STORE_SERVICE_ACCOUNT }}
          packageName: com.smarthome.app
          releaseFiles: android/app/build/outputs/apk/release/app-release-signed.apk
          track: internal

  build-ios:
    needs: test
    runs-on: macos-latest
    if: github.ref == 'refs/heads/main'
    steps:
      - uses: actions/checkout@v3
      
      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '18'
      
      - name: Install dependencies
        run: npm ci
      
      - name: Install CocoaPods
        run: |
          cd ios
          pod install
      
      - name: Build iOS
        run: |
          xcodebuild -workspace ios/SmartHome.xcworkspace \
                     -scheme SmartHome \
                     -configuration Release \
                     -archivePath ios/build/SmartHome.xcarchive \
                     archive
      
      - name: Export IPA
        run: |
          xcodebuild -exportArchive \
                     -archivePath ios/build/SmartHome.xcarchive \
                     -exportPath ios/build \
                     -exportOptionsPlist ios/ExportOptions.plist
      
      - name: Upload to TestFlight
        uses: apple-actions/upload-testflight-build@v1
        with:
          app-path: ios/build/SmartHome.ipa
          issuer-id: ${{ secrets.APPSTORE_ISSUER_ID }}
          api-key-id: ${{ secrets.APPSTORE_API_KEY_ID }}
          api-private-key: ${{ secrets.APPSTORE_API_PRIVATE_KEY }}