medical-mall/services/serviceOrderService.uts

import supa from '@/components/supadb/aksupainstance.uts'
import { getCurrentUserId } from '@/utils/store.uts'
import { getCurrentUser } from '@/utils/store.uts'
import type { UserAddress } from '@/utils/supabaseService.uts'
import type { HomeServiceCatalogType, HomeServicePackageType } from '@/types/home-service.uts'
import type { DeliveryServiceRecordType } from '@/types/delivery.uts'
import {
	getServiceOrderStatusText,
	normalizeServiceOrderStatus,
	type ServiceOrderAddressSnapshotType,
	type ServiceEvidenceFileType,
	type ServiceExecutionRecordType,
	type ServiceOrderStatus,
	type ServiceOrderTimelineItemType,
	type ServiceOrderType,
	type ServiceReviewType
} from '@/types/service-order.uts'

export type HomecareDispatchResult = {
  success: boolean
  code: string
  message: string
  display_type: string
  retryable: boolean
  dispatch_status?: string
  order_id?: string
  assignment_id?: string
  staff_id?: string
  station_id?: string
  dispatch_distance_km?: number
}

export const HOMECARE_DISPATCH_STATUS_PENDING = 'pending'
export const HOMECARE_DISPATCH_STATUS_DISPATCHING = 'dispatching'
export const HOMECARE_DISPATCH_STATUS_ASSIGNED = 'assigned'
export const HOMECARE_DISPATCH_STATUS_FAILED = 'failed'

export type CreateServiceOrderParams = {
	service: HomeServiceCatalogType
	packageInfo: HomeServicePackageType
	address: ServiceOrderAddressSnapshotType
	recipientName: string
	recipientPhone: string
	recipientAge: number
	recipientGender: string
	contactName: string
	contactPhone: string
	appointmentTime: string
	remark: string
}

function buildServiceSnapshot(params: CreateServiceOrderParams): any {
	return {
		serviceId: params.service.id,
		serviceName: params.service.name,
		category: params.service.category,
		price: params.packageInfo.price,
		durationText: params.packageInfo.durationText != '' ? params.packageInfo.durationText : params.service.durationText,
		summary: params.packageInfo.packageDesc != '' ? params.packageInfo.packageDesc : params.service.summary,
		tags: params.service.tags,
		suitableFor: params.service.suitableFor,
		packageId: params.packageInfo.id,
		packageName: params.packageInfo.packageName,
		packagePrice: params.packageInfo.price,
		packageListPrice: params.packageInfo.listPrice,
		packageDataSource: params.packageInfo.dataSource,
		packageSeedBatchNo: params.packageInfo.seedBatchNo
	} as any
}

function buildPricingSnapshot(params: CreateServiceOrderParams): any {
	return {
		service_id: params.service.id,
		service_name: params.service.name,
		package_id: params.packageInfo.id,
		package_name: params.packageInfo.packageName,
		package_desc: params.packageInfo.packageDesc,
		duration_minutes: params.packageInfo.durationMinutes,
		duration_text: params.packageInfo.durationText,
		price: params.packageInfo.price,
		list_price: params.packageInfo.listPrice,
		data_source: params.packageInfo.dataSource,
		seed_batch_no: params.packageInfo.seedBatchNo,
		remark: params.packageInfo.remark
	} as any
}

const HOMECARE_DISPATCH_CANDIDATE_RPC = 'rpc_homecare_dispatch_candidate'

function nowText(): string {
	return new Date().toISOString().replace('T', ' ').substring(0, 19)
}

function nowIso(): string {
	return new Date().toISOString()
}

function buildId(prefix: string): string {
	return prefix + '-' + String(Date.now()) + '-' + String(Math.floor(Math.random() * 100000)).padStart(5, '0')
}

function buildHex(length: number): string {
	const chars = '0123456789abcdef'
	let result = ''
	for (let i = 0; i < length; i++) {
		result += chars.charAt(Math.floor(Math.random() * chars.length))
	}
	return result
}

function buildUuidLike(): string {
	const segment1 = buildHex(8)
	const segment2 = buildHex(4)
	const segment3 = '4' + buildHex(3)
	const variants = '89ab'
	const segment4 = variants.charAt(Math.floor(Math.random() * variants.length)) + buildHex(3)
	const segment5 = buildHex(12)
	return segment1 + '-' + segment2 + '-' + segment3 + '-' + segment4 + '-' + segment5
}

function buildOrderNo(): string {
	const date = new Date()
	const y = String(date.getFullYear())
	const m = String(date.getMonth() + 1).padStart(2, '0')
	const d = String(date.getDate()).padStart(2, '0')
	const h = String(date.getHours()).padStart(2, '0')
	const i = String(date.getMinutes()).padStart(2, '0')
	const s = String(date.getSeconds()).padStart(2, '0')
	return 'HS' + y + m + d + h + i + s + String(Math.floor(Math.random() * 900) + 100)
}

function isUuidLike(value: string): boolean {
	return /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$/.test(value)
}

function normalizeUuidOrNull(value: string): string | null {
	if (value == '') {
		return null
	}
	return isUuidLike(value) ? value : null
}

function normalizeAppointmentTime(value: string): string | null {
	const text = value.trim()
	if (text == '') {
		return null
	}
	const fullRangeMatch = text.match(/^(\d{4}-\d{2}-\d{2})\s+(\d{2}:\d{2})(\s*-\s*\d{2}:\d{2})?$/)
	if (fullRangeMatch != null) {
		const datePart = fullRangeMatch[1] ?? ''
		const startTime = fullRangeMatch[2] ?? ''
		const parsed = Date.parse(datePart + 'T' + startTime + ':00')
		if (!isNaN(parsed)) {
			return new Date(parsed).toISOString()
		}
		return datePart + ' ' + startTime
	}
	if (/^\d{4}-\d{2}-\d{2}(\s+(上午|下午|晚上))$/.test(text)) {
		return text
	}
	if (/^\d{4}-\d{2}-\d{2}T/.test(text)) {
		const parsed = Date.parse(text)
		if (!isNaN(parsed)) {
			const date = new Date(parsed)
			const year = String(date.getFullYear())
			const month = String(date.getMonth() + 1).padStart(2, '0')
			const day = String(date.getDate()).padStart(2, '0')
			const hour = String(date.getHours()).padStart(2, '0')
			const minute = String(date.getMinutes()).padStart(2, '0')
			return year + '-' + month + '-' + day + ' ' + hour + ':' + minute
		}
		return text.replace('T', ' ')
	}
	const monthDayMatch = text.match(/(\d{2})\/(\d{2})/)
	if (monthDayMatch != null) {
		const month = monthDayMatch[1] ?? ''
		const day = monthDayMatch[2] ?? ''
		if (month == '' || day == '') {
			return text
		}
		const year = String(new Date().getFullYear())
		const rangeMatch = text.match(/(\d{2}:\d{2})(\s*-\s*\d{2}:\d{2})?/)
		if (rangeMatch != null) {
			const startTime = rangeMatch[1] ?? ''
			if (startTime != '') {
				const parsed = Date.parse(year + '-' + month + '-' + day + 'T' + startTime + ':00')
				if (!isNaN(parsed)) {
					return new Date(parsed).toISOString()
				}
				return year + '-' + month + '-' + day + ' ' + startTime
			}
		}
		const tailText = text.substring(text.indexOf(month + '/' + day) + 5).trim()
		return year + '-' + month + '-' + day + (tailText != '' ? ' ' + tailText : '')
	}
	const explicitParsed = Date.parse(text)
	if (!isNaN(explicitParsed) && /^\d{4}\//.test(text)) {
		const date = new Date(explicitParsed)
		const year = String(date.getFullYear())
		const month = String(date.getMonth() + 1).padStart(2, '0')
		const day = String(date.getDate()).padStart(2, '0')
		const hour = String(date.getHours()).padStart(2, '0')
		const minute = String(date.getMinutes()).padStart(2, '0')
		return year + '-' + month + '-' + day + ' ' + hour + ':' + minute
	}
	const year = String(new Date().getFullYear())
	return /^\d{2}-\d{2}\s+\d{2}:\d{2}/.test(text) ? year + '-' + text : text
}

function safeParseObject(value: string): UTSJSONObject {
	if (value == '') {
		return JSON.parse('{}') as UTSJSONObject
	}
	return JSON.parse(value) as UTSJSONObject
}

function safeParseArray(value: string): Array<string> {
	if (value == '') {
		return [] as Array<string>
	}
	const parsed = JSON.parse(value) as any
	if (Array.isArray(parsed)) {
		return parsed as Array<string>
	}
	return [] as Array<string>
}

function safeJsonField(source: any, key: string): string {
	const plain = JSON.parse(JSON.stringify(source)) as any
	const value = plain[key]
	if (value == null) {
		return ''
	}
	return JSON.stringify(value)
}

function safeFirstJsonField(source: any, keys: Array<string>): string {
	const plain = JSON.parse(JSON.stringify(source)) as any
	for (let i = 0; i < keys.length; i++) {
		const value = plain[keys[i]]
		if (value != null) {
			return JSON.stringify(value)
		}
	}
	return ''
}

function plainObject(source: any): any {
	return JSON.parse(JSON.stringify(source)) as any
}

function readString(source: any, key: string): string {
	const value = plainObject(source)[key]
	if (value == null) {
		return ''
	}
	return typeof value == 'string' ? value : String(value)
}

function readNumber(source: any, key: string): number {
	const value = plainObject(source)[key]
	if (typeof value == 'number') {
		return value
	}
	if (typeof value == 'string' && value != '') {
		const parsed = Number(value)
		return isNaN(parsed) ? 0 : parsed
	}
	return 0
}

function hasMissingColumnError(error: any, columnName: string): boolean {
	if (error == null || columnName == '') {
		return false
	}
	const errorText = JSON.stringify(error).toLowerCase()
	return errorText.indexOf('could not find the') >= 0 && errorText.indexOf(columnName.toLowerCase()) >= 0
}

let ecServiceRequestCreateUnavailable = false

function shouldBypassEcServiceRequestCreate(error: any): boolean {
	if (error == null) {
		return false
	}
	return hasMissingColumnError(error, 'address_snapshot')
		|| hasMissingColumnError(error, 'address_snapshot_json')
		|| hasMissingColumnError(error, 'contact_name')
		|| hasMissingColumnError(error, 'contact_phone')
}

export function shouldUseCareTaskPath(orderId: string): boolean {
	return isUuidLike(orderId)
}

function isStaffActive(staff: any): boolean {
	const plain = plainObject(staff)
	if (plain['deleted_at'] != null && String(plain['deleted_at']) != '') {
		return false
	}
	if (plain['is_active'] === false) {
		return false
	}
	return readNumber(staff, 'status') == 1
}

function getStaffPriority(staff: any): number {
	let score = 0
	const onlineStatus = readString(staff, 'online_status')
	if (onlineStatus == 'online') {
		score += 30
	} else if (onlineStatus == 'resting' || onlineStatus == '') {
		score += 20
	} else if (onlineStatus == 'busy') {
		score += 10
	}
	if (readString(staff, 'uid') != '') {
		score += 5
	}
	if (readString(staff, 'station_id') != '') {
		score += 1
	}
	return score
}

async function getAutoAssignableStaff(): Promise<any | null> {
	try {
		const rpcResponse: any = await supa.rpc(HOMECARE_DISPATCH_CANDIDATE_RPC, {} as any)
		if (rpcResponse == null || rpcResponse.error != null || rpcResponse.data == null) {
			return null
		}
		return rpcResponse.data
	} catch (error) {
		console.warn('getAutoAssignableStaff rpc failed', error)
		return null
	}
}

function buildEcServiceRequestPayload(params: CreateServiceOrderParams, userId: string, requestId: string, createdAt: string, appointmentTime: string | null, useAddressSnapshot: boolean): any {
	const payload = {
		id: requestId,
		user_id: userId,
		service_catalog_id: params.service.id,
		service_name: params.service.name,
		service_category: params.service.category,
		elder_name: params.recipientName,
		elder_phone: params.recipientPhone,
		elder_age: params.recipientAge,
		elder_gender: params.recipientGender,
		contact_name: params.contactName,
		contact_phone: params.contactPhone,
		scheduled_at: appointmentTime,
		remark: params.remark,
		status: 'ORDER_CREATED',
		created_at: createdAt,
		updated_at: createdAt
	} as any
	if (useAddressSnapshot) {
		payload.address_snapshot = params.address as any
	} else {
		payload.address_snapshot_json = params.address as any
	}
	return payload
}

function buildEcServiceRequestPayloadWithoutAddress(params: CreateServiceOrderParams, userId: string, requestId: string, createdAt: string, appointmentTime: string | null): any {
	return {
		id: requestId,
		user_id: userId,
		service_catalog_id: params.service.id,
		service_name: params.service.name,
		service_category: params.service.category,
		elder_name: params.recipientName,
		elder_phone: params.recipientPhone,
		elder_age: params.recipientAge,
		elder_gender: params.recipientGender,
		contact_name: params.contactName,
		contact_phone: params.contactPhone,
		scheduled_at: appointmentTime,
		remark: params.remark,
		status: 'ORDER_CREATED',
		created_at: createdAt,
		updated_at: createdAt
	} as any
}

function buildEcCareTaskPayload(params: CreateServiceOrderParams, userId: string, requestId: string, taskId: string, taskNo: string, createdAt: string, appointmentTime: string | null, useAddressSnapshot: boolean): any {
	const payload = {
		id: taskId,
		task_no: taskNo,
		request_id: requestId,
		user_id: userId,
		service_catalog_id: params.service.id,
		service_name: params.service.name,
		service_category: params.service.category,
		service_snapshot_json: buildServiceSnapshot(params),
		elder_name: params.recipientName,
		elder_phone: params.recipientPhone,
		elder_age: params.recipientAge,
		elder_gender: params.recipientGender,
		contact_name: params.contactName,
		contact_phone: params.contactPhone,
		scheduled_at: appointmentTime,
		remark: params.remark,
		status: 'ORDER_CREATED',
		created_at: createdAt,
		updated_at: createdAt
	} as any
	if (useAddressSnapshot) {
		payload.address_snapshot = params.address as any
	} else {
		payload.address_snapshot_json = params.address as any
	}
	return payload
}

function buildEcCareTaskPayloadWithoutAddress(params: CreateServiceOrderParams, userId: string, requestId: string, taskId: string, taskNo: string, createdAt: string, appointmentTime: string | null): any {
	return {
		id: taskId,
		task_no: taskNo,
		request_id: requestId,
		user_id: userId,
		service_catalog_id: params.service.id,
		service_name: params.service.name,
		service_category: params.service.category,
		service_snapshot_json: buildServiceSnapshot(params),
		elder_name: params.recipientName,
		elder_phone: params.recipientPhone,
		elder_age: params.recipientAge,
		elder_gender: params.recipientGender,
		contact_name: params.contactName,
		contact_phone: params.contactPhone,
		scheduled_at: appointmentTime,
		remark: params.remark,
		status: 'ORDER_CREATED',
		created_at: createdAt,
		updated_at: createdAt
	} as any
}

function parseTimeline(item: any): ServiceOrderTimelineItemType {
	return {
		id: readString(item, 'id'),
		orderId: readString(item, 'order_id'),
		fromStatus: readString(item, 'from_status'),
		toStatus: normalizeServiceOrderStatus(readString(item, 'to_status')),
		operatorId: readString(item, 'operator_id'),
		operatorRole: readString(item, 'operator_role'),
		remark: readString(item, 'remark'),
		createdAt: readString(item, 'created_at')
	}
	}

function parseReview(item: any): ServiceReviewType {
	return {
		id: readString(item, 'id'),
		orderId: readString(item, 'order_id'),
		userId: readString(item, 'user_id'),
		rating: readNumber(item, 'rating') == 0 ? 5 : readNumber(item, 'rating'),
		tags: safeParseArray(safeJsonField(item, 'tags_json')),
		content: readString(item, 'content'),
		createdAt: readString(item, 'created_at')
	}
	}

function parseExecutionRecord(item: any): ServiceExecutionRecordType {
	return {
		id: readString(item, 'id'),
		orderId: readString(item, 'order_id'),
		assignmentId: readString(item, 'assignment_id'),
		checkinTime: readString(item, 'checkin_time'),
		checkinLatitude: readNumber(item, 'checkin_latitude'),
		checkinLongitude: readNumber(item, 'checkin_longitude'),
		checkinAddress: readString(item, 'checkin_address'),
		serviceStartedAt: readString(item, 'service_started_at'),
		serviceFinishedAt: readString(item, 'service_finished_at'),
		actualDurationMinutes: readNumber(item, 'actual_duration_minutes'),
		serviceItemsJson: safeJsonField(item, 'service_items_json'),
		summary: readString(item, 'summary'),
		remark: readString(item, 'remark'),
		trackPointsJson: safeJsonField(item, 'track_points_json'),
		createdAt: readString(item, 'created_at'),
		updatedAt: readString(item, 'updated_at')
	}
	}

function parseEvidenceFile(item: any): ServiceEvidenceFileType {
	return {
		id: readString(item, 'id'),
		orderId: readString(item, 'order_id'),
		executionRecordId: readString(item, 'execution_record_id'),
		phase: readString(item, 'phase'),
		fileType: readString(item, 'file_type'),
		storagePath: readString(item, 'storage_path'),
		fileUrl: readString(item, 'file_url'),
		latitude: readNumber(item, 'latitude'),
		longitude: readNumber(item, 'longitude'),
		capturedAt: readString(item, 'captured_at'),
		createdAt: readString(item, 'created_at')
	}
	}

function parseServiceOrder(item: any, logs: Array<ServiceOrderTimelineItemType>, review: ServiceReviewType | null): ServiceOrderType {
	const addressSnapshot = safeFirstJsonField(item, ['address_snapshot_json', 'address_snapshot'])
	const serviceSnapshot = safeJsonField(item, 'service_snapshot_json')
	const addressObj = plainObject(safeParseObject(addressSnapshot))
	const serviceObj = plainObject(safeParseObject(serviceSnapshot))
	return {
		id: readString(item, 'id'),
		orderNo: readString(item, 'order_no'),
		userId: readString(item, 'user_id'),
		serviceId: readString(item, 'service_id'),
		serviceName: readString(item, 'service_name'),
		serviceSnapshot: {
			serviceId: readString(serviceObj, 'serviceId') != '' ? readString(serviceObj, 'serviceId') : readString(item, 'service_id'),
			serviceName: readString(serviceObj, 'serviceName') != '' ? readString(serviceObj, 'serviceName') : readString(item, 'service_name'),
			category: readString(serviceObj, 'category'),
			price: readNumber(serviceObj, 'price'),
			durationText: readString(serviceObj, 'durationText'),
			summary: readString(serviceObj, 'summary'),
			tags: safeParseArray(safeJsonField(serviceObj, 'tags')),
			suitableFor: readString(serviceObj, 'suitableFor')
		},
		serviceAddressId: readString(item, 'service_address_id'),
		addressSnapshot: {
			addressId: readString(addressObj, 'addressId'),
			contactName: readString(addressObj, 'contactName'),
			contactPhone: readString(addressObj, 'contactPhone'),
			province: readString(addressObj, 'province'),
			city: readString(addressObj, 'city'),
			district: readString(addressObj, 'district'),
			detailAddress: readString(addressObj, 'detailAddress'),
			fullAddress: readString(addressObj, 'fullAddress'),
			latitude: readNumber(addressObj, 'latitude'),
			longitude: readNumber(addressObj, 'longitude'),
			coordinateType: readString(addressObj, 'coordinateType') == '' ? 'gcj02' : readString(addressObj, 'coordinateType'),
			remark: readString(addressObj, 'remark')
		},
		recipientName: readString(item, 'recipient_name'),
		recipientPhone: readString(item, 'recipient_phone'),
		recipientAge: readFirstNumber(item, ['recipient_age', 'elder_age']),
		recipientGender: readFirstString(item, ['recipient_gender', 'elder_gender']),
		contactName: readString(item, 'contact_name'),
		contactPhone: readString(item, 'contact_phone'),
		appointmentTime: readString(item, 'appointment_time'),
		remark: readString(item, 'remark'),
		status: normalizeServiceOrderStatus(readString(item, 'status')),
		paymentStatus: readNumber(item, 'payment_status'),
		payExpireAt: readString(item, 'pay_expire_at'),
		currentAssignmentId: readString(item, 'current_assignment_id'),
		currentStaffId: readString(item, 'current_staff_id'),
		acceptedAt: readString(item, 'accepted_at'),
		departedAt: readString(item, 'departed_at'),
		arrivedAt: readString(item, 'arrived_at'),
		serviceStartedAt: readString(item, 'service_started_at'),
		completedAt: readString(item, 'completed_at'),
		pendingAcceptanceAt: readString(item, 'pending_acceptance_at'),
		acceptedByUserAt: readString(item, 'accepted_by_user_at'),
		reviewedAt: readString(item, 'reviewed_at'),
		createdAt: readString(item, 'created_at'),
		updatedAt: readString(item, 'updated_at'),
		staffName: '',
		staffPhone: '',
		logs,
		executionRecord: null,
		evidenceFiles: [] as Array<any>,
		review,
		dispatchStatus: readString(item, 'dispatch_status'),
		dispatchErrorCode: readString(item, 'dispatch_error_code'),
		dispatchErrorMessage: readString(item, 'dispatch_error_message')
	}
	}

async function insertLegacyStatusLog(orderId: string, fromStatus: string, toStatus: ServiceOrderStatus, operatorId: string, operatorRole: string, remark: string): Promise<void> {
	// LEGACY/TODO: 旧链路直接写 hss_service_order_status_logs 已停用。
	// 状态事件应由后端 RPC 统一写入 hc_work_order_events / hss_service_order_status_logs。
	console.warn('[LEGACY] insertLegacyStatusLog skipped for', orderId, fromStatus, toStatus, remark)
	}

async function insertWorkOrderEvent(taskId: string, fromStatus: string, toStatus: string, actorId: string, actorRole: string, action: string, remark: string): Promise<void> {
	// LEGACY/TODO: 前端直接 insert hc_work_order_events 已严格禁止。
	// 状态事件必须由后端 RPC 统一写入。
	console.warn('[LEGACY] insertWorkOrderEvent skipped for', taskId, fromStatus, toStatus, action, remark)
	}

function readFirstString(source: any, keys: Array<string>): string {
	for (let i = 0; i < keys.length; i++) {
		const value = readString(source, keys[i])
		if (value != '') {
			return value
		}
	}
	return ''
	}

function readFirstNumber(source: any, keys: Array<string>): number {
	for (let i = 0; i < keys.length; i++) {
		const value = readNumber(source, keys[i])
		if (value != 0) {
			return value
		}
	}
	return 0
	}

function readJsonObjectField(source: any, keys: Array<string>): any {
	const plain = plainObject(source)
	for (let i = 0; i < keys.length; i++) {
		const value = plain[keys[i]]
		if (value != null) {
			return value
		}
	}
	return null
	}

function mapCareTaskRowToLegacyOrderRow(item: any): any {
	const serviceSnapshotValue = readJsonObjectField(item, ['service_snapshot_json'])
	const addressSnapshotValue = readJsonObjectField(item, ['address_snapshot', 'address_snapshot_json'])
	let derivedStatus = readString(item, 'status')
	if (readFirstString(item, ['accepted_by_family_at']) != '') {
		derivedStatus = 'ACCEPTED'
	} else if (readFirstString(item, ['acceptance_pending_at']) != '') {
		derivedStatus = 'ACCEPTANCE_PENDING'
	} else if (readString(item, 'service_started_at') != '') {
		derivedStatus = 'ORDER_IN_SERVICE'
	} else if (readFirstString(item, ['checked_in_at']) != '') {
		derivedStatus = 'ORDER_CHECKED_IN'
	} else if (readString(item, 'departed_at') != '') {
		derivedStatus = 'departed'
	} else if (readString(item, 'accepted_at') != '') {
		derivedStatus = 'ORDER_ACCEPTED'
	} else if (readFirstString(item, ['assigned_to']) != '') {
		derivedStatus = 'ORDER_ASSIGNED'
	}
	const serviceSnapshot = serviceSnapshotValue != null ? serviceSnapshotValue : {
		serviceId: readFirstString(item, ['service_catalog_id', 'service_id']),
		serviceName: readString(item, 'service_name'),
		category: readFirstString(item, ['service_category', 'category']),
		price: readFirstNumber(item, ['service_price', 'price']),
		durationText: readFirstString(item, ['service_duration_text', 'duration_text']),
		summary: readFirstString(item, ['service_summary', 'summary']),
		tags: [] as Array<string>,
		suitableFor: readFirstString(item, ['suitable_for'])
	}
	return {
		id: readString(item, 'id'),
		order_no: readFirstString(item, ['task_no', 'order_no']),
		user_id: readFirstString(item, ['user_id', 'requester_user_id']),
		service_id: readFirstString(item, ['service_catalog_id', 'service_id']),
		service_name: readString(item, 'service_name'),
		service_snapshot_json: serviceSnapshot,
		service_address_id: readFirstString(item, ['service_address_id', 'address_id']),
		address_snapshot_json: addressSnapshotValue != null ? addressSnapshotValue : JSON.parse('{}'),
		recipient_name: readFirstString(item, ['elder_name', 'recipient_name']),
		recipient_phone: readFirstString(item, ['elder_phone', 'recipient_phone']),
		recipient_age: readFirstNumber(item, ['elder_age', 'recipient_age']),
		recipient_gender: readFirstString(item, ['elder_gender', 'recipient_gender']),
		contact_name: readString(item, 'contact_name'),
		contact_phone: readString(item, 'contact_phone'),
		appointment_time: readFirstString(item, ['scheduled_at', 'appointment_time']),
		remark: readString(item, 'remark'),
		status: derivedStatus,
		current_assignment_id: readFirstString(item, ['assignment_id', 'current_assignment_id']),
		current_staff_id: readFirstString(item, ['assigned_to', 'current_staff_id']),
		accepted_at: readString(item, 'accepted_at'),
		departed_at: readString(item, 'departed_at'),
		arrived_at: readFirstString(item, ['checked_in_at', 'arrived_at']),
		service_started_at: readString(item, 'service_started_at'),
		completed_at: readFirstString(item, ['service_completed_at', 'completed_at']),
		pending_acceptance_at: readFirstString(item, ['acceptance_pending_at', 'pending_acceptance_at']),
		accepted_by_user_at: readFirstString(item, ['accepted_by_family_at', 'accepted_by_user_at']),
		reviewed_at: readString(item, 'reviewed_at'),
		created_at: readString(item, 'created_at'),
		updated_at: readString(item, 'updated_at')
	}
	}

function mapWorkOrderEventToLegacyLog(item: any): any {
	return {
		id: readString(item, 'id'),
		order_id: readFirstString(item, ['task_id', 'order_id']),
		from_status: readString(item, 'from_status'),
		to_status: readFirstString(item, ['to_status', 'status']),
		operator_id: readFirstString(item, ['actor_id', 'operator_id']),
		operator_role: readFirstString(item, ['actor_role', 'operator_role']),
		remark: readString(item, 'remark'),
		created_at: readString(item, 'created_at')
	}
	}

function mapCareReviewRecordToLegacyReview(item: any): any {
	return {
		id: readString(item, 'id'),
		order_id: readFirstString(item, ['task_id', 'order_id']),
		user_id: readFirstString(item, ['created_by', 'user_id']),
		rating: readFirstNumber(item, ['rating']),
		tags_json: readJsonObjectField(item, ['tags_json']) != null ? readJsonObjectField(item, ['tags_json']) : [] as Array<string>,
		content: readFirstString(item, ['content', 'summary', 'remark']),
		created_at: readString(item, 'created_at')
	}
	}

function buildLegacyExecutionRecord(taskId: string, records: Array<any>): ServiceExecutionRecordType | null {
	if (records.length == 0) {
		return null
	}
	let checkinRecord: any = null
	let serviceRecord: any = null
	for (let i = 0; i < records.length; i++) {
		const recordType = readFirstString(records[i], ['record_type', 'care_record_type'])
		if (recordType == 'review') {
			continue
		}
		if (recordType == 'checkin') {
			checkinRecord = records[i]
			continue
		}
		if (serviceRecord == null) {
			serviceRecord = records[i]
		}
	}
	const target = serviceRecord != null ? serviceRecord : (checkinRecord != null ? checkinRecord : records[0])
	return parseExecutionRecord({
		id: readString(target, 'id'),
		order_id: taskId,
		assignment_id: readFirstString(target, ['assignment_id']),
		checkin_time: checkinRecord != null ? readFirstString(checkinRecord, ['checked_in_at', 'checkin_time', 'started_at']) : readFirstString(target, ['checked_in_at', 'checkin_time']),
		checkin_latitude: checkinRecord != null ? readFirstNumber(checkinRecord, ['latitude', 'checkin_latitude']) : readFirstNumber(target, ['latitude', 'checkin_latitude']),
		checkin_longitude: checkinRecord != null ? readFirstNumber(checkinRecord, ['longitude', 'checkin_longitude']) : readFirstNumber(target, ['longitude', 'checkin_longitude']),
		checkin_address: checkinRecord != null ? readFirstString(checkinRecord, ['location_text', 'checkin_address', 'remark']) : readFirstString(target, ['location_text', 'checkin_address']),
		service_started_at: readFirstString(target, ['started_at', 'service_started_at']),
		service_finished_at: readFirstString(target, ['finished_at', 'service_finished_at']),
		actual_duration_minutes: readFirstNumber(target, ['duration_minutes', 'actual_duration_minutes']),
		service_items_json: readJsonObjectField(target, ['service_items_json']) != null ? readJsonObjectField(target, ['service_items_json']) : [] as Array<any>,
		summary: readFirstString(target, ['summary', 'content']),
		remark: readString(target, 'remark'),
		track_points_json: readJsonObjectField(target, ['track_points_json']) != null ? readJsonObjectField(target, ['track_points_json']) : [] as Array<any>,
		created_at: readString(target, 'created_at'),
		updated_at: readString(target, 'updated_at')
	})
	}

async function getCareTaskDetail(taskId: string): Promise<ServiceOrderType | null> {
	if (!isUuidLike(taskId)) {
		return null
	}
	const taskResponse = await supa.from('ec_care_tasks').select('*').eq('id', taskId).limit(1).execute()
	if (taskResponse.error != null || taskResponse.data == null) {
		return null
	}
	const taskRows = taskResponse.data as Array<any>
	if (taskRows.length == 0) {
		return null
	}
	const eventsResponse = await supa.from('hc_work_order_events').select('*').eq('task_id', taskId).order('created_at', { ascending: false }).execute()
	const recordsResponse = await supa.from('ec_care_records').select('*').eq('task_id', taskId).order('created_at', { ascending: false }).execute()
	const evidenceResponse = await supa.from('hc_evidence_files').select('*').eq('task_id', taskId).order('created_at', { ascending: false }).execute()
	const logs = [] as Array<ServiceOrderTimelineItemType>
	if (eventsResponse.data != null) {
		const rawEvents = eventsResponse.data as Array<any>
		for (let i = 0; i < rawEvents.length; i++) {
			logs.push(parseTimeline(mapWorkOrderEventToLegacyLog(rawEvents[i])))
		}
	}
	let review: ServiceReviewType | null = null
	const recordRows = recordsResponse.data != null ? recordsResponse.data as Array<any> : [] as Array<any>
	for (let i = 0; i < recordRows.length; i++) {
		const recordType = readFirstString(recordRows[i], ['record_type', 'care_record_type'])
		if (recordType == 'review') {
			review = parseReview(mapCareReviewRecordToLegacyReview(recordRows[i]))
			break
		}
	}
	const parsed = parseServiceOrder(mapCareTaskRowToLegacyOrderRow(taskRows[0]), logs, review)
	parsed.executionRecord = buildLegacyExecutionRecord(taskId, recordRows)
	if (evidenceResponse.data != null) {
		const rawEvidence = evidenceResponse.data as Array<any>
		const evidenceFiles = [] as Array<ServiceEvidenceFileType>
		for (let i = 0; i < rawEvidence.length; i++) {
			evidenceFiles.push(parseEvidenceFile({
				id: readString(rawEvidence[i], 'id'),
				order_id: taskId,
				execution_record_id: readFirstString(rawEvidence[i], ['care_record_id', 'execution_record_id']),
				phase: readString(rawEvidence[i], 'phase'),
				file_type: readString(rawEvidence[i], 'file_type'),
				storage_path: readString(rawEvidence[i], 'storage_path'),
				file_url: readString(rawEvidence[i], 'file_url'),
				latitude: readFirstNumber(rawEvidence[i], ['latitude']),
				longitude: readFirstNumber(rawEvidence[i], ['longitude']),
				captured_at: readString(rawEvidence[i], 'captured_at'),
				created_at: readString(rawEvidence[i], 'created_at')
			}))
		}
		parsed.evidenceFiles = evidenceFiles
	}
	if (parsed.currentStaffId != '') {
		const staffResponse = await supa.from('ml_delivery_staff').select('nickname, phone').eq('uid', parsed.currentStaffId).limit(1).execute()
		if (staffResponse.data != null) {
			const rawStaffList = staffResponse.data as Array<any>
			if (rawStaffList.length > 0) {
				parsed.staffName = readString(rawStaffList[0], 'nickname')
				parsed.staffPhone = readString(rawStaffList[0], 'phone')
			}
		}
	}
	parsed.paymentStatus = 2
	parsed.dispatchStatus = parsed.currentStaffId != '' ? HOMECARE_DISPATCH_STATUS_ASSIGNED : HOMECARE_DISPATCH_STATUS_PENDING
	parsed.dispatchErrorCode = ''
	parsed.dispatchErrorMessage = ''
	return parsed
	}

async function tryCreateCareTask(params: CreateServiceOrderParams): Promise<ServiceOrderType | null> {
	// LEGACY/TODO: 本函数为前端直接 INSERT ec_service_requests + ec_care_tasks 的过渡逻辑。
	// 按新架构，履约工单应在支付完成后由后端 RPC 生成/激活，前端不得直接创建。
	// 当前因缺少后端接口（rpc_consumer_create_homecare_task 或支付回调自动创建）暂时保留，
	// 但已移除前端直接派单（不再写入 assigned_to + ORDER_ASSIGNED）。
	if (ecServiceRequestCreateUnavailable) {
		return null
	}
	const userId = getCurrentUserId()
	if (userId == '') {
		return null
	}
	const requestId = buildUuidLike()
	const taskId = buildUuidLike()
	const taskNo = buildOrderNo()
	const createdAt = nowIso()
	const appointmentTime = normalizeAppointmentTime(params.appointmentTime)
	let requestResponse = await supa.from('ec_service_requests').insert(
		buildEcServiceRequestPayload(params, userId, requestId, createdAt, appointmentTime, true)
	).execute()
	if (shouldBypassEcServiceRequestCreate(requestResponse.error)) {
		ecServiceRequestCreateUnavailable = true
		return null
	}
	if (requestResponse.error != null) {
		requestResponse = await supa.from('ec_service_requests').insert(
			buildEcServiceRequestPayload(params, userId, requestId, createdAt, appointmentTime, false)
		).execute()
	}
	if (shouldBypassEcServiceRequestCreate(requestResponse.error)) {
		ecServiceRequestCreateUnavailable = true
		return null
	}
	if (requestResponse.error != null) {
		requestResponse = await supa.from('ec_service_requests').insert(
			buildEcServiceRequestPayloadWithoutAddress(params, userId, requestId, createdAt, appointmentTime)
		).execute()
	}
	if (shouldBypassEcServiceRequestCreate(requestResponse.error)) {
		ecServiceRequestCreateUnavailable = true
		return null
	}
	if (requestResponse.error != null) {
		return null
	}
	let taskResponse = await supa.from('ec_care_tasks').insert(
		buildEcCareTaskPayload(params, userId, requestId, taskId, taskNo, createdAt, appointmentTime, true)
	).execute()
	if (taskResponse.error != null) {
		taskResponse = await supa.from('ec_care_tasks').insert(
			buildEcCareTaskPayload(params, userId, requestId, taskId, taskNo, createdAt, appointmentTime, false)
		).execute()
	}
	if (taskResponse.error != null) {
		taskResponse = await supa.from('ec_care_tasks').insert(
			buildEcCareTaskPayloadWithoutAddress(params, userId, requestId, taskId, taskNo, createdAt, appointmentTime)
		).execute()
	}
	if (taskResponse.error != null) {
		return null
	}
	// 已移除前端直接派单逻辑。派单应由后端调度系统完成。
	await insertWorkOrderEvent(taskId, '', 'ORDER_CREATED', userId, 'consumer', 'create_task', '创建服务申请')
	return await getCareTaskDetail(taskId)
	}

async function getLegacyServiceOrderDetail(orderId: string): Promise<ServiceOrderType | null> {
	const orderResponse = await supa.from('hss_service_orders').select('*').eq('id', orderId).limit(1).execute()
	if (orderResponse.error != null || orderResponse.data == null) {
		return null
	}
	const rawOrders = orderResponse.data as any[]
	if (rawOrders.length == 0) {
		return null
	}
	const logsResponse = await supa.from('hss_service_order_status_logs').select('*').eq('order_id', orderId).order('created_at', { ascending: false }).execute()
	const reviewResponse = await supa.from('hss_service_reviews').select('*').eq('order_id', orderId).order('created_at', { ascending: false }).execute()
	const executionResponse = await supa.from('hss_service_execution_records').select('*').eq('order_id', orderId).order('created_at', { ascending: false }).limit(1).execute()
	const evidenceResponse = await supa.from('hss_service_evidence_files').select('*').eq('order_id', orderId).order('created_at', { ascending: false }).execute()
	const logs = [] as Array<ServiceOrderTimelineItemType>
	if (logsResponse.data != null) {
		const rawLogs = logsResponse.data as any[]
		for (let i = 0; i < rawLogs.length; i++) {
			logs.push(parseTimeline(rawLogs[i]))
		}
	}
	let review: ServiceReviewType | null = null
	if (reviewResponse.data != null) {
		const rawReviews = reviewResponse.data as any[]
		if (rawReviews.length > 0) {
			review = parseReview(rawReviews[0])
		}
	}
	const parsed = parseServiceOrder(rawOrders[0], logs, review)
	if (executionResponse.data != null) {
		const rawExecutionList = executionResponse.data as any[]
		if (rawExecutionList.length > 0) {
			parsed.executionRecord = parseExecutionRecord(rawExecutionList[0])
		}
	}
	if (evidenceResponse.data != null) {
		const rawEvidenceList = evidenceResponse.data as any[]
		const evidenceFiles = [] as Array<ServiceEvidenceFileType>
		for (let i = 0; i < rawEvidenceList.length; i++) {
			evidenceFiles.push(parseEvidenceFile(rawEvidenceList[i]))
		}
		parsed.evidenceFiles = evidenceFiles
	}
	if (parsed.currentStaffId != '') {
		const staffResponse = await supa.from('ml_delivery_staff').select('nickname, phone').eq('id', parsed.currentStaffId).limit(1).execute()
		if (staffResponse.data != null) {
			const rawStaffList = staffResponse.data as any[]
			if (rawStaffList.length > 0) {
				const staffObj = plainObject(rawStaffList[0])
				parsed.staffName = readString(staffObj, 'nickname')
				parsed.staffPhone = readString(staffObj, 'phone')
			}
		}
	}
	return parsed
	}

export function buildAddressSnapshot(address: UserAddress, latitude: number, longitude: number): ServiceOrderAddressSnapshotType {
	return {
		addressId: address.id,
		contactName: address.recipient_name,
		contactPhone: address.phone,
		province: address.province,
		city: address.city,
		district: address.district,
		detailAddress: address.detail_address,
		fullAddress: address.province + address.city + address.district + ' ' + address.detail_address,
		latitude,
		longitude,
		coordinateType: 'gcj02',
		remark: address.label ?? ''
	}
	}

export function getHomecareOrderDisplayStatus(order: ServiceOrderType): string {
	if (order.paymentStatus == 1 && order.status == 'created' && isHomecarePaymentExpired(order)) {
		return '已超时未支付'
	}
	if (order.paymentStatus == 1 && order.status == 'created') {
		return '待付款'
	}
	if (order.paymentStatus == 2 && order.dispatchStatus == HOMECARE_DISPATCH_STATUS_PENDING) {
		return '待派单'
	}
	if (order.paymentStatus == 2 && order.dispatchStatus == HOMECARE_DISPATCH_STATUS_DISPATCHING) {
		return '正在派单'
	}
	if (order.paymentStatus == 2 && order.dispatchStatus == HOMECARE_DISPATCH_STATUS_FAILED) {
		return '派单未成功'
	}
	if (order.paymentStatus == 2 && order.dispatchStatus == HOMECARE_DISPATCH_STATUS_ASSIGNED) {
		return '已派单'
	}
	return getServiceOrderStatusText(order.status)
}

function isHomecarePaymentExpired(order: ServiceOrderType): boolean {
	if (order.paymentStatus != 1 || order.status != 'created') {
		return false
	}
	const payExpireAt = order.payExpireAt != null ? order.payExpireAt : ''
	if (payExpireAt == '') {
		return false
	}
	const expireMs = Date.parse(payExpireAt)
	if (isNaN(expireMs)) {
		return false
	}
	return expireMs <= Date.now()
}

export async function dispatchPaidHomecareOrder(orderId: string): Promise<HomecareDispatchResult> {
	if (orderId == null || orderId.trim() == '') {
		return {
			success: false,
			code: 'ORDER_ID_REQUIRED',
			message: '订单信息异常，请返回后重试',
			display_type: 'modal',
			retryable: false
		}
	}

	// LEGACY/TODO: rpc_homecare_auto_dispatch 当前只操作 hss_service_orders（旧交易链）。
	// 对于 ec_care_tasks 新链（UUID 格式订单 ID），不要调用旧 RPC，避免错误回写旧表。
	if (shouldUseCareTaskPath(orderId)) {
		return {
			success: true,
			code: 'SYNC_IN_PROGRESS',
			message: '付款成功，服务安排信息正在同步中，请稍后在我的服务中查看。',
			display_type: 'toast',
			retryable: false,
			dispatch_status: HOMECARE_DISPATCH_STATUS_PENDING,
			order_id: orderId
		}
	}

	const { data, error } = await supa.rpc('rpc_homecare_auto_dispatch', {
		p_order_id: orderId
	} as any)

	if (error != null) {
		console.error('[homecare-dispatch] rpc failed:', error)
		return {
			success: false,
			code: 'RPC_EXECUTION_FAILED',
			message: '派单服务暂时异常，请稍后重试',
			display_type: 'modal',
			retryable: true,
			dispatch_status: 'failed',
			order_id: orderId
		}
	}

	if (data == null) {
		return {
			success: false,
			code: 'RPC_EMPTY_RESULT',
			message: '未获取到派单结果，请稍后重试',
			display_type: 'modal',
			retryable: true,
			dispatch_status: 'failed',
			order_id: orderId
		}
	}

	const result = plainObject(data)
	const successValue = result['success']
	const isSuccess = successValue === true || successValue === 'true' || (typeof successValue === 'boolean' && successValue)
	const code = readString(result, 'code')
	const message = readString(result, 'message')
	const displayType = readString(result, 'display_type')
	const retryable = result['retryable'] === true || result['retryable'] === 'true'
	const dispatchStatus = readString(result, 'dispatch_status')

	if (isSuccess || code == 'DISPATCH_ASSIGNED' || code == 'ALREADY_ASSIGNED' || code == 'ALREADY_ASSIGNED_RECOVERED') {
		return {
			success: true,
			code: code != '' ? code : 'DISPATCH_ASSIGNED',
			message: message != '' ? message : '系统已为您匹配服务人员',
			display_type: displayType != '' ? displayType : 'none',
			retryable: false,
			dispatch_status: dispatchStatus != '' ? dispatchStatus : 'assigned',
			order_id: readString(result, 'order_id'),
			assignment_id: readString(result, 'assignment_id'),
			staff_id: readString(result, 'staff_id'),
			station_id: readString(result, 'station_id'),
			dispatch_distance_km: readNumber(result, 'dispatch_distance_km')
		}
	}

	return {
		success: false,
		code: code != '' ? code : 'DISPATCH_FAILED',
		message: message != '' ? message : '派单失败，请稍后重试',
		display_type: displayType != '' ? displayType : 'modal',
		retryable: retryable,
		dispatch_status: dispatchStatus != '' ? dispatchStatus : 'failed',
		order_id: readString(result, 'order_id')
	}
}

export function showHomecareDispatchFailureModal(orderId: string, result: HomecareDispatchResult, retryCallback: (id: string) => void): void {
	const code = result.code
	let title = '操作失败'
	let allowRetry = false

	if (code == 'ORDER_ID_REQUIRED') {
		title = '操作失败'
		allowRetry = false
	} else if (code == 'UNAUTHENTICATED') {
		title = '请重新登录'
		allowRetry = false
	} else if (code == 'USER_PROFILE_NOT_FOUND') {
		title = '账户异常'
		allowRetry = false
	} else if (code == 'ORDER_NOT_FOUND') {
		title = '订单异常'
		allowRetry = false
	} else if (code == 'ORDER_ACCESS_DENIED') {
		title = '无权操作'
		allowRetry = false
	} else if (code == 'ORDER_NOT_PAID') {
		title = '暂不能派单'
		allowRetry = false
	} else if (code == 'ORDER_STATUS_NOT_DISPATCHABLE') {
		title = '暂不能派单'
		allowRetry = false
	} else if (code == 'NO_ONLINE_STAFF' || code == 'NO_STAFF_IN_SERVICE_STATION' || code == 'NO_QUALIFIED_STAFF' || code == 'NO_NEARBY_STAFF' || code == 'ALL_ELIGIBLE_STAFF_BUSY') {
		title = '暂未匹配成功'
		allowRetry = true
	} else if (code == 'DISPATCH_CONFLICT_RETRY') {
		title = '请重新尝试'
		allowRetry = true
	} else if (code == 'RPC_EXECUTION_FAILED' || code == 'RPC_EMPTY_RESULT') {
		title = '派单服务异常'
		allowRetry = true
	} else {
		title = '操作失败'
		allowRetry = result.retryable
	}

	if (!allowRetry) {
		uni.showModal({
			title: title,
			content: result.message,
			showCancel: false,
			confirmText: '我知道了'
		})
		return
	}

	uni.showModal({
		title: title,
		content: result.message,
		showCancel: true,
		cancelText: '稍后再试',
		confirmText: '重新派单',
		success: (res) => {
			if (res.confirm) {
				retryCallback(orderId)
			}
		}
	})
}

export async function createServiceOrder(params: CreateServiceOrderParams): Promise<ServiceOrderType | null> {
	// 当前下单链路分为两层：
	// 1) 交易支付层：hss_service_orders（旧表，仍承担套餐价格快照与支付状态）。
	// 2) 履约工单层：ec_care_tasks（新表，应由后端在支付成功后生成/激活）。
	// 非套餐单当前走 tryCreateCareTask（LEGACY，前端直接写 ec_service_requests + ec_care_tasks），
	// 待后端提供 rpc_consumer_create_homecare_task 后应统一切到后端创建。
	if (params.packageInfo.id == '') {
		const newTask = await tryCreateCareTask(params)
		if (newTask != null) {
			return newTask
		}
	}
	const userId = getCurrentUserId()
	if (userId == '') {
		return null
	}
	const orderId = buildId('so')
	const orderNo = buildOrderNo()
	const now = new Date().toISOString()
	const appointmentTime = normalizeAppointmentTime(params.appointmentTime)
	const pricingSnapshot = buildPricingSnapshot(params)
	const serviceSnapshot = buildServiceSnapshot(params)
	const payableAmount = params.packageInfo.price
	const response = await supa.from('hss_service_orders').insert({
		id: orderId,
		order_no: orderNo,
		user_id: userId,
		service_id: params.service.id,
		service_name: params.service.name,
		service_snapshot_json: serviceSnapshot,
		service_package_id: params.packageInfo.id,
		pricing_snapshot_json: pricingSnapshot,
		original_amount: params.packageInfo.listPrice > 0 ? params.packageInfo.listPrice : payableAmount,
		payable_amount: payableAmount,
		total_amount: payableAmount,
		service_address_id: normalizeUuidOrNull(params.address.addressId),
		address_snapshot_json: params.address as any,
		recipient_name: params.recipientName,
		recipient_phone: params.recipientPhone,
		recipient_age: params.recipientAge,
		recipient_gender: params.recipientGender,
		contact_name: params.contactName,
		contact_phone: params.contactPhone,
		appointment_time: appointmentTime,
		remark: params.remark,
		status: 'created',
		payment_status: 1,
		created_at: now,
		updated_at: now
	}).execute()
	if (response.error != null) {
		console.error('createServiceOrder failed', response.error)
		return null
	}
	await insertLegacyStatusLog(orderId, '', 'created', userId, 'consumer', '创建服务订单')
	return await getLegacyServiceOrderDetail(orderId)
}

export async function listConsumerServiceOrders(): Promise<Array<ServiceOrderType>> {
	const userId = getCurrentUserId()
	if (userId == '') {
		return [] as Array<ServiceOrderType>
	}
	const careTaskResponse = await supa.from('ec_care_tasks').select('*').eq('user_id', userId).order('created_at', { ascending: false }).execute()
	if (careTaskResponse.error == null && careTaskResponse.data != null) {
		const rawTasks = careTaskResponse.data as Array<any>
		const taskResult = [] as Array<ServiceOrderType>
		for (let i = 0; i < rawTasks.length; i++) {
			const parsed = await getCareTaskDetail(readString(rawTasks[i], 'id'))
			if (parsed != null) {
				taskResult.push(parsed)
			}
		}
		return taskResult
	}
	const response = await supa.from('hss_service_orders').select('*').eq('user_id', userId).order('created_at', { ascending: false }).execute()
	if (response.error != null || response.data == null) {
		return [] as Array<ServiceOrderType>
	}
	const list = response.data as any[]
	const result = [] as Array<ServiceOrderType>
	for (let i = 0; i < list.length; i++) {
		const parsed = await getLegacyServiceOrderDetail(JSON.parse(JSON.stringify(list[i]))['id'] as string)
		if (parsed != null) {
			result.push(parsed)
		}
	}
	return result
	}

export async function getServiceOrderDetail(orderId: string): Promise<ServiceOrderType | null> {
	if (shouldUseCareTaskPath(orderId)) {
		const careTask = await getCareTaskDetail(orderId)
		if (careTask != null) {
			return careTask
		}
	}
	return await getLegacyServiceOrderDetail(orderId)
	}

export async function saveServiceRecord(orderId: string, record: DeliveryServiceRecordType): Promise<ServiceOrderType | null> {
	const userId = getCurrentUserId()
	if (userId == '') {
		return null
	}
	const careTask = shouldUseCareTaskPath(orderId) ? await getCareTaskDetail(orderId) : null
	if (careTask != null) {
		// TODO/GAP: consumer 端保存服务记录（ec_care_tasks 新链）暂无后端 RPC。
		// 禁止前端直接 insert ec_care_records / update ec_care_tasks。
		// 如需启用，请后端补充 rpc_consumer_save_service_record(task_id, record)。
		console.warn('[GAP] saveServiceRecord 暂不可用（新链）：缺少 consumer 保存服务记录 RPC')
		uni.showToast({ title: '服务记录功能正在升级，请稍后重试', icon: 'none' })
		return await getCareTaskDetail(orderId)
	}
	const current = await getLegacyServiceOrderDetail(orderId)
	if (current == null) {
		return null
	}
	const savedAt = nowIso()
	const serviceSummary = record.serviceSummary != '' ? record.serviceSummary : record.processNote
	const saveResponse = await supa.from('hss_service_execution_records').insert({
		id: buildId('ser'),
		order_id: orderId,
		checkin_time: current.executionRecord != null ? current.executionRecord.checkin_time : savedAt,
		checkin_latitude: current.executionRecord != null ? current.executionRecord.checkin_latitude : 0,
		checkin_longitude: current.executionRecord != null ? current.executionRecord.checkin_longitude : 0,
		checkin_address: current.executionRecord != null ? current.executionRecord.checkin_address : '',
		service_content_json: record.serviceContent.length > 0 ? record.serviceContent as any : record.serviceItems.map(item => item.name) as any,
		service_summary: serviceSummary,
		completion_images_json: record.photos as any,
		signature_image: '',
		signature_name: record.familyConfirmation.familyMember,
		created_at: savedAt,
		updated_at: savedAt
	}).execute()
	if (saveResponse.error != null) {
		return null
	}
	await supa.from('hss_service_orders').update({
		updated_at: savedAt
	}).eq('id', orderId).execute()
	return await getLegacyServiceOrderDetail(orderId)
}

export async function confirmServiceOrder(orderId: string, rating: number, content: string, tags: Array<string>): Promise<ServiceOrderType | null> {
	const userId = getCurrentUserId()
	if (userId == '') {
		return null
	}
	const careTask = shouldUseCareTaskPath(orderId) ? await getCareTaskDetail(orderId) : null
	if (careTask != null) {
		// TODO/GAP: consumer 确认验收（ec_care_tasks 新链）暂无后端 RPC。
		// 禁止前端直接 update ec_care_tasks / insert ec_care_records / insert hc_work_order_events。
		// 如需启用，请后端补充 rpc_consumer_confirm_acceptance(task_id, rating, feedback, tags)。
		console.warn('[GAP] confirmServiceOrder 暂不可用（新链）：缺少 consumer 确认验收 RPC')
		uni.showToast({ title: '验收功能正在升级，请稍后重试', icon: 'none' })
		return await getCareTaskDetail(orderId)
	}
	// LEGACY: 以下仍为旧 hss_service_orders 链路，仅用于兼容已有交易订单。
	const current = await getServiceOrderDetail(orderId)
	if (current == null) {
		return null
	}
	const acceptedAt = new Date().toISOString()
	const updateResponse = await supa.from('hss_service_orders').update({
		status: 'accepted_by_user',
		accepted_by_user_at: acceptedAt,
		updated_at: acceptedAt
	}).eq('id', orderId).execute()
	if (updateResponse.error != null) {
		return null
	}
	await insertLegacyStatusLog(orderId, current.status, 'accepted_by_user', userId, 'consumer', '用户确认验收')
	await supa.from('hss_service_reviews').insert({
		id: buildId('srv'),
		order_id: orderId,
		user_id: userId,
		rating,
		tags_json: tags as any,
		content,
		created_at: acceptedAt
	}).execute()
	await supa.from('hss_service_orders').update({
		status: 'reviewed',
		reviewed_at: acceptedAt,
		updated_at: acceptedAt
	}).eq('id', orderId).execute()
	await insertLegacyStatusLog(orderId, 'accepted_by_user', 'reviewed', userId, 'consumer', '用户提交评价')
	return await getLegacyServiceOrderDetail(orderId)
	}

export async function rejectServiceOrderAcceptance(orderId: string, content: string): Promise<ServiceOrderType | null> {
	const userId = getCurrentUserId()
	if (userId == '') {
		return null
	}
	const careTask = shouldUseCareTaskPath(orderId) ? await getCareTaskDetail(orderId) : null
	if (careTask != null) {
		// TODO/GAP: consumer 拒绝验收（ec_care_tasks 新链）暂无后端 RPC。
		// 禁止前端直接 update ec_care_tasks / insert hc_work_order_exceptions。
		// 如需启用，请后端补充 rpc_consumer_reject_acceptance(task_id, feedback)。
		console.warn('[GAP] rejectServiceOrderAcceptance 暂不可用（新链）：缺少 consumer 拒绝验收 RPC')
		uni.showToast({ title: '验收功能正在升级，请稍后重试', icon: 'none' })
		return await getCareTaskDetail(orderId)
	}
	// LEGACY: 以下仍为旧 hss_service_orders 链路。
	const current = await getServiceOrderDetail(orderId)
	if (current == null) {
		return null
	}
	const updateResponse = await supa.from('hss_service_orders').update({
		status: 'exception',
		updated_at: nowIso()
	}).eq('id', orderId).execute()
	if (updateResponse.error != null) {
		return null
	}
	await insertLegacyStatusLog(orderId, current.status, 'exception', userId, 'consumer', content == '' ? '用户退回整改' : content)
	return await getLegacyServiceOrderDetail(orderId)
	}

export async function getCurrentConsumerUser() {
	return await getCurrentUser()
	}