import orderService from '../../../services/orderService';
import { Order } from '../../../types';
import { showToast } from '../../../utils/helpers';
import { DataModule } from './dataModule';

export class OrderModule {
  private pageContext: any;
  private dataModule: DataModule;
  
  constructor(pageContext: any, dataModule: DataModule) {
    this.pageContext = pageContext;
    this.dataModule = dataModule;
  }
  
  /**
   * 加载待处理订单
   */
  async loadPendingOrders() {
    try {
      this.pageContext.setData({
        loadingOrders: true
      });
      
      const orders = await orderService.getPendingOrders();
      this.dataModule.updatePendingOrders(orders);
      
      // 更新地图标记点
      // this.updateOrderMarkers();
    } catch (error) {
      console.error('加载订单失败:', error);
      showToast('加载订单失败');
    } finally {
      this.pageContext.setData({
        loadingOrders: false
      });
    }
  }
  
  /**
   * 显示订单详情面板
   */
  showOrderPanel(order: any, position: { x: number, y: number }): void {
    // 关闭其他面板
    this.pageContext.hideAllPanels();
    
    // 更新数据模块中的当前订单和面板状态
    this.dataModule.setCurrentOrder(order);
    this.dataModule.setPanelPosition(position);
    this.dataModule.toggleOrderPanel(true);
    
    // 规划订单路线
    this.planOrderRoute(order);
  }
  
  /**
   * 隐藏订单详情面板
   */
  hideOrderPanel(): void {
    // 更新数据模块中的面板状态
    this.dataModule.toggleOrderPanel(false);
    this.dataModule.setCurrentOrder(null);
    
    // 同时取消路线显示
    this.cancelRoute();
    // 重置标记点状态
    this.pageContext.resetMarkers();
  }
  
  /**
   * 规划订单路线
   */
  async planOrderRoute(order: any): Promise<void> {
    try {
      const origin = `${order.startPoint.longitude},${order.startPoint.latitude}`;
      const destination = `${order.endPoint.longitude},${order.endPoint.latitude}`;
      
      console.log(`开始规划路线: 起点=${origin}, 终点=${destination}`);
      
      // 这里应该调用地图服务的路线规划功能
      // 目前先模拟一个简单的路线规划结果
      const routeResult = {
        distance: 1500, // 1.5公里
        duration: 300,  // 5分钟
        polyline: null  // 路线数据
      };
      
      console.log('路线规划结果:', routeResult);
      
      // 显示距离和时长信息
      if (routeResult.distance > 0 || routeResult.duration > 0) {
        const distanceStr = this.formatDistance(routeResult.distance);
        const durationStr = this.formatDuration(routeResult.duration);
        showToast(`距离: ${distanceStr}, 预计时间: ${durationStr}`);
      }
      
      // 更新数据模块中的路线信息
      this.dataModule.updateRouteInfo(routeResult.polyline, routeResult.distance, routeResult.duration);
      
    } catch (error) {
      console.error('路线规划失败:', error);
      showToast('路线规划失败');
    }
  }
  
  /**
   * 取消路线显示
   */
  cancelRoute(): void {
    // 清除数据模块中的路线信息
    this.dataModule.clearRouteInfo();
  }
  
  /**
   * 分配订单给货运人员
   */
  async assignOrder(orderId: number, deliveryPersonId: number) {
    try {
      const result = await orderService.assignOrder(orderId, deliveryPersonId);
      if (result.success) {
        showToast('订单分配成功');
        // 刷新订单列表
        await this.loadPendingOrders();
        // 刷新货运人员状态
      //  TODO  this.dataModule.notifyDeliveryPersonsUpdated();
      } else {
        showToast(result.message || '订单分配失败');
      }
    } catch (error) {
      console.error('分配订单失败:', error);
      showToast('订单分配失败');
    }
  }
  
  /**
   * 更新订单状态
   */
  async updateOrderStatus(orderId: number, status: string) {
    try {
      const result = await orderService.updateOrderStatus(orderId, status as Order['status']);
      if (result.success) {
        showToast('订单状态已更新');
        // 刷新订单列表
        await this.loadPendingOrders();
        // 刷新货运人员状态
        // this.dataModule.notifyDeliveryPersonsUpdated();
      } else {
        showToast(result.message || '订单状态更新失败');
      }
    } catch (error) {
      console.error('更新订单状态失败:', error);
      showToast('订单状态更新失败');
    }
  }

  /**
   * 删除订单
   */
  async deleteOrder(orderId: number) {
    try {
      // 确认删除操作
      const confirmResult = await new Promise<boolean>((resolve) => {
        wx.showModal({
          title: '确认删除',
          content: '确定要删除这个订单吗？此操作不可恢复。',
          success: (res) => {
            resolve(res.confirm);
          }
        });
      });

      if (!confirmResult) {
        return; // 用户取消删除
      }

      await orderService.deleteOrder(orderId);
      showToast('订单已删除');
      
      // 刷新订单列表
      await this.loadPendingOrders();
      // 刷新货运人员状态
      // this.dataModule.notifyDeliveryPersonsUpdated();
      
      // 如果当前正在查看被删除的订单，关闭订单面板
        //TODO
      // const currentOrder = this.dataModule.getCurrentOrder();
      // if (currentOrder && currentOrder.id === orderId) {
      //   this.hideOrderPanel();
      // }
      
    } catch (error) {
      console.error('删除订单失败:', error);
      showToast('删除订单失败');
    }
  }

  /**
   * 格式化距离
   */
  private formatDistance(distance: number): string {
    if (distance < 1000) {
      return `${distance}米`;
    } else {
      return `${(distance / 1000).toFixed(1)}公里`;
    }
  }
  
  /**
   * 格式化时长
   */
  private formatDuration(duration: number): string {
    const minutes = Math.floor(duration / 60);
    const seconds = duration % 60;
    
    if (minutes > 0) {
      return `${minutes}分${seconds}秒`;
    } else {
      return `${seconds}秒`;
    }
  }
  
  /**
   * 获取订单状态文本
   */
  getOrderStatusText(status: string): string {
    const statusMap: Record<string, string> = {
      'pending': '未分配',
      'assigned': '已分配',
      'in_transit': '配送中',
      'delivered': '已完成',
      'cancelled': '已取消'
    };
    return statusMap[status] || status;
  }
  
  /**
   * 获取订单状态对应的图标
   */
  getOrderStatusIcon(status: string): string {
    switch (status) {
      case 'pending':
        return '/images/order-pending.png';
      case 'assigned':
        return '/images/order-assigned.png';
      case 'in_transit':
        return '/images/order-transit.png';
      case 'delivered':
        return '/images/order-delivered.png';
      default:
        return '/images/order-pending.png';
    }
  }
}