import Taro from '@tarojs/taro';
import { formatDateTime, clearOrderTripStorage, debounce, reportEvent } from '../../../../utils/Robotaxi-public-method';
import { saveOrder, getOrderPayment, cancelOrder, endOrder } from '../../../api/begin-route';
import { getAgreement } from '../../../api/home';
import { checkOtp } from '../../../../utils/tools';
import { jumpTo } from '../../../../utils/jump';

type Deps = {
  /** 行程状态 */
  tripStatus: number;
  /** 订单 ID */
  orderId: string;
  /** 结束点 */
  endSite: any;
  /** 起始点 */
  startSite: any;
  /** 费用信息 */
  fareEstimate: any;
  /** 路线错误标记 */
  routeAndFareError: boolean;
  /** 下单提交中 */
  callSubmitting: boolean;
  /** 取消类型 */
  cancelType: number;
  /** 状态设置 */
  setTripStatus: (value: number) => void;
  /** 订单设置 */
  setOrderId: (value: string) => void;
  /** 车辆信息设置 */
  setVehicleInfo: (value: any) => void;
  /** 下单提交设置 */
  setCallSubmitting: (value: boolean) => void;
  /** 取消类型设置 */
  setCancelType: (value: number) => void;
  /** 取消弹窗设置 */
  setShowCancelPopup: (value: boolean) => void;
  /** 取消弹窗等待分钟数 */
  setCancelPopupWaitMinutes: (value: number | null) => void;
  /** 步行点设置 */
  setWalkingPoints: (value: any[]) => void;
  /** 步行时长设置 */
  setWalkingTime: (value: number) => void;
  /** 纬度设置 */
  setLatitude: (value: number) => void;
  /** 经度设置 */
  setLongitude: (value: number) => void;
  /** 打开取消弹窗 */
  setShowOverRoutePopup: (value: boolean) => void;
  /** 打开协议弹窗 */
  handleOpenPrivacyPopup: () => void;
  /** 距离与城市校验 */
  checkDistanceAndCityReady: (startSite: any) => Promise<number | null>;
  /** 绑定 socket 监听 */
  bindSocketListeners: () => void;
  /** 更新步行路线 */
  routeUpdateWalkingRouteForStart: (startSite: any) => void;
  /** 请求预估路线 */
  routeRequestRouteAndFare: (originLat: number, originLng: number, destLat: number, destLng: number, force?: boolean) => void;
};

/**
 * 订单动作编排：下单、取消、结束、支付。
 */
export default function useOrderActions(deps: Deps) {
  const NOT_AGREED_TEXT = 'Not agreed to the agreement'; // 协议未同意返回文案关键字

  // 标准化文本，兼容普通空格与不可见空格差异
  const normalizeText = (value: any) => String(value || '').replace(/\s+/g, ' ').trim().toLowerCase();

  // 判断接口返回是否为“未同意协议”场景
  const isNotAgreedMessage = (value: any) => normalizeText(value).includes(NOT_AGREED_TEXT);

  // 协议接口约定：true=已同意，false=未同意
  const resolveAgreementStatus = (result: any) => result === true;

  /**
   * 结束下单中状态。
   */
  const stopCallSubmitting = () => {
    deps.setCallSubmitting(false);
  };

  /**
   * 提交订单。
   */
  const submitOrder = async (s: any, openCityId: number) => {
    const waitingTime = Number(deps.fareEstimate?.waitingTime || 0);
    const estimatedTime = formatDateTime(new Date(Date.now() + waitingTime * 60 * 1000));
    const cachedCouponId = Taro.getStorageSync('selectedCouponId') || '';
    const payload: any = {
      endPointId: deps.endSite.id,
      openCityId,
      placementAddress: s?.name,
      placementLat: s?.latitude,
      placementLon: s?.longitude,
      startPointId: s?.id,
      xpElectronicFenceAreaId: s?.electronicAreaId || deps.endSite?.electronicAreaId || '',
      estimatedTime
    };
    if (cachedCouponId) payload.userCouponId = cachedCouponId;
    const res = await saveOrder(payload);
    const status_code = res?.orderId ? 1 : 0;
    reportEvent('RT_xcx_order_submit', {
      total_amount: deps.fareEstimate.originalFare,
      payable_amount: deps.fareEstimate.finalFare,
      coupon_id: cachedCouponId,
      status_code
    });
    if (isNotAgreedMessage(res) || isNotAgreedMessage(res?.data) || isNotAgreedMessage(res?.msg)) {
      deps.handleOpenPrivacyPopup();
      return null;
    }
    if (typeof res === 'string') {
      Taro.showToast({ title: res, icon: 'none', mask: true });
      setTimeout(() => {
        Taro.reLaunch({ url: '/pages/home/index' });
      }, 1500);
      return null;
    }
    if (!res?.orderId) {
      Taro.showToast({ title: '下单失败，请重试', icon: 'none' });
      return null;
    }
    Taro.removeStorageSync('selectedCouponId');
    Taro.setStorageSync('orderId', res.orderId);
    return res.orderId;
  };

  /**
   * 登录校验。
   */
  const checkCallAuth = async () => {
    const otp = await checkOtp(false);
    if (otp) return true;
    stopCallSubmitting();
    jumpTo({ url: '/pages/user/login?hideBack=1' });
    return false;
  };

  /**
   * 路线校验。
   */
  const checkRouteReady = () => {
    if (deps.endSite.name && !deps.routeAndFareError) return true;
    if (!deps.endSite.name) {
      Taro.showToast({ title: '请选择站点', icon: 'none' });
    }
    stopCallSubmitting();
    return false;
  };

  /**
   * 读取下单起点。
   */
  const getStartSiteForCall = () => {
    const s = Taro.getStorageSync('startSite');
    if (s?.latitude && s?.longitude && deps.endSite?.latitude && deps.endSite?.longitude) {
      return s;
    }
    Taro.showToast({ title: '请先选择起终点', icon: 'none' });
    stopCallSubmitting();
    return null;
  };

  /**
   * 呼叫车辆。
   */
  const callImmediately = debounce(async () => {
    if (deps.callSubmitting) return;
    deps.setCallSubmitting(true);
    const authReady = await checkCallAuth();
    if (!authReady) return;
    try {
      const agreementResult = await getAgreement();
      const hasAgreed = resolveAgreementStatus(agreementResult);
      if (!hasAgreed) {
        deps.handleOpenPrivacyPopup();
        stopCallSubmitting();
        return;
      }
    } catch (error) {
      Taro.showToast({ title: '协议校验失败，请重试', icon: 'none' });
      stopCallSubmitting();
      return;
    }
    const routeReady = checkRouteReady();
    if (!routeReady) return;
    const s = getStartSiteForCall();
    if (!s) return;
    const openCityId = await deps.checkDistanceAndCityReady(s);
    if (!openCityId) return;
    try {
      const nextOrderId = await submitOrder(s, openCityId);
      if (!nextOrderId) {
        stopCallSubmitting();
        return;
      }
      deps.setOrderId(nextOrderId);
      deps.setTripStatus(2);
      deps.bindSocketListeners();
    } catch (error) {
      stopCallSubmitting();
    }
  }, 500);

  /**
   * 清理活跃订单运行时缓存。
   */
  const clearActiveOrderRuntime = () => {
    deps.setOrderId('');
    deps.setVehicleInfo({});
    clearOrderTripStorage();
    Taro.removeStorageSync('pickupEndTime');
    Taro.removeStorageSync('waitingTimerStartAt');
    Taro.removeStorageSync('waitingTimerElapsed');
  };

  /**
   * 重启发单规划。
   */
  const restartPlanningRoute = () => {
    deps.setShowCancelPopup(false);
    deps.setCancelPopupWaitMinutes(null);
    deps.setTripStatus(1);
    deps.routeUpdateWalkingRouteForStart(deps.startSite);
    const s = Taro.getStorageSync('startSite');
    const e = Taro.getStorageSync('endSite');
    if (s?.latitude && s?.longitude && e?.longitude && e?.latitude) {
      deps.routeRequestRouteAndFare(s.latitude, s.longitude, e.latitude, e.longitude, true);
    }
  };

  /**
   * 确认取消。
   */
  const handleConfirmCancel = async () => {
    if (deps.cancelType === 5) {
      handleOpenCancelPopupWithType(5);
      return;
    }
    const targetOrderId = deps.orderId || Taro.getStorageSync('orderId');
    if (targetOrderId) {
      try {
        await cancelOrder(targetOrderId);
        Taro.showToast({ title: '行程已取消', icon: 'success' });
        clearActiveOrderRuntime();
        deps.setTripStatus(10);
        deps.setCancelType(4);
        return;
      } catch (error) {
        Taro.showToast({ title: '取消订单失败，请重试', icon: 'none' });
        return;
      }
    }
    restartPlanningRoute();
  };

  /**
   * 订单超时再来一单。
   */
  const handleOpenCancelPopupWithType = (type: number) => {
    clearActiveOrderRuntime();
    deps.setCancelType(type);
    restartPlanningRoute();
  };

  /**
   * 根据状态打开取消弹窗。
   */
  const handleOpenCancelPopupByTripStatus = (status: number, displayInfo?: any) => {
    const waitMinutes = Number(displayInfo?.waitMinutes);
    if (status === 3 && Number.isFinite(waitMinutes)) {
      deps.setCancelPopupWaitMinutes(waitMinutes);
    } else {
      deps.setCancelPopupWaitMinutes(null);
    }
    if (displayInfo?.durationDisplay && ![3, 5].includes(status)) {
      deps.setCancelType(2);
      deps.setShowCancelPopup(true);
      return;
    }
    if ([2, 3].includes(status)) deps.setCancelType(1);
    if (status == 4) deps.setCancelType(2);
    if (status == 5) deps.setCancelType(3);
    deps.setShowCancelPopup(true);
  };

  /**
   * 确认结束行程。
   */
  const handleConfirmOverRoute = () => {
    deps.setShowOverRoutePopup(false);
    deps.setTripStatus(8);
  };

  /**
   * 完成倒计时超时处理。
   */
  const handleFinishCountdownTimeout = async () => {
    const targetOrderId = deps.orderId || Taro.getStorageSync('orderId');
    if (!targetOrderId) return;
    try {
      await endOrder(targetOrderId);
    } catch (error) {
    }
    deps.setTripStatus(8);
  };

  /**
   * 支付处理。
   */
  const handlePay = async () => {
    const targetOrderId = deps.orderId || Taro.getStorageSync('orderId');
    if (!targetOrderId) {
      Taro.showToast({ title: '订单信息缺失，无法支付', icon: 'none' });
      return;
    }
    try {
      await getOrderPayment({ orderId: targetOrderId });
      Taro.showToast({ title: '支付成功', icon: 'none' });
      deps.setTripStatus(9);
      Taro.setStorageSync('tripStatus', 9);
    } catch (error) {
      Taro.showToast({ title: '支付失败，请重试', icon: 'none' });
      return;
    }
  };

  return {
    callImmediately,
    stopCallSubmitting,
    handleConfirmCancel,
    handleOpenCancelPopupWithType,
    handleOpenCancelPopupByTripStatus,
    handleConfirmOverRoute,
    handleFinishCountdownTimeout,
    handlePay,
    clearActiveOrderRuntime,
    restartPlanningRoute
  };
}