#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
设备朝向检测模块
用于自动获取设备的GPS位置和朝向信息
"""

import requests
import time
import json
import math
from typing import Tuple, Optional, Dict
from . import config


class OrientationDetector:
    """设备朝向检测器"""
    
    def __init__(self):
        self.current_location = None  # (lat, lng, accuracy)
        self.current_heading = None   # 设备朝向角度
        self.last_update = 0
        self.gps_cache_duration = 300  # GPS缓存5分钟
        
    def get_current_gps_location(self) -> Optional[Tuple[float, float, float]]:
        """
        获取当前设备的GPS位置
        返回: (纬度, 经度, 精度) 或 None
        """
        try:
            # 首先尝试使用系统API (需要安装相关库)
            location = self._get_system_gps()
            if location:
                return location
            
            # 如果系统API不可用，使用IP地理定位作为备选
            location = self._get_ip_geolocation()
            if location:
                print("🌐 使用IP地理定位获取位置（精度较低）")
                return location
                
            return None
            
        except Exception as e:
            print(f"❌ GPS位置获取失败: {e}")
            return None
    
    def _get_system_gps(self) -> Optional[Tuple[float, float, float]]:
        """尝试使用系统GPS API获取位置"""
        try:
            # 在Windows上可以使用Windows Location API
            # 这里提供一个框架，实际实现需要根据操作系统选择合适的API
            import platform
            system = platform.system()
            
            if system == "Windows":
                return self._get_windows_location()
            elif system == "Darwin":  # macOS
                return self._get_macos_location()
            elif system == "Linux":
                return self._get_linux_location()
                
        except ImportError:
            print("💡 系统定位API不可用，将使用IP定位")
            
        return None
    
    def _get_windows_location(self) -> Optional[Tuple[float, float, float]]:
        """Windows系统GPS定位"""
        try:
            # 使用Windows Location API
            import winrt.windows.devices.geolocation as geo
            
            locator = geo.Geolocator()
            # 设置期望精度
            locator.desired_accuracy = geo.PositionAccuracy.HIGH
            
            print("🔍 正在获取Windows系统GPS位置...")
            
            # 获取位置信息（同步方式）
            position = locator.get_geoposition_async().get()
            
            lat = position.coordinate.point.position.latitude
            lng = position.coordinate.point.position.longitude
            accuracy = position.coordinate.accuracy
            
            print(f"✅ Windows GPS获取成功: ({lat:.6f}, {lng:.6f}), 精度: ±{accuracy:.0f}m")
            return (lat, lng, accuracy)
            
        except Exception as e:
            print(f"⚠️ Windows GPS API失败: {e}")
            return None
    
    def _get_macos_location(self) -> Optional[Tuple[float, float, float]]:
        """macOS系统GPS定位"""
        try:
            # macOS可以使用Core Location框架
            # 这里提供一个基本框架
            print("💡 macOS GPS定位需要额外配置，建议使用IP定位")
            return None
            
        except Exception as e:
            print(f"⚠️ macOS GPS API失败: {e}")
            return None
    
    def _get_linux_location(self) -> Optional[Tuple[float, float, float]]:
        """Linux系统GPS定位"""
        try:
            # Linux可以使用gpsd或NetworkManager
            print("💡 Linux GPS定位需要额外配置，建议使用IP定位")
            return None
            
        except Exception as e:
            print(f"⚠️ Linux GPS API失败: {e}")
            return None
    
    def _get_ip_geolocation(self) -> Optional[Tuple[float, float, float]]:
        """使用IP地址进行地理定位"""
        try:
            print("🌐 正在使用IP地理定位...")
            
            # 使用免费的IP地理定位服务
            response = requests.get("http://ip-api.com/json/", timeout=10)
            
            if response.status_code == 200:
                data = response.json()
                
                if data.get('status') == 'success':
                    lat = float(data.get('lat', 0))
                    lng = float(data.get('lon', 0))
                    accuracy = 10000  # IP定位精度通常在10km左右
                    
                    city = data.get('city', '未知')
                    region = data.get('regionName', '未知')
                    country = data.get('country', '未知')
                    
                    print(f"✅ IP定位成功: {city}, {region}, {country}")
                    print(f"📍 位置: ({lat:.6f}, {lng:.6f}), 精度: ±{accuracy:.0f}m")
                    
                    return (lat, lng, accuracy)
                    
        except Exception as e:
            print(f"❌ IP地理定位失败: {e}")
            
        return None
    
    def get_device_heading(self) -> Optional[float]:
        """
        获取设备朝向（磁力计方向）
        返回: 角度 (0-360度，0为正北) 或 None
        """
        try:
            # 桌面设备通常没有磁力计，返回默认朝向
            # 可以根据摄像头位置或用户设置来确定朝向
            print("💡 桌面设备朝向检测有限，使用默认朝向")
            
            # 假设用户面向屏幕，摄像头朝向用户
            # 如果摄像头在屏幕上方，那么朝向就是用户的相反方向
            default_heading = 180.0  # 假设用户面向南方，摄像头朝向北方
            
            return default_heading
            
        except Exception as e:
            print(f"❌ 设备朝向检测失败: {e}")
            return None
    
    def calculate_camera_heading_facing_user(self, user_heading: float) -> float:
        """
        计算摄像头朝向用户的角度
        
        Args:
            user_heading: 用户朝向角度 (0-360度)
            
        Returns:
            摄像头应该设置的朝向角度
        """
        # 摄像头朝向用户，即朝向用户相反的方向
        camera_heading = (user_heading + 180) % 360
        return camera_heading
    
    def auto_configure_camera_location(self) -> Dict:
        """
        自动配置摄像头位置和朝向
        
        Returns:
            配置信息字典
        """
        result = {
            'success': False,
            'gps_location': None,
            'device_heading': None,
            'camera_heading': None,
            'method': None,
            'accuracy': None
        }
        
        print("🚀 开始自动配置摄像头位置和朝向...")
        
        # 1. 获取GPS位置
        gps_location = self.get_current_gps_location()
        if not gps_location:
            print("❌ 无法获取GPS位置，自动配置失败")
            return result
            
        lat, lng, accuracy = gps_location
        result['gps_location'] = (lat, lng)
        result['accuracy'] = accuracy
        
        # 2. 获取设备朝向
        device_heading = self.get_device_heading()
        if device_heading is None:
            print("⚠️ 无法获取设备朝向，使用默认朝向")
            device_heading = 0.0  # 默认朝北
            
        result['device_heading'] = device_heading
        
        # 3. 计算摄像头朝向（朝向用户）
        camera_heading = self.calculate_camera_heading_facing_user(device_heading)
        result['camera_heading'] = camera_heading
        
        # 4. 确定配置方法
        if accuracy < 100:
            result['method'] = 'GPS'
        else:
            result['method'] = 'IP定位'
            
        result['success'] = True
        
        print(f"✅ 自动配置完成:")
        print(f"📍 GPS位置: ({lat:.6f}, {lng:.6f})")
        print(f"🧭 设备朝向: {device_heading:.1f}°")
        print(f"📷 摄像头朝向: {camera_heading:.1f}°")
        print(f"🎯 定位方法: {result['method']}")
        print(f"📏 定位精度: ±{accuracy:.0f}m")
        
        return result
    
    def update_camera_config(self, gps_location: Tuple[float, float], camera_heading: float):
        """
        更新摄像头配置文件
        
        Args:
            gps_location: (纬度, 经度)
            camera_heading: 摄像头朝向角度
        """
        try:
            from tools.setup_camera_location import update_config_file
            
            lat, lng = gps_location
            
            # 更新配置文件
            update_config_file(lat, lng, camera_heading)
            
            # 同时更新运行时配置
            config.CAMERA_LATITUDE = lat
            config.CAMERA_LONGITUDE = lng
            config.CAMERA_HEADING = camera_heading
            
            print(f"✅ 摄像头配置已更新")
            print(f"📍 新位置: ({lat:.6f}, {lng:.6f})")
            print(f"🧭 新朝向: {camera_heading:.1f}°")
            
        except Exception as e:
            print(f"❌ 配置更新失败: {e}")


def main():
    """测试函数"""
    print("🧭 设备朝向检测器测试")
    print("=" * 50)
    
    detector = OrientationDetector()
    
    # 测试自动配置
    result = detector.auto_configure_camera_location()
    
    if result['success']:
        print("\n🎯 是否应用此配置? (y/n): ", end="")
        choice = input().strip().lower()
        
        if choice == 'y':
            detector.update_camera_config(
                result['gps_location'], 
                result['camera_heading']
            )
            print("✅ 配置已应用")
        else:
            print("⏭️ 配置未应用")
    else:
        print("❌ 自动配置失败")


if __name__ == "__main__":
    main() 