/**
 * 百度地图服务工具
 * 封装了百度地图API的初始化和操作方法
 */

// 百度地图API加载状态
let BMapLoaded = false;
let loadingPromise = null;

/**
 * 加载百度地图API
 * @param {number} retryCount 重试次数
 * @returns {Promise} 加载完成的Promise
 */
export const loadBMapScript = async (retryCount = 0) => {
  // 如果已经加载过，直接返回
  if (BMapLoaded) {
    console.log('百度地图API已加载');
    return Promise.resolve();
  }
  
  // 如果正在加载中，返回加载Promise
  if (loadingPromise) {
    console.log('百度地图API正在加载中...');
    return loadingPromise;
  }
  
  console.log(`开始加载百度地图API... (重试次数: ${retryCount})`);
  
  // 创建加载Promise
  loadingPromise = new Promise(async (resolve, reject) => {
    try {
      // 导入环境配置
      const { BAIDU_MAP_CONFIG } = await import('../config/env');
      
      console.log('使用API密钥:', BAIDU_MAP_CONFIG.apiKey);
      console.log('完整配置:', BAIDU_MAP_CONFIG);
      
      // 检查API密钥是否有效
      if (!BAIDU_MAP_CONFIG.apiKey || BAIDU_MAP_CONFIG.apiKey === 'YOUR_VALID_BAIDU_MAP_API_KEY') {
        const error = new Error('百度地图API密钥未配置或无效');
        console.error('API密钥错误:', error);
        reject(error);
        return;
      }
      
      // 构建API URL，包含Referer参数
      let apiUrl = `https://api.map.baidu.com/api?v=3.0&ak=${BAIDU_MAP_CONFIG.apiKey}`;
      
      // 如果启用Referer校验，添加当前域名
      if (BAIDU_MAP_CONFIG.enableRefererCheck) {
        const currentDomain = window.location.hostname;
        apiUrl += `&callback=initBMap&referer=${encodeURIComponent(currentDomain)}`;
      } else {
        apiUrl += '&callback=initBMap';
      }
      
      console.log('百度地图API URL:', apiUrl);
      
      // 检查是否已经存在BMap
      if (typeof window.BMap !== 'undefined') {
        console.log('BMap已存在，直接使用');
        BMapLoaded = true;
        resolve();
        return;
      }
      
      // 创建全局回调函数
      window.initBMap = () => {
        console.log('百度地图API加载成功，BMap对象类型:', typeof window.BMap);
        console.log('BMap对象详情:', window.BMap);
        console.log('BMap.Map是否存在:', typeof window.BMap?.Map);
        
        // 清理超时定时器
        clearTimeout(timeoutId);
        
        // 等待BMap完全初始化
        setTimeout(() => {
          // 详细验证BMap对象
          if (!window.BMap) {
            console.error('BMap对象不存在');
            reject(new Error('BMap对象不存在'));
            delete window.initBMap;
            return;
          }
          
          if (typeof window.BMap.Map !== 'function') {
            console.error('BMap.Map构造函数不可用');
            reject(new Error('BMap.Map构造函数不可用'));
            delete window.initBMap;
            return;
          }
          
          if (typeof window.BMap.Point !== 'function') {
            console.error('BMap.Point构造函数不可用');
            reject(new Error('BMap.Point构造函数不可用'));
            delete window.initBMap;
            return;
          }
          
          // 测试创建Point对象
          try {
            const testPoint = new window.BMap.Point(0, 0);
            if (!testPoint || typeof testPoint.lng !== 'number') {
              throw new Error('Point对象创建失败');
            }
            console.log('BMap对象验证通过，版本:', window.BMap.version || '未知');
          } catch (error) {
            console.error('BMap对象功能测试失败:', error);
            reject(new Error(`BMap对象功能测试失败: ${error.message}`));
            delete window.initBMap;
            return;
          }
          
          BMapLoaded = true;
          resolve();
          // 清理全局回调
          delete window.initBMap;
        }, 200); // 增加等待时间
      };
      
      // 创建script标签
      const script = document.createElement('script');
      script.type = 'text/javascript';
      // 使用构建的API URL
      script.src = apiUrl;
      
      console.log('百度地图API URL:', script.src);
      
      script.onerror = async (error) => {
        console.error('百度地图脚本加载失败:', error);
        console.error('失败的URL:', script.src);
        // 清理超时定时器
        clearTimeout(timeoutId);
        // 清理script标签
        if (script.parentNode) {
          script.parentNode.removeChild(script);
        }
        // 清理全局回调
        if (window.initBMap) {
          delete window.initBMap;
        }
        
        // 尝试使用备用API密钥
        if (BAIDU_MAP_CONFIG.fallbackApiKey && BAIDU_MAP_CONFIG.fallbackApiKey !== 'YOUR_FALLBACK_API_KEY') {
          console.log('尝试使用备用API密钥...');
          try {
            const fallbackUrl = `https://api.map.baidu.com/api?v=3.0&ak=${BAIDU_MAP_CONFIG.fallbackApiKey}&callback=initBMap`;
            const fallbackScript = document.createElement('script');
            fallbackScript.type = 'text/javascript';
            fallbackScript.src = fallbackUrl;
            
            fallbackScript.onerror = () => {
              console.error('备用API密钥也加载失败');
              if (retryCount < BAIDU_MAP_CONFIG.maxRetries) {
                retryLoad();
              } else {
                reject(new Error('百度地图API加载失败，主密钥和备用密钥都无法使用'));
              }
            };
            
            window.initBMap = () => {
              console.log('备用API密钥加载成功');
              BMapLoaded = true;
              loadingPromise = null;
              resolve();
              delete window.initBMap;
            };
            
            document.head.appendChild(fallbackScript);
            return;
          } catch (fallbackError) {
            console.error('备用API密钥加载出错:', fallbackError);
          }
        }
        
        // 检查是否可以重试
        if (retryCount < BAIDU_MAP_CONFIG.maxRetries) {
          retryLoad();
        } else {
          reject(new Error('百度地图脚本加载失败，已达到最大重试次数'));
        }
        
        function retryLoad() {
          console.log(`准备重试加载百度地图API (${retryCount + 1}/${BAIDU_MAP_CONFIG.maxRetries})`);
          loadingPromise = null; // 重置加载状态
          setTimeout(async () => {
            try {
              await loadBMapScript(retryCount + 1);
              resolve();
            } catch (retryError) {
              reject(retryError);
            }
          }, BAIDU_MAP_CONFIG.retryDelay);
        }
      };
      
      // 设置超时
      const timeoutId = setTimeout(async () => {
        if (!BMapLoaded) {
          console.error('百度地图API加载超时');
          // 清理script标签
          if (script.parentNode) {
            script.parentNode.removeChild(script);
          }
          // 清理全局回调
          if (window.initBMap) {
            delete window.initBMap;
          }
          
          // 检查是否可以重试
          if (retryCount < BAIDU_MAP_CONFIG.maxRetries) {
            console.log(`准备重试加载百度地图API (${retryCount + 1}/${BAIDU_MAP_CONFIG.maxRetries})`);
            loadingPromise = null; // 重置加载状态
            setTimeout(async () => {
              try {
                await loadBMapScript(retryCount + 1);
                resolve();
              } catch (retryError) {
                reject(retryError);
              }
            }, BAIDU_MAP_CONFIG.retryDelay);
          } else {
            reject(new Error('百度地图API加载超时，已达到最大重试次数'));
          }
        }
      }, 30000); // 增加超时时间到30秒
      
      // 添加到文档中
      document.head.appendChild(script);
    } catch (error) {
      console.error('加载百度地图API时出错:', error);
      reject(error);
    }
  });
  
  return loadingPromise;
};

/**
 * 创建百度地图实例
 * @param {HTMLElement} container - 地图容器元素
 * @param {Object} options - 地图配置选项
 * @returns {Promise<BMap.Map>} 地图实例
 */
export const createMap = async (container, options = {}) => {
  try {
    console.log('开始创建地图，容器:', container);
    console.log('容器尺寸:', container.offsetWidth, 'x', container.offsetHeight);
    
    // 确保百度地图API已加载
    await loadBMapScript();
    
    // 导入环境配置
    const { BAIDU_MAP_CONFIG } = await import('../config/env');
    
    console.log('百度地图配置:', BAIDU_MAP_CONFIG);
    
    // 检查BMap是否可用
    if (typeof window.BMap === 'undefined' || !window.BMap) {
      const error = new Error('百度地图API未正确加载，BMap对象不存在');
      console.error('BMap未定义:', error);
      throw error;
    }
    
    // 验证BMap对象的关键属性
    if (typeof window.BMap.Map !== 'function') {
      const error = new Error('BMap.Map构造函数不可用');
      console.error('BMap.Map不可用:', error);
      throw error;
    }
    
    if (typeof window.BMap.Point !== 'function') {
      const error = new Error('BMap.Point构造函数不可用');
      console.error('BMap.Point不可用:', error);
      throw error;
    }
    
    console.log('BMap对象可用，版本:', window.BMap.version || '未知');
    console.log('BMap对象详细信息:', {
      Map: typeof window.BMap.Map,
      Point: typeof window.BMap.Point,
      Marker: typeof window.BMap.Marker,
      InfoWindow: typeof window.BMap.InfoWindow
    });
    
    // 默认配置
    const defaultOptions = {
      center: new BMap.Point(BAIDU_MAP_CONFIG.defaultCenter.lng, BAIDU_MAP_CONFIG.defaultCenter.lat), // 宁夏中心点
      zoom: BAIDU_MAP_CONFIG.defaultZoom,   // 默认缩放级别
      enableMapClick: true,                 // 启用地图点击
      enableScrollWheelZoom: true,          // 启用滚轮缩放
      enableDragging: true,                 // 启用拖拽
      enableDoubleClickZoom: true,          // 启用双击缩放
      enableKeyboard: true                  // 启用键盘控制
    };
    
    // 合并配置
    const mergedOptions = { ...defaultOptions, ...options };
    
    console.log('地图配置选项:', mergedOptions);
    
    // 验证容器
    if (!container || !container.offsetWidth || !container.offsetHeight) {
      throw new Error('地图容器无效或没有设置尺寸');
    }
    
    // 验证BMap对象
    if (!window.BMap || typeof window.BMap.Map !== 'function') {
      throw new Error('BMap对象未正确加载');
    }
    
    // 检查容器及其父级的样式问题
    let currentElement = container;
    while (currentElement && currentElement !== document.body) {
      const computedStyle = window.getComputedStyle(currentElement);
      console.log('检查元素样式:', {
        tagName: currentElement.tagName,
        id: currentElement.id,
        className: currentElement.className,
        position: computedStyle.position,
        display: computedStyle.display,
        visibility: computedStyle.visibility
      });
      
      // 检查是否有问题样式
      if (computedStyle.position === 'fixed') {
        console.warn('发现position: fixed的父级元素，可能导致地图初始化失败');
      }
      if (computedStyle.display === 'none') {
        console.warn('发现display: none的父级元素，可能导致地图初始化失败');
      }
      
      currentElement = currentElement.parentElement;
    }
    
    // 临时修复：确保容器有正确的样式
    const originalStyle = {
      position: container.style.position,
      display: container.style.display,
      visibility: container.style.visibility
    };
    
    // 设置临时样式确保地图能正确初始化
    container.style.position = 'relative';
    container.style.display = 'block';
    container.style.visibility = 'visible';
    
    console.log('创建BMap.Map实例...');
    console.log('容器信息:', {
      id: container.id,
      className: container.className,
      offsetWidth: container.offsetWidth,
      offsetHeight: container.offsetHeight,
      clientWidth: container.clientWidth,
      clientHeight: container.clientHeight,
      style: container.style.cssText
    });
    
    // 最终验证容器状态
    if (!container || !container.parentNode) {
      throw new Error('地图容器无效或已从DOM中移除');
    }
    
    if (container.offsetWidth === 0 || container.offsetHeight === 0) {
      throw new Error('地图容器尺寸为0，无法创建地图');
    }
    
    let map;
    try {
      // 临时移除所有可能干扰的样式
      const tempStyles = {};
      const styleProps = ['position', 'display', 'visibility', 'transform', 'opacity', 'zIndex'];
      
      styleProps.forEach(prop => {
        tempStyles[prop] = container.style[prop];
        container.style[prop] = '';
      });
      
      // 确保容器有基本样式
      container.style.position = 'relative';
      container.style.display = 'block';
      container.style.visibility = 'visible';
      container.style.width = container.offsetWidth + 'px';
      container.style.height = container.offsetHeight + 'px';
      
      console.log('创建地图前的容器状态:', {
        offsetWidth: container.offsetWidth,
        offsetHeight: container.offsetHeight,
        style: container.style.cssText
      });
      
      // 再次验证BMap对象
      if (!window.BMap || typeof window.BMap.Map !== 'function') {
        throw new Error('BMap.Map构造函数不可用');
      }
      
      // 创建地图实例，添加错误捕获
      try {
        map = new window.BMap.Map(container);
        console.log('地图实例创建成功:', map);
      } catch (mapError) {
        console.error('BMap.Map构造函数调用失败:', mapError);
        throw new Error(`地图实例创建失败: ${mapError.message}`);
      }
      
      // 恢复临时移除的样式
      styleProps.forEach(prop => {
        if (tempStyles[prop]) {
          container.style[prop] = tempStyles[prop];
        }
      });
      
    } catch (error) {
      console.error('地图实例创建失败:', error);
      // 恢复所有原始样式
      container.style.position = originalStyle.position;
      container.style.display = originalStyle.display;
      container.style.visibility = originalStyle.visibility;
      throw error;
    }
    
    // 恢复原始样式（如果地图创建成功）
    container.style.position = originalStyle.position;
    container.style.display = originalStyle.display;
    container.style.visibility = originalStyle.visibility;
    
    // 验证地图实例
    if (!map || typeof map.centerAndZoom !== 'function') {
      throw new Error('地图实例创建失败');
    }
    
    // 设置中心点和缩放级别
    console.log('设置地图中心点和缩放级别:', mergedOptions.center, mergedOptions.zoom);
    map.centerAndZoom(mergedOptions.center, mergedOptions.zoom);
    
    // 监听地图加载完成事件
    map.addEventListener('tilesloaded', function() {
      console.log('百度地图瓦片加载完成');
    });
    
    map.addEventListener('load', function() {
      console.log('百度地图完全加载完成');
    });
    
    // 强制刷新地图
    setTimeout(() => {
      console.log('强制刷新地图');
      map.reset();
    }, 100);
    
    // 延迟确保地图完全渲染
    setTimeout(() => {
      console.log('地图渲染完成');
      // 移除map.reset()调用，避免缩放时重置地图
    }, 100);
    
    // 添加地图类型控件
    console.log('添加地图控件...');
    map.addControl(new window.BMap.MapTypeControl());
    
    // 添加增强的缩放控件
    const navigationControl = new window.BMap.NavigationControl({
      anchor: window.BMAP_ANCHOR_TOP_LEFT,
      type: window.BMAP_NAVIGATION_CONTROL_LARGE,
      enableGeolocation: false
    });
    map.addControl(navigationControl);
    
    // 添加缩放控件（滑块式）
    const scaleControl = new window.BMap.ScaleControl({
      anchor: window.BMAP_ANCHOR_BOTTOM_LEFT
    });
    map.addControl(scaleControl);
    
    // 添加概览地图控件
    const overviewMapControl = new window.BMap.OverviewMapControl({
      anchor: window.BMAP_ANCHOR_TOP_RIGHT,
      isOpen: false
    });
    map.addControl(overviewMapControl);
    
    // 设置缩放范围
    map.setMinZoom(3);
    map.setMaxZoom(19);
    
    // 配置地图功能
    if (mergedOptions.enableScrollWheelZoom) {
      map.enableScrollWheelZoom();
    }
    
    if (mergedOptions.enableDragging) {
      map.enableDragging();
    } else {
      map.disableDragging();
    }
    
    if (mergedOptions.enableDoubleClickZoom) {
      map.enableDoubleClickZoom();
    } else {
      map.disableDoubleClickZoom();
    }
    
    if (mergedOptions.enableKeyboard) {
      map.enableKeyboard();
    } else {
      map.disableKeyboard();
    }
    
    console.log('百度地图创建成功:', map);
    
    return map;
  } catch (error) {
    console.error('创建百度地图失败:', error);
    throw error;
  }
};

/**
 * 在地图上添加标记
 * @param {BMap.Map} map - 百度地图实例
 * @param {Array} markers - 标记点数据数组
 * @param {Function} onClick - 点击标记的回调函数
 * @returns {Array<BMap.Marker>} 标记点实例数组
 */
export const addMarkers = (map, markers = [], onClick = null) => {
  // 验证地图实例是否有效
  if (!map || typeof map.addOverlay !== 'function') {
    console.error('addMarkers: 无效的地图实例', map);
    return [];
  }
  
  // 验证BMap对象是否可用
  if (!window.BMap || typeof window.BMap.Point !== 'function' || typeof window.BMap.Marker !== 'function') {
    console.error('addMarkers: BMap对象不可用');
    return [];
  }
  
  return markers.map(markerData => {
    try {
      // 验证标记数据
      if (!markerData || !markerData.location || typeof markerData.location.lng !== 'number' || typeof markerData.location.lat !== 'number') {
        console.error('addMarkers: 无效的标记数据', markerData);
        return null;
      }
      
      // 创建标记点
      const point = new window.BMap.Point(markerData.location.lng, markerData.location.lat);
      const marker = new window.BMap.Marker(point);
      
      // 添加标记到地图
      map.addOverlay(marker);
    
      // 创建信息窗口
      if (markerData.title || markerData.content) {
        const infoWindow = new window.BMap.InfoWindow(
          `<div class="map-info-window">
            ${markerData.content || ''}
          </div>`, 
          {
            title: markerData.title || '',
            width: 250,
            height: 120,
            enableMessage: false
          }
        );
        
        // 添加点击事件
        marker.addEventListener('click', () => {
          marker.openInfoWindow(infoWindow);
          
          // 如果有自定义点击回调，则调用
          if (onClick && typeof onClick === 'function') {
            onClick(markerData, marker);
          }
        });
      }
      
      return marker;
    } catch (error) {
      console.error('addMarkers: 创建标记失败:', error, markerData);
      return null;
    }
  }).filter(marker => marker !== null);
};

/**
 * 清除地图上的所有覆盖物
 * @param {BMap.Map} map - 百度地图实例
 */
export const clearOverlays = (map) => {
  if (!map || typeof map.clearOverlays !== 'function') {
    console.warn('clearOverlays: 无效的地图实例，已跳过清理');
    return;
  }
  map.clearOverlays();
};

/**
 * 设置地图视图以包含所有标记点
 * @param {BMap.Map} map - 百度地图实例
 * @param {Array<BMap.Point>} points - 点数组
 * @param {Number} padding - 边距，单位像素
 */
export const setViewToFitMarkers = (map, points, padding = 50) => {
  if (!map) {
    console.warn('setViewToFitMarkers: 无效的地图实例，已跳过设置视图');
    return;
  }
  if (!points || points.length === 0) return;
  
  // 如果只有一个点，直接居中
  if (points.length === 1) {
    map.centerAndZoom(points[0], 15);
    return;
  }
  
  // 创建视图范围
  const viewport = map.getViewport(points, { margins: [padding, padding, padding, padding] });
  map.setViewport(viewport);
};

/**
 * 转换养殖场数据为地图标记数据
 * @param {Array} farms - 养殖场数据数组
 * @returns {Array} 地图标记数据数组
 */
export const convertFarmsToMarkers = (farms = []) => {
  return farms
    .filter(farm => {
      // 只保留有有效位置信息的农场
      return farm.location && 
             typeof farm.location.lat === 'number' && 
             typeof farm.location.lng === 'number';
    })
    .map(farm => {
      // 计算动物总数
      const animalCount = farm.animals ? 
        farm.animals.reduce((total, animal) => total + (animal.count || 0), 0) : 0;
      
      // 计算在线设备数
      const onlineDevices = farm.devices ? 
        farm.devices.filter(device => device.status === 'online').length : 0;
      const totalDevices = farm.devices ? farm.devices.length : 0;
      
      return {
        id: farm.id,
        title: farm.name,
        location: farm.location,
        content: `
          <div style="padding: 8px; font-size: 14px;">
            <h4 style="margin: 0 0 8px 0; color: #1890ff;">${farm.name}</h4>
            <p style="margin: 4px 0;"><strong>类型:</strong> ${farm.type || '未知'}</p>
            <p style="margin: 4px 0;"><strong>动物数量:</strong> ${animalCount} 只</p>
            <p style="margin: 4px 0;"><strong>设备状态:</strong> ${onlineDevices}/${totalDevices} 在线</p>
            <p style="margin: 4px 0;"><strong>联系人:</strong> ${farm.contact || '未知'}</p>
            <p style="margin: 4px 0;"><strong>地址:</strong> ${farm.address || '未知'}</p>
            <p style="margin: 4px 0; color: #666;"><strong>坐标:</strong> ${farm.location.lat.toFixed(4)}, ${farm.location.lng.toFixed(4)}</p>
          </div>
        `,
        originalData: farm
      };
    });
};