import { Order } from '../types';
import apiService from './apiService';
import { isMockMode } from './apiService';

class OrderService {
  // 模拟订单数据
  private mockOrders: Order[];

  /**
   * 构造函数，初始化模拟订单数据
   */
  constructor() {
    this.mockOrders = [
      {
        id: 1001,
        startPoint: {
          id: 1,
          name: '瓦尔塔蓄电池昆明总店',
          longitude: 102.705745,
          latitude: 25.055281
        },
        endPoint: {
          name: '昆明德众汽车销售服务有限公司',
          longitude: 102.714686,
          latitude: 25.047134
        },
        status: 'pending',
        goodsType: '瓦尔塔AGM蓄电池',
        goodsWeight: 50,
        createTime: Date.now() - 3600000 // 1小时前创建
      },
      {
        id: 1002,
        startPoint: {
          id: 2,
          name: '瓦尔塔蓄电池盘龙区分店',
          longitude: 102.728421,
          latitude: 25.042498
        },
        endPoint: {
          name: '云南中致远汽车销售有限公司',
          longitude: 102.796212,
          latitude: 24.936947
        },
        status: 'pending',
        goodsType: '瓦尔塔EFB蓄电池',
        goodsWeight: 120,
        createTime: Date.now() - 7200000 // 2小时前创建
      },
      {
        id: 1003,
        startPoint: {
          id: 3,
          name: '瓦尔塔蓄电池西山区分店',
          longitude: 102.689190,
          latitude: 25.028234
        },
        endPoint: {
          name: '昆明宝远汽车销售服务有限公司',
          longitude: 102.756212,
          latitude: 24.986947
        },
        status: 'pending',
        goodsType: '瓦尔塔普通铅酸蓄电池',
        goodsWeight: 80,
        createTime: Date.now() - 10800000 // 3小时前创建
      }
    ];
  }

  /**
   * 获取所有待处理订单
   */
  async getPendingOrders(): Promise<Order[]> {
    if (isMockMode) {
      return [...this.mockOrders];
    }
    return apiService.getPendingOrders();
  }

  /**
   * 根据ID获取订单
   */
  async getOrderById(id: number): Promise<Order | null> {
    if (isMockMode) {
      const order = this.mockOrders.find(o => o.id === id);
      return order || null;
    }
    return apiService.getOrderById(id);
  }

  /**
   * 指派订单给货运人员
   * @param orderId 订单ID
   * @param deliveryPersonId 货运人员ID
   * @returns 指派结果，包含success状态和可选消息
   */
  async assignOrder(orderId: number, deliveryPersonId: number): Promise<{ success: boolean; message?: string }> {
    if (isMockMode) {
      // 模拟数据 - 查找订单并更新状态
      const order = this.mockOrders.find(o => o.id === orderId);
      if (order) {
        order.status = 'assigned';
        order.deliveryPersonId = deliveryPersonId;
        console.log(`[MOCK] 订单 ${orderId} 已指派给货运人员 ${deliveryPersonId}`);
        return { success: true, message: '指派成功' };
      } else {
        console.warn(`[MOCK] 订单 ${orderId} 不存在`);
        return { success: false, message: '订单不存在' };
      }
    }

    // 真实环境中调用API
    try {
      return await apiService.assignOrder(orderId, deliveryPersonId);
    } catch (error) {
      console.error('指派订单失败:', error);
      return { success: false, message: error instanceof Error ? error.message : '指派失败' };
    }
  }

  /**
   * 更新订单状态
   */
  async updateOrderStatus(orderId: number, status: Order['status']): Promise<{ success: boolean; message?: string }> {
    if (isMockMode) {
      const order = this.mockOrders.find(o => o.id === orderId);
      if (order) {
        order.status = status;
        console.log(`[MOCK] 订单 ${orderId} 状态更新为 ${status}`);
        return { success: true, message: '状态更新成功' };
      }
      return { success: false, message: '订单不存在' };
    }
    return apiService.updateOrderStatus(orderId, status).then(result => ({
      success: result.success,
      message: result.message || '状态更新成功'
    }));
  }

  /**
   * 创建新订单
   */
  async createOrder(orderData: Omit<Order, 'id' | 'createTime'>): Promise<Order> {
    if (isMockMode) {
      const newOrder: Order = {
        ...orderData,
        id: Math.max(...this.mockOrders.map(o => o.id), 1000) + 1,
        createTime: Date.now()
      };
      this.mockOrders.push(newOrder);
      return newOrder;
    }
    return apiService.createOrder(orderData);
  }

  /**
   * 获取货运人员的订单列表
   */
  async getDeliveryPersonOrders(deliveryPersonId: number): Promise<Order[]> {
    if (isMockMode) {
      // 模拟模式下返回部分订单
      return this.mockOrders.slice(0, 2);
    }
    return apiService.getDeliveryPersonOrders(deliveryPersonId);
  }

  /**
   * 删除订单
   * @param orderId 订单ID
   */
  async deleteOrder(orderId: number): Promise<void> {
    if (isMockMode) {
      // 在模拟数据中删除订单
      const index = this.mockOrders.findIndex(o => o.id === orderId);
      if (index !== -1) {
        this.mockOrders.splice(index, 1);
        console.log(`订单 ${orderId} 已删除`);
      }
      return;
    }
    return apiService.deleteOrder(orderId);
  }
}

export default new OrderService();