// 酒店相关接口
// 磐河旅行开放平台 - 酒店模块
// AppKey: 34c130be1d611fd21c9f35488c689a0d
// SecretKey: 766067b446871059606ec130cc33bbb6
// 接口网关域名：http://api.panhe.net

import { get, post } from '@/core/http/http-client'
import { buildOssUrl } from '@/core/media/oss-url'
import { digestHex } from '@/core/infra/hash-digest'
// 磐河旅行 API 基础配置
const PANHE_API_BASE = 'http://api.panhe.net'

/**
 * 搜索酒店列表
 * 接口地址：http://api.panhe.net/hotel/searchHotelList
 * @param {Object} params
 * @param {string} params.cityName - 城市名称（与cityCode必填一个）
 * @param {string} params.cityCode - 城市code（与cityName必填一个）
 * @param {string} params.checkInDate - 入住日期（格式：yyyy-MM-dd）
 * @param {string} params.checkOutDate - 离店日期（格式：yyyy-MM-dd）
 * @param {number} params.pageIndex - 页码（从1开始）
 * @param {number} params.pageSize - 每页请求酒店数量（取值范围：1-20，默认为10）
 * @param {string} params.queryText - 查询关键词（可选）
 * @param {string} params.hotelStars - 酒店星级(2,3,4,5)，多个以逗号分隔（可选）
 * @param {number} params.minPrice - 最小价格（可选）
 * @param {number} params.maxPrice - 最大价格（可选）
 * @param {number} params.longitude - 经度（可选）
 * @param {number} params.latitude - 纬度（可选）
 * @param {number} params.range - 方圆公里数（可选，默认100KM）
 * @param {string} params.districtName - 行政区名称（可选）
 * @param {string} params.brands - 酒店品牌，多个以逗号分隔（可选）
 * @param {number} params.sort - 排序类型：0=默认,1=价格升序,2=价格降序,3=评分降序,4=距离升序（可选）
 * @param {number} params.availableSaleStatus - 可售状态：1=仅查询有可售房间的酒店（可选）
 */
export async function pullHotelList({
  cityName = '',
  cityCode = '',
  checkInDate = '',
  checkOutDate = '',
  pageIndex = 1,
  pageSize = 10,
  queryText = '',
  hotelStars = '',
  minPrice = null,
  maxPrice = null,
  longitude = null,
  latitude = null,
  range = 0,
  districtName = '',
  brands = '',
  sort = 0,
  availableSaleStatus = null
} = {}) {
  const params = {
    cityName,
    cityCode,
    checkInDate,
    checkOutDate,
    pageIndex,
    pageSize,
    queryText,
    hotelStars,
    minPrice,
    maxPrice,
    longitude,
    latitude,
    range,
    districtName,
    brands,
    sort,
    availableSaleStatus
  }

  const { data } = await get(`${PANHE_API_BASE}/hotel/searchHotelList`, params)
  const body = data || {}

  const hotelList = (Array.isArray(body.hotelList) ? body.hotelList : []).map(item => {
    if (!item || item.hotelID == null) return null
    return {
      id: item.hotelID,
      name: item.hotelName || '',
      cityName: item.cityName || '',
      address: item.address || '',
      hotelStar: item.hotelStar || 0,
      isGovStar: item.isGovStar,
      hotelStarName: item.hotelStarName || '',
      avgScore: item.avgScore || 0,
      googleLat: item.googleLat || 0,
      googleLon: item.googleLon || 0,
      distance: item.distance || 0,
      image: buildOssUrl(item.mainImage),
      startingPrice: item.startingPrice || 0,
      facilities: Array.isArray(item.lstServiceFacilities) ? item.lstServiceFacilities : [],
      raw: item
    }
  }).filter(Boolean)

  return {
    hotelList,
    count: Number(body.count || hotelList.length),
    pageIndex,
    pageSize
  }
}

/**
 * 获取酒店详情
 * 接口地址：http://api.panhe.net/hotel/getHotelDetail
 * @param {Object} params
 * @param {string|number} params.hotelID - 酒店ID（必填）
 * @param {string} params.checkInDate - 入住日期（格式：yyyy-MM-dd）（必填）
 * @param {string} params.checkOutDate - 离店日期（格式：yyyy-MM-dd）（必填）
 */
export async function pullHotelDetail({ hotelID, checkInDate, checkOutDate } = {}) {
  const { data } = await get(`${PANHE_API_BASE}/hotel/getHotelDetail`, {
    hotelID,
    checkInDate,
    checkOutDate
  })

  if (!data) return null

  // 处理酒店图片列表
  if (Array.isArray(data.pictures)) {
    data.pictures = data.pictures.map(pic => ({
      path: buildOssUrl(pic.path),
      name: pic.name || ''
    }))
  }

  // 处理主图
  if (data.mainImage) {
    data.mainImage = buildOssUrl(data.mainImage)
  }

  // 处理服务列表
  if (Array.isArray(data.services)) {
    data.services = data.services.map(service => ({
      name: service.name || '',
      status: service.status || '0' // 0=无,1=有,2=不确定,3=部分有
    }))
  }

  // 处理设施列表
  if (Array.isArray(data.facilities)) {
    data.facilities = data.facilities.map(facility => ({
      name: facility.name || '',
      status: facility.status || '0' // 0=无,1=有,2=不确定,3=部分有
    }))
  }

  return {
    hotelID: data.hotelID,
    hotelName: data.hotelName || '',
    cityName: data.cityName || '',
    cityCode: data.cityCode,
    areaName: data.areaName || '',
    areaCode: data.areaCode,
    address: data.address || '',
    hotelStar: data.hotelStar || 0,
    isGovStar: data.isGovStar,
    hotelStarName: data.hotelStarName || '',
    phone: data.phone || '',
    openDate: data.openDate || '',
    decorationDate: data.decorationDate || '',
    description: data.description || '',
    avgScore: data.avgScore || 0,
    googleLat: data.googleLat || 0,
    googleLon: data.googleLon || 0,
    pictures: data.pictures || [],
    services: data.services || [],
    facilities: data.facilities || [],
    raw: data
  }
}

/**
 * 查询酒店房型、价格、库存
 * 接口地址：http://api.panhe.net/hotel/queryRoomAndRatePlan
 * @param {Object} params
 * @param {string|number} params.hotelID - 酒店ID（必填）
 * @param {string} params.checkInDate - 入住日期（格式：yyyy-MM-dd）（必填）
 * @param {string} params.checkOutDate - 离店日期（格式：yyyy-MM-dd）（必填）
 * @param {number} params.maxWaitSeconds - 最大等待时长（可选，默认5秒，最小1秒）
 */
export async function pullHotelRooms({ hotelID, checkInDate, checkOutDate, maxWaitSeconds = 5 } = {}) {
  const { data } = await get(`${PANHE_API_BASE}/hotel/queryRoomAndRatePlan`, {
    hotelID,
    checkInDate,
    checkOutDate,
    maxWaitSeconds
  })

  if (!data || !Array.isArray(data.rooms)) {
    return { rooms: [] }
  }

  const rooms = data.rooms.map(room => {
    // 处理房型图片
    const pictures = Array.isArray(room.pictures)
      ? room.pictures.map(pic => ({
        path: buildOssUrl(pic.path),
        name: pic.name || ''
      }))
      : []

    // 处理房型设施
    const facilities = Array.isArray(room.facilities)
      ? room.facilities.map(facility => ({
        name: facility.name || '',
        status: facility.status || '0'
      }))
      : []

    // 处理价格方案
    const ratePlans = Array.isArray(room.ratePlans)
      ? room.ratePlans.map(plan => ({
        ratePlanId: plan.ratePlanId || '',
        ratePlanName: plan.ratePlanName || '',
        paymentType: plan.paymentType || 0, // 0:预付，1:现付
        averagePrice: plan.averagePrice || 0,
        pricePerDay: plan.pricePerDay || '', // 每日价格，以"|"分隔
        stockPerDay: plan.stockPerDay || '', // 库存量，以"|"分隔
        confirmType: plan.confirmType || 0, // 0:不支持即时确认 1:支持即时确认
        breakfast: plan.breakfast || '', // 早餐规则
        cancelRule: {
          name: plan.cancelRule?.name || '',
          type: plan.cancelRule?.type || 1, // 1:不可取消, 2:限时取消, 3:收费取消
          desc: plan.cancelRule?.desc || '',
          freeCancelLatestTime: plan.cancelRule?.freeCancelLatestTime || null
        }
      }))
      : []

    return {
      roomId: room.roomId || 0,
      roomName: room.roomName || '',
      useableArea: room.useableArea || '',
      capacity: room.capacity || '',
      floor: room.floor || '',
      bedType: room.bedType || '',
      windowType: room.windowType || '',
      pictures,
      facilities,
      ratePlans
    }
  })
  return { rooms }
}

/**
 * 创建酒店订单
 * 接口地址：http://api.panhe.net/hotel/createOrder
 * 请求方法：POST
 * @param {Object} params
 * @param {string} params.customerOrderNo - 商户订单号（必填，必须唯一）
 * @param {string|number} params.hotelID - 酒店ID（必填）
 * @param {string} params.ratePlanID - 产品（价格计划）ID（必填）
 * @param {number} params.roomNum - 房间数量（必填）
 * @param {string} params.checkInDate - 入住日期（格式：yyyy-MM-dd）（必填）
 * @param {string} params.checkOutDate - 离店日期（格式：yyyy-MM-dd）（必填）
 * @param {string[]} params.guestNames - 房客姓名数组（必填，长度需和房间数量保持一致）
 * @param {string} params.arriveTime - 最晚到店时间（可选，如：2020-07-27 16:00）
 * @param {number} params.orderAmount - 订单总金额（必填）
 * @param {string} params.contactName - 订单联系人姓名（必填）
 * @param {string} params.contactMobile - 订单联系人手机号（必填）
 * @param {string} params.contactEmail - 订单联系人邮箱（可选）
 * @param {string} params.orderRemark - 用户备注信息（可选）
 * @param {string} params.callBackUrl - 订单状态变更异步回调地址（可选）
 */
export async function postHotelBook(params) {
  const {
    customerOrderNo,
    hotelID,
    ratePlanID,
    roomNum,
    checkInDate,
    checkOutDate,
    guestNames,
    arriveTime,
    orderAmount,
    contactName,
    contactMobile,
    contactEmail,
    orderRemark,
    callBackUrl
  } = params

  const requestData = {
    customerOrderNo,
    hotelID,
    ratePlanID,
    roomNum,
    checkInDate,
    checkOutDate,
    guestNames,
    arriveTime,
    orderAmount,
    contactName,
    contactMobile,
    contactEmail,
    orderRemark,
    callBackUrl
  }

  const { data } = await post(`${PANHE_API_BASE}/hotel/createOrder`, requestData)

  if (!data) {
    return { success: false, msg: '创建订单失败' }
  }

  return {
    success: true,
    orderNo: data.orderNo || '',
    msg: '订单创建成功'
  }
}

/**
 * 酒店订单支付（代扣支付）
 * 接口地址：http://api.panhe.net/hotel/autoPay
 * 请求方法：POST
 * @param {Object} params
 * @param {string} params.orderNo - 酒店订单号（必填）
 * @param {number} params.payAmount - 订单支付金额（可选，传值时将和订单金额进行比对）
 * @param {string} params.appKey - 应用AppKey（必填）
 * @param {string} params.secretKey - 应用SecretKey（必填）
 */
export async function postHotelPay({ orderNo, payAmount, appKey, secretKey } = {}) {
  // 生成签名：md5(secretKey + orderNo + payAmount + secretKey)
  // 注意：payAmount为null时不参与签名
  let signStr = ''
  if (payAmount != null) {
    signStr = `${secretKey}${orderNo}${payAmount}${secretKey}`
  } else {
    signStr = `${secretKey}${orderNo}${secretKey}`
  }

  // 使用项目自带的MD5工具加密
  const sign = digestHex(signStr)

  const requestData = {
    appKey,
    orderNo,
    payAmount,
    sign
  }

  const { data } = await post(`${PANHE_API_BASE}/hotel/autoPay`, requestData)

  return {
    success: data === true,
    msg: data === true ? '支付成功' : '支付失败'
  }
}


/**
 * 获取酒店订单列表（暂时留着）
 * @param {Object} params
 * @param {number} params.state - 订单状态 (0=全部, 1=待付款, 2=待入住, 3=已入住, 4=已完成, 5=已取消)
 * @param {number} params.page - 页码
 */
export async function pullHotelOrderList({ state = 0, page = 1 } = {}) {
  const { data } = await get(`${PANHE_API_BASE}/hotel/getOrderList`, { state, page })

  return {
    rows: Array.isArray(data.data) ? data.data : [],
    currentPage: data.current_page || 1,
    lastPage: data.last_page || 1,
    total: data.total || 0
  }
}

/**
 * 获取酒店订单详情
 * 接口地址：http://api.panhe.net/hotel/getOrderDetail
 * @param {Object} params
 * @param {string} params.orderNo - 酒店订单号（必填）
 */
export async function pullHotelOrderDetail({ orderNo } = {}) {
  const { data } = await get(`${PANHE_API_BASE}/hotel/getOrderDetail`, { orderNo })

  if (!data) return null

  // 订单状态映射
  const orderStatusMap = {
    1: '待付款',
    2: '待确认',
    3: '已确认',
    4: '确认失败',
    5: '已完成',
    6: '取消中',
    7: '取消失败',
    8: '已取消'
  }

  // 支付状态映射
  const payStatusMap = {
    0: '待支付',
    1: '已支付'
  }

  // 支付方式映射
  const paymentTypeMap = {
    0: '未支付',
    1: '虚拟钱包支付',
    2: '支付宝',
    3: '微信'
  }

  // 取消政策类型映射
  const cancelPolicyTypeMap = {
    1: '不可取消',
    2: '限时取消',
    3: '收费取消'
  }

  return {
    orderNo: data.orderNo || '',
    customerOrderNo: data.customerOrderNo || '',
    numberOfRooms: data.numberOfRooms || 0,
    numberOfNights: data.numberOfNights || 0,
    arriveTime: data.arriveTime || '',
    checkInDate: data.checkInDate || '',
    checkOutDate: data.checkOutDate || '',
    guestNames: data.guestNames || '',
    remark: data.remark || '',
    orderAmount: data.orderAmount || 0,
    orderStatus: data.orderStatus || 0,
    orderStatusText: orderStatusMap[data.orderStatus] || '未知',
    payStatus: data.payStatus || 0,
    payStatusText: payStatusMap[data.payStatus] || '未知',
    payTime: data.payTime || '',
    paymentType: data.paymentType || 0,
    paymentTypeText: paymentTypeMap[data.paymentType] || '未知',
    transactionNo: data.transactionNo || '',
    refundAmount: data.refundAmount || 0,
    refundSuccessTime: data.refundSuccessTime || '',
    refundTransactionNo: data.refundTransactionNo || '',
    refundTransactionMethods: data.refundTransactionMethods || 0,
    hotelId: data.hotelId || 0,
    hotelName: data.hotelName || '',
    hotelAddress: data.hotelAddress || '',
    roomTypeName: data.roomTypeName || '',
    bedTypeName: data.bedTypeName || '',
    ratePlanId: data.ratePlanId || '',
    pricePerDay: data.pricePerDay || '',
    breakfastDesc: data.breakfastDesc || '',
    cancelPolicyType: data.cancelPolicyType || 0,
    cancelPolicyTypeText: cancelPolicyTypeMap[data.cancelPolicyType] || '未知',
    cancelDesc: data.cancelDesc || '',
    freeCancelLatestTime: data.freeCancelLatestTime || '',
    confirmationNumber: data.confirmationNumber || '',
    contactName: data.contactName || '',
    contactMobile: data.contactMobile || '',
    contactEmail: data.contactEmail || '',
    payLimitTime: data.payLimitTime || '',
    unFinishedReason: data.unFinishedReason || '',
    createTime: data.createTime || '',
    raw: data
  }
}

/**
 * 取消酒店订单
 * 接口地址：http://api.panhe.net/hotel/cancelOrder
 * @param {Object} params
 * @param {string} params.orderNo - 酒店订单号（必填）
 */
export async function postHotelOrderCancel({ orderNo } = {}) {
  const { data } = await get(`${PANHE_API_BASE}/hotel/cancelOrder`, { orderNo })

  if (!data) {
    return {
      success: false,
      msg: '取消失败'
    }
  }

  return {
    success: data === true,
    msg: data === true ? '取消成功' : '取消失败'
  }
}

/**
 * 获取热门酒店推荐（暂时留着）
 * @param {Object} params
 * @param {string} params.cityName - 城市名称
 * @param {number} params.pageIndex - 页码
 */
export async function pullHotelRecommend({ cityName = '', pageIndex = 1 } = {}) {
  const { data } = await get(`${PANHE_API_BASE}/hotel/getRecommendHotels`, { cityName, pageIndex })

  const hotelList = (Array.isArray(data.hotelList) ? data.hotelList : []).map(item => {
    if (!item || item.hotelID == null) return null
    return {
      id: item.hotelID,
      name: item.hotelName || '',
      cityName: item.cityName || '',
      address: item.address || '',
      hotelStar: item.hotelStar || 0,
      avgScore: item.avgScore || 0,
      image: buildOssUrl(item.mainImage),
      startingPrice: item.startingPrice || 0,
      raw: item
    }
  }).filter(Boolean)

  return {
    hotelList,
    count: data.count || 0,
    pageIndex,
    pageSize: 10
  }
}

/**
 * 获取酒店评价列表（暂时留着）
 * @param {string|number} hotelId - 酒店ID
 * @param {number} pageIndex - 页码
 */
export async function pullHotelReviews({ hotelId, pageIndex = 1 } = {}) {
  const { data } = await get(`${PANHE_API_BASE}/hotel/getHotelReviews`, { hotelId, pageIndex })

  const reviews = Array.isArray(data.data) ? data.data : []

  return {
    rows: reviews.map(review => ({
      id: review.id,
      userName: review.user_name || review.nickname || '匿名用户',
      userAvatar: buildOssUrl(review.user_avatar || review.avatar),
      rating: Number(review.rating || 0),
      content: review.content || '',
      images: Array.isArray(review.images) ? review.images.map(img => buildOssUrl(img)) : [],
      createTime: review.create_time || '',
      raw: review
    })),
    total: data.total || 0,
    currentPage: data.current_page || 1,
    lastPage: data.last_page || 1
  }
}