owl-admin/app/Services/Client/CoachService.php

<?php

namespace App\Services\Client;

use App\Enums\OrderStatus;
use App\Enums\TechnicianAuthStatus;
use App\Enums\TechnicianLocationType;
use App\Enums\TechnicianStatus;
use App\Enums\TechnicianWorkStatus;
use App\Enums\UserStatus;
use App\Models\CoachSchedule;
use App\Models\CoachUser;
use App\Models\MemberUser;
use App\Models\Order;
use Illuminate\Support\Carbon;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Redis;

class CoachService
{
    /**
     * 获取技师列表
     *
     * @param  int  $userId  用户ID
     * @param  float  $latitude  纬度
     * @param  float  $longitude  经度
     * @return array ['items' => array, 'total' => int]
     *
     * @throws \Exception
     */
    public function getNearCoachList(int $userId, float $latitude, float $longitude)
    {
        try {
            // 参数验证
            abort_if(! is_numeric($latitude) || ! is_numeric($longitude), 400, '无效的经纬度坐标');
            abort_if($latitude < -90 || $latitude > 90 || $longitude < -180 || $longitude > 180,
                400, '经纬度超出有效范围');

            $page = max(1, (int) request()->get('page', 1));
            $perPage = max(1, min(50, (int) request()->get('per_page', 15)));

            // 获取当前用户并检查状态
            $user = MemberUser::select(['id', 'state'])->find($userId);
            abort_if(! $user, 404, '用户不存在');
            abort_if($user->state !== UserStatus::OPEN->value, 400, '用户状态异常');

            Log::info('开始获取附近技师列表', [
                'user_id' => $userId,
                'latitude' => $latitude,
                'longitude' => $longitude,
                'page' => $page,
                'per_page' => $perPage,
            ]);

            // 使用缓存减少Redis查询压力
            $cacheKey = "nearby_coaches:{$latitude}:{$longitude}";
            $nearbyCoachIds = Cache::remember($cacheKey, now()->addMinutes(1), function () use ($longitude, $latitude) {
                return Redis::georadius(
                    'coach_locations',
                    $longitude,
                    $latitude,
                    40,
                    'km',
                    ['WITHDIST', 'ASC']
                ) ?: [];
            });

            if (empty($nearbyCoachIds)) {
                Log::info('附近没有找到技师', compact('latitude', 'longitude'));

                return ['items' => [], 'total' => 0];
            }

            // 处理技师数据
            $coachData = collect($nearbyCoachIds)->map(function ($item) {
                [$id, $type] = explode('_', $item[0]);

                return [
                    'id' => (int) $id,
                    'type' => $type,
                    'distance' => round((float) $item[1], 2),
                ];
            })->unique('id')->values();

            // 分页处理
            $total = $coachData->count();
            $offset = ($page - 1) * $perPage;
            $paginatedCoachIds = $coachData->slice($offset, $perPage)
                ->pluck('id')
                ->toArray();

            if (empty($paginatedCoachIds)) {
                return ['items' => [], 'total' => 0];
            }

            // 查询数据库获取技师信息
            $coaches = CoachUser::query()
                ->whereIn('id', $paginatedCoachIds)
                ->where('state', TechnicianStatus::ACTIVE->value)
                ->whereHas('info', function ($query) {
                    $query->where('state', TechnicianAuthStatus::PASSED->value);
                })
                ->whereHas('real', function ($query) {
                    $query->where('state', TechnicianAuthStatus::PASSED->value);
                })
                ->whereHas('qual', function ($query) {
                    $query->where('state', TechnicianAuthStatus::PASSED->value);
                })
                ->with(['info' => function ($query) {
                    $query->select(['id', 'coach_id', 'nickname', 'avatar', 'gender', 'state']);
                }])
                ->get();

            // 设置距离并格式化数据
            $items = $coaches->map(function ($coach) use ($coachData) {
                $distanceData = $coachData->firstWhere('id', $coach->id);

                return [
                    'id' => $coach->id,
                    'nickname' => $coach->info->nickname ?? '',
                    'avatar' => $coach->info->avatar ?? '',
                    'gender' => $coach->info->gender ?? '',
                    'state' => $coach->state,
                    'state_text' => TechnicianStatus::fromValue($coach->state)->label(),
                    'work_status' => $coach->work_status,
                    'work_status_text' => TechnicianWorkStatus::fromValue($coach->work_status)->label(),
                    'distance' => $distanceData ? $distanceData['distance'] : null,
                ];
            })->sortBy('distance')->values()->all();

            Log::info('成功获取附近技师列表', [
                'total' => $total,
                'page' => $page,
                'per_page' => $perPage,
                'found' => count($items),
            ]);

            return [
                'items' => $items,
                'total' => $total,
            ];

        } catch (\Exception $e) {
            Log::error('获取附近技师列表失败', [
                'user_id' => $userId,
                'latitude' => $latitude,
                'longitude' => $longitude,
                'error' => $e->getMessage(),
                'trace' => $e->getTraceAsString(),
            ]);
            throw $e;
        }
    }

    /**
     * 获取技师详情
     */
    public function getCoachDetail($coachId, $latitude, $longitude)
    {
        // 检查Redis连接
        try {
            $pingResult = Redis::connection()->ping();
            Log::info('Redis connection test:', ['ping_result' => $pingResult]);
        } catch (\Exception $e) {
            Log::error('Redis connection error:', ['error' => $e->getMessage()]);
            throw new \Exception('Redis连接失败：'.$e->getMessage());
        }

        // 检查Redis中的所有位置数据
        $allLocations = Redis::zrange('coach_locations', 0, -1, 'WITHSCORES');
        Log::info('All locations in Redis:', ['locations' => $allLocations]);

        // 获取当前用户
        $user = Auth::user();

        Log::info('Current user and coordinates:', [
            'user' => $user ? $user->id : null,
            'latitude' => $latitude,
            'longitude' => $longitude,
            'coach_id' => $coachId,
        ]);

        // 检查用户状态
        if (! $user) {
            throw new \Exception('用户未登录');
        }

        if ($user->state !== UserStatus::OPEN->value) {
            throw new \Exception('用户状态异常');
        }
        // 获取技师信息
        $coach = CoachUser::where('state', TechnicianStatus::ACTIVE->value)
            ->whereHas('info', function ($query) {
                $query->where('state', TechnicianAuthStatus::PASSED->value);
            })
            ->whereHas('real', function ($query) {
                $query->where('state', TechnicianAuthStatus::PASSED->value);
            })
            ->whereHas('qual', function ($query) {
                $query->where('state', TechnicianAuthStatus::PASSED->value);
            })
            ->with(['info:id,nickname,avatar,gender'])
            ->find($coachId);

        if (! $coach) {
            throw new \Exception('技师不存在');
        }

        // 从 Redis 获取技师的 id_home 和 id_work 的经纬度
        $homeLocation = Redis::geopos('coach_locations', $coachId.'_'.TechnicianLocationType::COMMON->value);
        $workLocation = Redis::geopos('coach_locations', $coachId.'_'.TechnicianLocationType::CURRENT->value);

        // 检查输入的经纬度是否有效
        if (! is_numeric($latitude) || ! is_numeric($longitude)) {
            Log::error('Invalid coordinates:', ['latitude' => $latitude, 'longitude' => $longitude]);
            throw new \Exception('无效的经纬度坐标');
        }

        // 临时存储用户当前位置用于计算距离
        $tempKey = 'user_temp_'.$user->id;
        Redis::geoadd('coach_locations', $longitude, $latitude, $tempKey);

        // 计算距离（单位：km）
        $distanceHome = null;
        $distanceWork = null;

        if ($homeLocation && ! empty($homeLocation[0])) {
            $distanceHome = Redis::geodist('coach_locations', $tempKey, $coachId.'_'.TechnicianLocationType::COMMON->value, 'km');
            Log::info('Home distance calculation:', [
                'from' => $tempKey,
                'to' => $coachId.'_'.TechnicianLocationType::COMMON->value,
                'distance' => $distanceHome,
                'home_location' => $homeLocation[0],
            ]);
        }

        if ($workLocation && ! empty($workLocation[0])) {
            $distanceWork = Redis::geodist('coach_locations', $tempKey, $coachId.'_'.TechnicianLocationType::CURRENT->value, 'km');
        }

        // 删除临时位置点
        Redis::zrem('coach_locations', $tempKey);

        // 选择最近的距离
        $distances = array_filter([$distanceHome, $distanceWork]);
        $coach->distance = ! empty($distances) ? round(min($distances), 2) : null;

        return $coach;
    }

    /**
     * 设置技师位置信息
     *
     * @param  int  $coachId  技师ID
     * @param  float  $latitude  纬度
     * @param  float  $longitude  经度
     * @param  int  $type  位置类型 (current|common)
     * @return bool
     *
     * @throws \Exception
     */
    public function setCoachLocation($coachId, $latitude, $longitude, $type = TechnicianLocationType::COMMON->value)
    {
        if (! is_numeric($latitude) || ! is_numeric($longitude)) {
            Log::error('Invalid coordinates in setCoachLocation:', [
                'coach_id' => $coachId,
                'latitude' => $latitude,
                'longitude' => $longitude,
            ]);
            throw new \Exception('无效的经纬度坐标');
        }

        if (! in_array($type, [TechnicianLocationType::CURRENT->value, TechnicianLocationType::COMMON->value])) {
            throw new \Exception('无效的位置类型，必须是 current 或 common');
        }

        $key = $coachId.'_'.$type;
        $result = Redis::geoadd('coach_locations', $longitude, $latitude, $key);

        Log::info('Coach location set:', [
            'coach_id' => $coachId,
            'type' => $type,
            'key' => $key,
            'latitude' => $latitude,
            'longitude' => $longitude,
            'result' => $result,
        ]);

        // 验证数据是否成功写入
        $location = Redis::geopos('coach_locations', $key);
        Log::info('Verify location after set:', [
            'key' => $key,
            'location' => $location,
        ]);

        return $result;
    }

    /**
     * 获取技师可预约时间段列表
     *
     * @param  int  $coachId  技师ID
     * @param  string|null  $date  日期，默认当天
     * @return array 返回格式：[
     *               'date' => '2024-03-22',
     *               'day_of_week' => '星期五',
     *               'is_today' => false,
     *               'time_slots' => [
     *               [
     *               'start_time' => '09:00',
     *               'end_time' => '09:30',
     *               'is_available' => true,
     *               'duration' => 30
     *               ]
     *               ],
     *               'total_slots' => 1,
     *               'updated_at' => '2024-03-22 10:00:00'
     *               ]
     *
     * @throws \Exception
     */
    public function getSchedule(int $coachId, ?string $date = null)
    {
        try {
            // 默认使用当天日期
            $date = $date ?: now()->toDateString();
            $targetDate = Carbon::parse($date);

            // 验证技师信息
            $coach = CoachUser::with('info')->find($coachId);
            abort_if(! $coach, 404, '技师不存在');
            abort_if($coach->info->state != TechnicianStatus::ACTIVE->value,
                400, '技师状态异常');

            // 验证日期
            abort_if($targetDate->startOfDay()->lt(now()->startOfDay()),
                400, '不能查询过去的日期');
            abort_if($targetDate->diffInDays(now()) > 30,
                400, '只能查询未来30天内的时间段');

            // 使用缓存减少数据库查询
            return Cache::remember(
                "coach:timeslots:{$coachId}:{$date}",
                now()->addMinutes(15), // 缓存15分钟
                function () use ($coachId, $date, $targetDate) {
                    // 获取技师排班信息
                    $schedule = CoachSchedule::where('coach_id', $coachId)
                        ->where('state', 1)
                        ->first();

                    if (! $schedule || empty($schedule->time_ranges)) {
                        return $this->formatResponse($date, []);
                    }

                    $timeRanges = json_decode($schedule->time_ranges, true);

                    // 获取当天所有订单
                    $dayOrders = $this->getDayOrders($coachId, $date);

                    // 生成时间段列表
                    $timeSlots = $this->generateAvailableTimeSlots(
                        $date,
                        $timeRanges,
                        $dayOrders,
                        $targetDate->isToday()
                    );

                    return $this->formatResponse($date, $timeSlots);
                }
            );

        } catch (\Exception $e) {
            Log::error('获取可预约时间段失败', [
                'coach_id' => $coachId,
                'date' => $date,
                'error' => $e->getMessage(),
                'trace' => $e->getTraceAsString(),
            ]);
            throw $e;
        }
    }

    /**
     * 获取当天所有订单
     *
     * @param  int  $coachId  技师ID
     * @param  string  $date  日期
     * @return array 订单列表
     */
    private function getDayOrders(int $coachId, string $date): array
    {
        return Order::where('coach_id', $coachId)
            ->where('service_time', $date)
            ->whereIn('state', [
                OrderStatus::ACCEPTED->value,
                OrderStatus::DEPARTED->value,
                OrderStatus::ARRIVED->value,
                OrderStatus::SERVING->value,
            ])
            ->select(['id', 'service_start_time', 'service_end_time', 'state'])
            ->get()
            ->toArray();
    }

    /**
     * 生成可用时间段列表
     *
     * @param  string  $date  日期
     * @param  array  $timeRanges  排班时间段
     * @param  array  $dayOrders  当天订单
     * @param  bool  $isToday  是否是当天
     * @return array 可用时间段列表
     */
    private function generateAvailableTimeSlots(
        string $date,
        array $timeRanges,
        array $dayOrders,
        bool $isToday
    ): array {
        $timeSlots = [];
        $currentTime = now();

        foreach ($timeRanges as $range) {
            $start = Carbon::parse($date.' '.$range['start_time']);
            $end = Carbon::parse($date.' '.$range['end_time']);

            // 如果是当天且开始时间已过，从下一个30分钟时间点开始
            if ($isToday && $start->lt($currentTime)) {
                $start = $currentTime->copy()->addMinutes(30)->floorMinutes(30);
                // 如果调整后的开始时间已超过结束时间，跳过此时间段
                if ($start->gt($end)) {
                    continue;
                }
            }

            // 生成30分钟间隔的时间段
            while ($start->lt($end)) {
                $slotStart = $start->format('H:i');
                $slotEnd = $start->copy()->addMinutes(30)->format('H:i');

                // 检查时间段是否被订单占用
                if (! $this->hasConflictingOrder($date, $slotStart, $slotEnd, $dayOrders)) {
                    $timeSlots[] = [
                        'start_time' => $slotStart,
                        'end_time' => $slotEnd,
                        'is_available' => true,
                        'duration' => 30,
                    ];
                }

                $start->addMinutes(30);
            }
        }

        return $timeSlots;
    }

    /**
     * 格式化返回数据
     *
     * @param  string  $date  日期
     * @param  array  $timeSlots  时间段列表
     * @return array 格式化后的数据
     */
    private function formatResponse(string $date, array $timeSlots): array
    {
        $targetDate = Carbon::parse($date);

        return [
            'date' => $date,
            'day_of_week' => $targetDate->isoFormat('dddd'), // 星期几
            'is_today' => $targetDate->isToday(),
            'time_slots' => $timeSlots,
            'total_slots' => count($timeSlots),
            'updated_at' => now()->toDateTimeString(),
        ];
    }

    /**
     * 检查是否与已有订单冲突
     *
     * @param  string  $date  日期
     * @param  string  $startTime  开始时间
     * @param  string  $endTime  结束时间
     * @param  array  $dayOrders  当天订单
     * @return bool 是否冲突
     */
    private function hasConflictingOrder(
        string $date,
        string $startTime,
        string $endTime,
        array $dayOrders
    ): bool {
        $slotStart = Carbon::parse("$date $startTime");
        $slotEnd = Carbon::parse("$date $endTime");

        foreach ($dayOrders as $order) {
            $orderStart = Carbon::parse($order['service_start_time']);
            $orderEnd = Carbon::parse($order['service_end_time']);

            // 检查时间段是否重叠
            if (($slotStart >= $orderStart && $slotStart < $orderEnd) ||
                ($slotEnd > $orderStart && $slotEnd <= $orderEnd) ||
                ($slotStart <= $orderStart && $slotEnd >= $orderEnd)) {
                return true;
            }
        }

        return false;
    }
}