import { GUIDE_ORDERS_KEY, initialOrders } from '../constants/mock'
import { request } from '../utils/request'
import { resolveMeetingPoint } from './guide'

function readOrders() {
  const orders = uni.getStorageSync(GUIDE_ORDERS_KEY)
  if (Array.isArray(orders) && orders.length) {
    return orders
  }
  uni.setStorageSync(GUIDE_ORDERS_KEY, initialOrders)
  return initialOrders
}

function writeOrders(orders) {
  uni.setStorageSync(GUIDE_ORDERS_KEY, orders)
}

function withMeetingPoint(order = {}) {
  const meetingPoint = resolveMeetingPoint({
    scenicId: order.scenicId,
    scenicName: order.scenicName,
    meetingPointId: order.meetingPointId,
    meetingPointName: order.meetingPointName,
    meetingPointLatitude: order.meetingPointLatitude,
    meetingPointLongitude: order.meetingPointLongitude,
    meetingPointAddress: order.meetingPointAddress
  })

  if (!meetingPoint) {
    return order
  }

  return {
    ...order,
    scenicId: order.scenicId || meetingPoint.scenicId,
    meetingPointId: order.meetingPointId || meetingPoint.id,
    meetingPointName: order.meetingPointName || meetingPoint.name,
    meetingPointLatitude: order.meetingPointLatitude || meetingPoint.latitude,
    meetingPointLongitude: order.meetingPointLongitude || meetingPoint.longitude,
    meetingPointAddress: order.meetingPointAddress || meetingPoint.address
  }
}

export function getGuideOrders(filter = 'all') {
  return request({
    url: `/guide/orders?tab=${encodeURIComponent(normalizeOrderTab(filter))}&page=1&size=50`
  }).then((page) => (page.records || []).map(normalizeGuideOrder))
}

export function getPendingOrders() {
  return getGuideOrders('accepted')
}

export function getOrderDetail(orderId) {
  return request({ url: `/guide/orders/${orderId}` }).then(normalizeGuideOrder)
}

export function startGuideLecture(orderId) {
  return request({
    url: `/guide/orders/${orderId}/start`,
    method: 'POST'
  }).then(normalizeGuideOrder)
}

function normalizeOrderTab(filter) {
  if (filter === 'active' || filter === 'pending') {
    return 'accepted'
  }
  if (filter === 'history') {
    return 'completed'
  }
  return filter || 'all'
}

function normalizeGuideOrder(order = {}) {
  const normalized = withMeetingPoint({
    ...order,
    quantity: Number(order.quantity ?? order.peopleCount ?? 0),
    receiveTime: normalizeTime(order.receiveTime || order.acceptedAt || order.createdAt),
    receiveStartTime: normalizeTime(order.receiveStartTime || order.receiveTime || order.acceptedAt || order.createdAt),
    lectureStartTime: normalizeTime(order.lectureStartTime || order.serviceStartedAt || order.arrivedAt),
    lectureEndTime: normalizeTime(order.lectureEndTime || order.completedAt),
    completedAt: normalizeTime(order.completedAt),
    customers: (order.customers || []).map((item) => ({
      ...item,
      time: normalizeTime(item.time)
    }))
  })
  return {
    ...normalized,
    customers: normalized.customers && normalized.customers.length
      ? normalized.customers
      : [{ no: 1, phone: normalized.customerPhone || '', people: normalized.quantity || 0, time: normalized.receiveStartTime || '' }]
  }
}

function normalizeTime(value) {
  return value ? String(value).replace('T', ' ') : ''
}

export function updateOrderStatus(orderId, status) {
  const orders = readOrders()
  const next = orders.map((item) => {
    if (item.id !== orderId) {
      return item
    }
    return {
      ...item,
      status
    }
  })
  writeOrders(next)
  return Promise.resolve(next.find((item) => item.id === orderId))
}

export function getWorkbenchSummary() {
  const orders = readOrders()
  const todayOrders = orders.filter((item) => item.createdAt.includes('2026-06-17'))
  const completed = orders.filter((item) => item.status === 'completed')
  const todayIncomeCent = todayOrders.reduce((sum, item) => sum + item.incomeCent, 0)
  return Promise.resolve({
    pendingCount: orders.filter((item) => item.status === 'pending').length,
    activeCount: orders.filter((item) => ['accepted', 'arrived', 'serving'].includes(item.status)).length,
    completedCount: completed.length,
    todayIncomeCent
  })
}

export function getEarnings(filters = {}) {
  const data = {
    pageNum: filters.pageNum || 1,
    pageSize: filters.pageSize || 50
  }
  if (filters.serviceType) {
    data.serviceType = filters.serviceType
  }
  if (filters.scenicName) {
    data.scenicName = filters.scenicName
  }
  if (filters.date) {
    data.date = filters.date
  }
  return request({
    url: '/guide/earnings',
    data
  })
}