// 블루투스 지원 여부 먼저 확인!
if (!navigator.bluetooth) {
  console.log('이 브라우저는 Web Bluetooth를 지원하지 않아요 😢');
  return;
}

// 기기 검색 요청
async function connectToDevice() {
  try {
    const device = await navigator.bluetooth.requestDevice({
      // 필터 옵션: 어떤 기기를 검색할지 지정
      filters: [
        { services: ['heart_rate'] }  // 심박수 서비스를 가진 기기만 표시
      ],
      // 또는 이름으로 필터링
      // filters: [{ name: '내 기기 이름' }],
      // 또는 이름 접두사로 필터링
      // filters: [{ namePrefix: 'BLE-' }],
      
      // 추가로 접근할 서비스 목록 (선택사항)
      optionalServices: ['battery_service']
    });
    
    console.log('선택된 기기:', device.name);
    console.log('기기 ID:', device.id);
    
    return device;
  } catch (error) {
    console.error('기기 선택 취소 또는 오류:', error);
  }
}

async function connectGATT(device) {
  try {
    // GATT 서버 연결
    const server = await device.gatt.connect();
    console.log('GATT 서버 연결 성공! 🎉');
    
    // 연결 상태 확인
    console.log('연결됨:', device.gatt.connected); // true
    
    return server;
  } catch (error) {
    console.error('GATT 연결 실패:', error);
  }
}

// 연결 해제 이벤트 리스너
device.addEventListener('gattserverdisconnected', (event) => {
  console.log('기기 연결이 끊어졌어요:', event.target.name);
  // 여기서 재연결 로직을 구현할 수 있어
});

async function getHeartRateCharacteristic(server) {
  try {
    // 심박수 서비스 가져오기
    const service = await server.getPrimaryService('heart_rate');
    console.log('심박수 서비스 획득!');
    
    // 심박수 측정 특성 가져오기
    const characteristic = await service.getCharacteristic(
      'heart_rate_measurement'
    );
    console.log('심박수 특성 획득!');
    
    // 특성의 속성 확인
    console.log('읽기 가능:', characteristic.properties.read);
    console.log('알림 가능:', characteristic.properties.notify);
    console.log('쓰기 가능:', characteristic.properties.write);
    
    return characteristic;
  } catch (error) {
    console.error('서비스/특성 획득 실패:', error);
  }
}

async function readHeartRate(characteristic) {
  try {
    // 현재 값 한 번 읽기
    const value = await characteristic.readValue();
    
    // DataView로 반환됨 - 파싱이 필요해!
    // 심박수 데이터 파싱 (GATT 스펙에 따라)
    const flags = value.getUint8(0);
    const rate16Bits = flags & 0x1;
    
    let heartRate;
    if (rate16Bits) {
      heartRate = value.getUint16(1, /*littleEndian=*/true);
    } else {
      heartRate = value.getUint8(1);
    }
    
    console.log('현재 심박수:', heartRate, 'bpm');
    return heartRate;
  } catch (error) {
    console.error('데이터 읽기 실패:', error);
  }
}

async function subscribeToHeartRate(characteristic) {
  try {
    // 알림 시작
    await characteristic.startNotifications();
    console.log('심박수 알림 구독 시작! 💓');
    
    // 값이 변경될 때마다 이벤트 발생
    characteristic.addEventListener(
      'characteristicvaluechanged',
      handleHeartRateChange
    );
  } catch (error) {
    console.error('알림 구독 실패:', error);
  }
}

function handleHeartRateChange(event) {
  const value = event.target.value;
  const flags = value.getUint8(0);
  const rate16Bits = flags & 0x1;
  
  let heartRate;
  if (rate16Bits) {
    heartRate = value.getUint16(1, true);
  } else {
    heartRate = value.getUint8(1);
  }
  
  console.log('실시간 심박수:', heartRate, 'bpm');
  // UI 업데이트
  document.getElementById('heart-rate').textContent = heartRate;
}

// 알림 구독 해제
async function unsubscribe(characteristic) {
  await characteristic.stopNotifications();
  characteristic.removeEventListener(
    'characteristicvaluechanged',
    handleHeartRateChange
  );
  console.log('알림 구독 해제됨');
}

async function writeLEDColor(characteristic, r, g, b) {
  try {
    // RGB 값을 ArrayBuffer로 변환
    const data = new Uint8Array([r, g, b]);
    
    // writeValue: 응답을 기다림 (Write with Response)
    await characteristic.writeValue(data);
    console.log(`LED 색상 변경: RGB(${r}, ${g}, ${b})`);
    
    // writeValueWithoutResponse: 응답 없이 빠르게 전송
    // await characteristic.writeValueWithoutResponse(data);
    
    // writeValueWithResponse: 명시적으로 응답 요청
    // await characteristic.writeValueWithResponse(data);
  } catch (error) {
    console.error('쓰기 실패:', error);
  }
}

// 사용 예시
// LED를 빨간색으로 변경
writeLEDColor(ledCharacteristic, 255, 0, 0);

// LED를 파란색으로 변경
writeLEDColor(ledCharacteristic, 0, 0, 255);

let reconnectAttempts = 0;
const MAX_RECONNECT_ATTEMPTS = 5;

async function reconnect(device) {
  if (reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
    console.log('최대 재연결 시도 횟수 초과');
    return;
  }
  
  reconnectAttempts++;
  console.log(`재연결 시도 ${reconnectAttempts}/${MAX_RECONNECT_ATTEMPTS}...`);
  
  // 지수 백오프: 1초, 2초, 4초, 8초, 16초
  const delay = Math.pow(2, reconnectAttempts - 1) * 1000;
  
  await new Promise(resolve => setTimeout(resolve, delay));
  
  try {
    const server = await device.gatt.connect();
    reconnectAttempts = 0; // 성공 시 초기화
    console.log('재연결 성공! 🎉');
    
    // 서비스와 특성 다시 설정
    await setupCharacteristics(server);
  } catch (error) {
    console.error('재연결 실패:', error);
    reconnect(device); // 재귀 호출로 다시 시도
  }
}

// 연결 해제 이벤트에서 재연결 시도
device.addEventListener('gattserverdisconnected', () => {
  console.log('연결 끊김 감지, 재연결 시도...');
  reconnect(device);
});

async function getAllCharacteristics(server) {
  // 모든 서비스 가져오기
  const services = await server.getPrimaryServices();
  
  for (const service of services) {
    console.log('서비스:', service.uuid);
    
    // 서비스의 모든 특성 가져오기
    const characteristics = await service.getCharacteristics();
    
    for (const char of characteristics) {
      console.log('  특성:', char.uuid);
      console.log('  속성:', {
        read: char.properties.read,
        write: char.properties.write,
        notify: char.properties.notify,
        indicate: char.properties.indicate,
        writeWithoutResponse: char.properties.writeWithoutResponse
      });
    }
  }
}

// Promise.all로 병렬 처리 (성능 향상!)
async function readMultipleValues(server) {
  const [heartRateService, batteryService] = await Promise.all([
    server.getPrimaryService('heart_rate'),
    server.getPrimaryService('battery_service')
  ]);
  
  const [heartRateChar, batteryChar] = await Promise.all([
    heartRateService.getCharacteristic('heart_rate_measurement'),
    batteryService.getCharacteristic('battery_level')
  ]);
  
  const batteryValue = await batteryChar.readValue();
  const batteryLevel = batteryValue.getUint8(0);
  console.log('배터리 잔량:', batteryLevel, '%');
}

// 커스텀 서비스/특성 UUID (제조사 문서에서 확인)
const CUSTOM_SERVICE_UUID = '12345678-1234-1234-1234-123456789abc';
const CUSTOM_CHAR_UUID = 'abcdef01-1234-1234-1234-123456789abc';

const device = await navigator.bluetooth.requestDevice({
  filters: [{ name: '내 커스텀 기기' }],
  optionalServices: [CUSTOM_SERVICE_UUID]  // 반드시 명시해야 해!
});

const server = await device.gatt.connect();
const service = await server.getPrimaryService(CUSTOM_SERVICE_UUID);
const characteristic = await service.getCharacteristic(CUSTOM_CHAR_UUID);

// 커스텀 명령 전송 (기기 프로토콜에 따라)
const command = new Uint8Array([0x01, 0x02, 0x03]);
await characteristic.writeValue(command);

// 이전에 연결 허용한 기기 목록 가져오기
async function getPairedDevices() {
  const devices = await navigator.bluetooth.getDevices();
  console.log('허용된 기기 목록:', devices.map(d => d.name));
  return devices;
}

// 특정 기기에 자동 연결 시도
async function autoConnect() {
  const devices = await navigator.bluetooth.getDevices();
  
  for (const device of devices) {
    try {
      // watchAdvertisements로 기기 광고 신호 감지
      await device.watchAdvertisements();
      
      device.addEventListener('advertisementreceived', async (event) => {
        console.log('기기 발견:', event.device.name);
        await event.device.gatt.connect();
        device.unwatchAdvertisements();
      });
    } catch (error) {
      console.error('광고 감시 실패:', error);
    }
  }
}