Device and Sensor Integration APIs

// Check if geolocation is supported
if ("geolocation" in navigator) {
  console.log("Geolocation available");
} else {
  console.log("Geolocation not supported");
}

// Get current position
navigator.geolocation.getCurrentPosition(
  (position) => {
    const { latitude, longitude, accuracy } = position.coords;
    console.log(`Location: ${latitude}, ${longitude}`);
    console.log(`Accuracy: ${accuracy} meters`);
    console.log(`Timestamp: ${new Date(position.timestamp)}`);
    
    // Optional fields
    if (position.coords.altitude !== null) {
      console.log(`Altitude: ${position.coords.altitude} meters`);
    }
    if (position.coords.speed !== null) {
      console.log(`Speed: ${position.coords.speed} m/s`);
    }
    if (position.coords.heading !== null) {
      console.log(`Heading: ${position.coords.heading} degrees`);
    }
  },
  (error) => {
    switch (error.code) {
      case error.PERMISSION_DENIED:
        console.error("User denied geolocation permission");
        break;
      case error.POSITION_UNAVAILABLE:
        console.error("Location unavailable");
        break;
      case error.TIMEOUT:
        console.error("Geolocation timeout");
        break;
      default:
        console.error("Unknown geolocation error");
    }
  },
  {
    "enableHighAccuracy": true,
    "timeout": 10000,
    "maximumAge": 0
  }
);

let watchId;

// Start watching position
function startWatching() {
  watchId = navigator.geolocation.watchPosition(
    (position) => {
      const { latitude, longitude, accuracy } = position.coords;
      console.log(`Updated location: ${latitude}, ${longitude}`);
      console.log(`Accuracy: ${accuracy}m`);
      
      // Update map or UI
      updateMap(latitude, longitude);
    },
    (error) => {
      console.error("Watch position error:", error.message);
    },
    {
      "enableHighAccuracy": true,
      "timeout": 5000,
      "maximumAge": 2000
    }
  );
  
  console.log("Watching position, ID:", watchId);
}

// Stop watching
function stopWatching() {
  if (watchId) {
    navigator.geolocation.clearWatch(watchId);
    console.log("Stopped watching position");
  }
}

// Calculate distance between two points (Haversine formula)
function calculateDistance(lat1, lon1, lat2, lon2) {
  const R = 6371e3; // Earth radius in meters
  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; // Distance in meters
}

// Usage
const distance = calculateDistance(51.5074, -0.1278, 48.8566, 2.3522);
console.log(`Distance: ${(distance / 1000).toFixed(2)} km`);

// Request permission (iOS 13+)
async function requestOrientationPermission() {
  if (typeof DeviceOrientationEvent !== "undefined" &&
      typeof DeviceOrientationEvent.requestPermission === "function") {
    try {
      const permission = await DeviceOrientationEvent.requestPermission();
      if (permission === "granted") {
        console.log("Orientation permission granted");
        return true;
      }
    } catch (error) {
      console.error("Orientation permission error:", error);
    }
    return false;
  }
  return true; // No permission needed (Android, older iOS)
}

// Listen for orientation changes
window.addEventListener("deviceorientation", (event) => {
  const alpha = event.alpha; // Compass direction (0-360)
  const beta = event.beta;   // Front-to-back tilt (-180 to 180)
  const gamma = event.gamma; // Left-to-right tilt (-90 to 90)
  const absolute = event.absolute;
  
  console.log(`Alpha (Z): ${alpha?.toFixed(2)}°`);
  console.log(`Beta (X): ${beta?.toFixed(2)}°`);
  console.log(`Gamma (Y): ${gamma?.toFixed(2)}°`);
  console.log(`Absolute: ${absolute}`);
  
  // Rotate element based on device orientation
  const element = document.querySelector(".compass");
  if (alpha !== null) {
    element.style.transform = `rotate(${-alpha}deg)`;
  }
});

// Compass heading (absolute orientation)
window.addEventListener("deviceorientationabsolute", (event) => {
  const heading = event.alpha; // True compass heading
  console.log(`Compass heading: ${heading?.toFixed(2)}°`);
});

// Request permission (iOS 13+)
async function requestMotionPermission() {
  if (typeof DeviceMotionEvent !== "undefined" &&
      typeof DeviceMotionEvent.requestPermission === "function") {
    try {
      const permission = await DeviceMotionEvent.requestPermission();
      return permission === "granted";
    } catch (error) {
      console.error("Motion permission error:", error);
      return false;
    }
  }
  return true;
}

// Listen for motion events
window.addEventListener("devicemotion", (event) => {
  // Acceleration (without gravity)
  const acc = event.acceleration;
  if (acc) {
    console.log(`Acceleration: x=${acc.x}, y=${acc.y}, z=${acc.z} m/s²`);
  }
  
  // Acceleration (with gravity)
  const accGrav = event.accelerationIncludingGravity;
  if (accGrav) {
    console.log(`With gravity: x=${accGrav.x}, y=${accGrav.y}, z=${accGrav.z}`);
  }
  
  // Rotation rate
  const rotation = event.rotationRate;
  if (rotation) {
    console.log(`Rotation: α=${rotation.alpha}, β=${rotation.beta}, γ=${rotation.gamma} deg/s`);
  }
  
  console.log(`Interval: ${event.interval}ms`);
});

// Shake detection
let lastTime = 0;
let lastX = 0, lastY = 0, lastZ = 0;
const shakeThreshold = 15; // Adjust sensitivity

window.addEventListener("devicemotion", (event) => {
  const acc = event.accelerationIncludingGravity;
  if (!acc) return;
  
  const currentTime = Date.now();
  const timeDiff = currentTime - lastTime;
  
  if (timeDiff > 100) {
    const deltaX = Math.abs(acc.x - lastX);
    const deltaY = Math.abs(acc.y - lastY);
    const deltaZ = Math.abs(acc.z - lastZ);
    
    const speed = (deltaX + deltaY + deltaZ) / timeDiff * 10000;
    
    if (speed > shakeThreshold) {
      console.log("Device shaken!");
      onShake();
    }
    
    lastTime = currentTime;
    lastX = acc.x;
    lastY = acc.y;
    lastZ = acc.z;
  }
});

function onShake() {
  console.log("Shake detected!");
  // Trigger shake action
}

// Check if API is available
if ("getBattery" in navigator) {
  navigator.getBattery().then((battery) => {
    // Initial state
    console.log(`Battery level: ${battery.level * 100}%`);
    console.log(`Charging: ${battery.charging}`);
    console.log(`Charging time: ${battery.chargingTime} seconds`);
    console.log(`Discharging time: ${battery.dischargingTime} seconds`);
    
    // Listen for level changes
    battery.addEventListener("levelchange", () => {
      console.log(`Battery level: ${battery.level * 100}%`);
      
      // Warn if low battery
      if (battery.level < 0.2 && !battery.charging) {
        console.warn("Low battery!");
      }
    });
    
    // Listen for charging state changes
    battery.addEventListener("chargingchange", () => {
      if (battery.charging) {
        console.log("Device is charging");
      } else {
        console.log("Device is not charging");
      }
    });
    
    // Charging time updates
    battery.addEventListener("chargingtimechange", () => {
      if (battery.chargingTime !== Infinity) {
        const minutes = Math.floor(battery.chargingTime / 60);
        console.log(`Fully charged in ${minutes} minutes`);
      }
    });
    
    // Discharging time updates
    battery.addEventListener("dischargingtimechange", () => {
      if (battery.dischargingTime !== Infinity) {
        const minutes = Math.floor(battery.dischargingTime / 60);
        console.log(`Battery empty in ${minutes} minutes`);
      }
    });
  });
} else {
  console.log("Battery Status API not supported");
}

// Check support
if ("vibrate" in navigator) {
  console.log("Vibration API supported");
} else {
  console.log("Vibration not supported");
}

// Simple vibration (200ms)
navigator.vibrate(200);

// Vibration pattern [vibrate, pause, vibrate, pause, ...]
// Vibrate 200ms, pause 100ms, vibrate 200ms
navigator.vibrate([200, 100, 200]);

// SOS pattern (... --- ...)
navigator.vibrate([
  100, 30, 100, 30, 100,  // S (...)
  200,                     // Pause
  200, 30, 200, 30, 200,  // O (---)
  200,                     // Pause
  100, 30, 100, 30, 100   // S (...)
]);

// Stop vibration
navigator.vibrate(0);
// or
navigator.vibrate([]);

// Pulse pattern (heartbeat)
function vibratePulse() {
  navigator.vibrate([50, 50, 50, 50, 200]);
}

// Success feedback
function vibrateSuccess() {
  navigator.vibrate([100, 50, 100]);
}

// Error feedback
function vibrateError() {
  navigator.vibrate([200, 100, 200, 100, 200]);
}

// Click feedback
function vibrateClick() {
  navigator.vibrate(10); // Short tap
}

// Button with haptic feedback
document.querySelector("button").addEventListener("click", () => {
  navigator.vibrate(50);
  // Handle button action
});

// Check current orientation
if (screen.orientation) {
  console.log(`Type: ${screen.orientation.type}`);
  console.log(`Angle: ${screen.orientation.angle}°`);
} else {
  console.log("Screen Orientation API not supported");
}

// Listen for orientation changes
screen.orientation?.addEventListener("change", () => {
  console.log(`Orientation changed to: ${screen.orientation.type}`);
  console.log(`Angle: ${screen.orientation.angle}°`);
  
  // Adjust layout based on orientation
  if (screen.orientation.type.startsWith("landscape")) {
    document.body.classList.add("landscape");
    document.body.classList.remove("portrait");
  } else {
    document.body.classList.add("portrait");
    document.body.classList.remove("landscape");
  }
});

// Lock orientation (requires fullscreen)
async function lockLandscape() {
  try {
    // Enter fullscreen first
    await document.documentElement.requestFullscreen();
    
    // Lock to landscape
    await screen.orientation.lock("landscape");
    console.log("Locked to landscape");
  } catch (error) {
    console.error("Failed to lock orientation:", error);
  }
}

// Lock to specific orientation
async function lockOrientation(orientation) {
  try {
    await screen.orientation.lock(orientation);
    console.log(`Locked to ${orientation}`);
  } catch (error) {
    if (error.name === "NotSupportedError") {
      console.error("Orientation lock not supported");
    } else if (error.name === "SecurityError") {
      console.error("Must be in fullscreen to lock orientation");
    } else {
      console.error("Lock failed:", error);
    }
  }
}

// Unlock orientation
function unlockOrientation() {
  screen.orientation?.unlock();
  console.log("Orientation unlocked");
}

// Game example: lock to landscape when playing
async function startGame() {
  await document.documentElement.requestFullscreen();
  await screen.orientation.lock("landscape");
  // Start game
}

function exitGame() {
  screen.orientation.unlock();
  document.exitFullscreen();
}

// Request permission (if needed)
async function requestSensorPermission() {
  try {
    const result = await navigator.permissions.query({ "name": "accelerometer" });
    if (result.state === "denied") {
      console.error("Accelerometer permission denied");
      return false;
    }
    return true;
  } catch (error) {
    console.error("Permission query failed:", error);
    return false;
  }
}

// Create accelerometer
try {
  const accelerometer = new Accelerometer({
    "frequency": 60 // 60 Hz (readings per second)
  });
  
  // Listen for readings
  accelerometer.addEventListener("reading", () => {
    console.log(`Acceleration: x=${accelerometer.x}, y=${accelerometer.y}, z=${accelerometer.z} m/s²`);
    console.log(`Timestamp: ${accelerometer.timestamp}`);
    
    // Detect device tilt
    const tiltX = Math.atan2(accelerometer.y, accelerometer.z) * 180 / Math.PI;
    const tiltY = Math.atan2(accelerometer.x, accelerometer.z) * 180 / Math.PI;
    console.log(`Tilt: X=${tiltX.toFixed(2)}°, Y=${tiltY.toFixed(2)}°`);
  });
  
  // Handle errors
  accelerometer.addEventListener("error", (event) => {
    console.error("Accelerometer error:", event.error.name, event.error.message);
  });
  
  // Start sensor
  accelerometer.start();
  console.log("Accelerometer started");
  
  // Stop after 10 seconds
  setTimeout(() => {
    accelerometer.stop();
    console.log("Accelerometer stopped");
  }, 10000);
  
} catch (error) {
  console.error("Accelerometer not supported:", error);
}

// Linear acceleration (without gravity)
try {
  const linearAccel = new LinearAccelerationSensor({ "frequency": 60 });
  
  linearAccel.addEventListener("reading", () => {
    console.log(`Linear acceleration: x=${linearAccel.x}, y=${linearAccel.y}, z=${linearAccel.z}`);
  });
  
  linearAccel.start();
} catch (error) {
  console.error("LinearAccelerationSensor not supported:", error);
}

// Gyroscope (rotation rate)
try {
  const gyroscope = new Gyroscope({ "frequency": 60 });
  
  gyroscope.addEventListener("reading", () => {
    console.log(`Rotation rate: x=${gyroscope.x}, y=${gyroscope.y}, z=${gyroscope.z} rad/s`);
    
    // Convert to degrees per second
    const degPerSec = {
      "x": gyroscope.x * 180 / Math.PI,
      "y": gyroscope.y * 180 / Math.PI,
      "z": gyroscope.z * 180 / Math.PI
    };
    console.log(`Rotation (deg/s): x=${degPerSec.x.toFixed(2)}, y=${degPerSec.y.toFixed(2)}, z=${degPerSec.z.toFixed(2)}`);
  });
  
  gyroscope.start();
} catch (error) {
  console.error("Gyroscope not supported:", error);
}

// Absolute orientation (quaternion)
try {
  const orientation = new AbsoluteOrientationSensor({ "frequency": 60 });
  
  orientation.addEventListener("reading", () => {
    // Quaternion representation
    const [x, y, z, w] = orientation.quaternion;
    console.log(`Quaternion: [${x}, ${y}, ${z}, ${w}]`);
    
    // Convert to Euler angles
    const angles = quaternionToEuler(x, y, z, w);
    console.log(`Euler angles: ${JSON.stringify(angles)}`);
  });
  
  orientation.start();
} catch (error) {
  console.error("AbsoluteOrientationSensor not supported:", error);
}

// Helper: Convert quaternion to Euler angles
function quaternionToEuler(x, y, z, w) {
  const roll = Math.atan2(2 * (w * x + y * z), 1 - 2 * (x * x + y * y));
  const pitch = Math.asin(2 * (w * y - z * x));
  const yaw = Math.atan2(2 * (w * z + x * y), 1 - 2 * (y * y + z * z));
  
  return {
    "roll": roll * 180 / Math.PI,
    "pitch": pitch * 180 / Math.PI,
    "yaw": yaw * 180 / Math.PI
  };
}

// Ambient light sensor
try {
  const lightSensor = new AmbientLightSensor({ "frequency": 1 });
  
  lightSensor.addEventListener("reading", () => {
    console.log(`Illuminance: ${lightSensor.illuminance} lux`);
    
    // Adjust UI based on ambient light
    if (lightSensor.illuminance < 50) {
      document.body.classList.add("dark-mode");
    } else {
      document.body.classList.remove("dark-mode");
    }
  });
  
  lightSensor.start();
} catch (error) {
  console.error("AmbientLightSensor not supported:", error);
}