owl-admin/app/Services/Coach/AccountService.php

<?php

namespace App\Services\Coach;

use App\Enums\TechnicianAuthStatus;
use App\Enums\TechnicianLocationType;
use App\Models\CoachSchedule;
use App\Models\MemberUser;
use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Redis;

class AccountService
{
    private const CACHE_KEY_PREFIX = 'coach_info_';

    private const CACHE_TTL = 300; // 5分钟

    /**
     * 提交技师基本信息
     */
    public function submitBaseInfo($user, array $data)
    {
        DB::beginTransaction();
        try {
            $this->setTransactionConfig();

            abort_if(! $user->coach, 404, '技师信息不存在');

            // 检查是否有待审核的记录
            $pendingRecord = $user->coach->infoRecords()
                ->where('state', TechnicianAuthStatus::AUDITING->value)
                ->exists();
            abort_if($pendingRecord, 422, '已有待审核的基本信息记录');

            // 创建技师信息
            $record = $user->coach->infoRecords()->create(array_merge($data, [
                'state' => TechnicianAuthStatus::AUDITING->value,
            ]));

            // 清除技师信息缓存
            $this->clearCoachCache($user->coach->id);

            DB::commit();

            $this->logInfo('技师提交基本信息成功', $user, $data);

            return ['message' => '基本信息提交成功'];

        } catch (\Exception $e) {
            DB::rollBack();
            $this->logError('提交技师基本信息失败', $user, $data, $e);
            throw $e;
        }
    }

    /**
     * 提交技师资质信息
     */
    public function submitQualification($user, array $data)
    {
        DB::beginTransaction();
        try {
            $this->setTransactionConfig();

            abort_if(! $user->coach, 404, '技师信息不存在');

            // 检查是否有待审核的记录
            $pendingRecord = $user->coach->qualRecords()
                ->where('state', TechnicianAuthStatus::AUDITING->value)
                ->exists();
            abort_if($pendingRecord, 422, '已有待审核的资质信息记录');

            // 创建资质信息
            $record = $user->coach->qualRecords()->create(array_merge($data, [
                'state' => TechnicianAuthStatus::AUDITING->value,
            ]));

            // 清除技师信息缓存
            $this->clearCoachCache($user->coach->id);

            DB::commit();

            $this->logInfo('技师提交资质信息成功', $user, $data);

            return ['message' => '资质信息提交成功'];

        } catch (\Exception $e) {
            DB::rollBack();
            $this->logError('提交技师资质信息失败', $user, $data, $e);
            throw $e;
        }
    }

    /**
     * 提交实名认证信息
     */
    public function submitRealName($user, array $data)
    {
        DB::beginTransaction();
        try {
            $this->setTransactionConfig();

            abort_if(! $user->coach, 404, '技师信息不存在');

            // 检查是否有待审核的记录
            $pendingRecord = $user->coach->realRecords()
                ->where('state', TechnicianAuthStatus::AUDITING->value)
                ->exists();
            abort_if($pendingRecord, 422, '已有待审核的实名认证信息');

            // 创建实名认证信息
            $record = $user->coach->realRecords()->create(array_merge($data, [
                'state' => TechnicianAuthStatus::AUDITING->value,
            ]));

            // 清除技师信息缓存
            $this->clearCoachCache($user->coach->id);

            DB::commit();

            $this->logInfo('技师提交实名认证信息成功', $user, $this->maskSensitiveData($data));

            return ['message' => '实名认证信息提交成功'];

        } catch (\Exception $e) {
            DB::rollBack();
            $this->logError('提交实名认证信息失败', $user, $this->maskSensitiveData($data), $e);
            throw $e;
        }
    }

    /**
     * 获取技师信息
     */
    public function getCoachInfo($user)
    {
        try {
            abort_if(! $user, 404, '用户不存在');
            abort_if(! $user->coach, 404, '技师信息不存在');

            return Cache::remember(
                self::CACHE_KEY_PREFIX.$user->coach->id,
                self::CACHE_TTL,
                function () use ($user) {
                    return $this->fetchCoachInfo($user->coach);
                }
            );
        } catch (\Exception $e) {
            $this->logError('获取技师信息失败', $user, [], $e);
            throw $e;
        }
    }

    /**
     * 设置事务配置
     */
    private function setTransactionConfig()
    {
        DB::statement('SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED');
        DB::statement('SET SESSION innodb_lock_wait_timeout=10');
    }

    /**
     * 记录信息日志
     */
    private function logInfo(string $message, $user, array $data)
    {
        Log::info($message, [
            'user_id' => $user->id,
            'coach_id' => $user->coach->id,
            'data' => $data,
            'ip' => request()->ip(),
            'timestamp' => now()->toDateTimeString(),
        ]);
    }

    /**
     * 记录错误日志
     */
    private function logError(string $message, $user, array $data, \Exception $e)
    {
        Log::error($message, [
            'user_id' => $user->id,
            'coach_id' => $user->coach->id ?? null,
            'data' => $data,
            'error' => $e->getMessage(),
            'file' => $e->getFile(),
            'line' => $e->getLine(),
            'ip' => request()->ip(),
            'timestamp' => now()->toDateTimeString(),
        ]);
    }

    /**
     * 获取技师详细信息
     */
    private function fetchCoachInfo($coach)
    {
        $baseInfo = $coach->infoRecords()->latest()->first();
        $qualification = $coach->qualRecords()->latest()->first();
        $realName = $coach->realRecords()->latest()->first();

        return [
            'base_info' => $baseInfo ? $this->formatBaseInfo($baseInfo) : null,
            'qualification' => $qualification ? $this->formatQualification($qualification) : null,
            'real_name' => $realName ? $this->formatRealName($realName) : null,
        ];
    }

    /**
     * 格式化基本信息
     */
    private function formatBaseInfo($info)
    {
        return [
            'nickname' => $info->nickname,
            'avatar' => $info->avatar,
            'gender' => $info->gender,
            'mobile' => $this->maskMobile($info->mobile),
            'birthday' => $info->birthday,
            'work_years' => $info->work_years,
            'intention_city' => $info->intention_city,
            'introduction' => $info->introduction,
            'state' => $info->state,
            'state_text' => TechnicianAuthStatus::fromValue($info->state)->label(),
            'audit_remark' => $info->audit_remark,
        ];
    }

    /**
     * 格式化资质信息
     */
    private function formatQualification($qual)
    {
        return [
            'qual_type' => $qual->qual_type,
            'qual_no' => $qual->qual_no,
            'qual_photo' => $qual->qual_photo,
            'valid_start' => $qual->valid_start,
            'valid_end' => $qual->valid_end,
            'state' => $qual->state,
            'state_text' => TechnicianAuthStatus::fromValue($qual->state)->label(),
            'audit_remark' => $qual->audit_remark,
        ];
    }

    /**
     * 格式化实名信息
     */
    private function formatRealName($real)
    {
        return [
            'real_name' => $real->real_name,
            'id_card' => $this->maskIdCard($real->id_card),
            'id_card_front_photo' => $real->id_card_front_photo,
            'id_card_back_photo' => $real->id_card_back_photo,
            'id_card_hand_photo' => $real->id_card_hand_photo,
            'state' => $real->state,
            'state_text' => TechnicianAuthStatus::fromValue($real->state)->label(),
            'audit_remark' => $real->audit_remark,
        ];
    }

    /**
     * 手机号脱敏
     */
    private function maskMobile($mobile)
    {
        return substr_replace($mobile, '****', 3, 4);
    }

    /**
     * 身份证号脱敏
     */
    private function maskIdCard($idCard)
    {
        return substr_replace($idCard, '****', 6, 8);
    }

    /**
     * 敏感数据脱敏
     */
    private function maskSensitiveData(array $data)
    {
        if (isset($data['id_card'])) {
            $data['id_card'] = $this->maskIdCard($data['id_card']);
        }
        if (isset($data['mobile'])) {
            $data['mobile'] = $this->maskMobile($data['mobile']);
        }

        return $data;
    }

    /**
     * 清除技师信息缓存
     */
    private function clearCoachCache($coachId)
    {
        Cache::forget(self::CACHE_KEY_PREFIX.$coachId);
    }

    /**
     * 设置定位信息
     *
     * @param  int  $coachId  技师ID
     * @param  float  $latitude  纬度
     * @param  float  $longitude  经度
     * @param  int  $type  位置类型 (current：1|common：2)
     * @return bool
     *
     * @throws \Exception
     */
    public function setLocation($coachId, $latitude, $longitude, $type = TechnicianLocationType::COMMON->value)
    {
        DB::beginTransaction();
        try {
            // 验证经纬度参数
            if (! is_numeric($latitude) || ! is_numeric($longitude)) {
                throw new \Exception('无效的经纬度坐标');
            }

            // 验证位置类型
            if (! in_array($type, [TechnicianLocationType::CURRENT->value, TechnicianLocationType::COMMON->value])) {
                throw new \Exception('无效的位置类型');
            }

            // 生成Redis键
            $key = $coachId.'_'.$type;

            // 将位置信息写入Redis
            $result = Redis::geoadd('coach_locations', $longitude, $latitude, $key);

            // 同时写入数据库保存历史记录
            DB::table('coach_locations')->updateOrInsert(
                ['coach_id' => $coachId, 'type' => $type],
                [
                    'latitude' => $latitude,
                    'longitude' => $longitude,
                    'updated_at' => now(),
                ]
            );

            DB::commit();

            Log::info('技师位置信息设置成功', [
                'coach_id' => $coachId,
                'type' => $type,
                'latitude' => $latitude,
                'longitude' => $longitude,
            ]);

            return $result;

        } catch (\Exception $e) {
            DB::rollBack();
            Log::error('技师位置信息设置异常', [
                'coach_id' => $coachId,
                'latitude' => $latitude,
                'longitude' => $longitude,
                'type' => $type,
                'error' => $e->getMessage(),
                'file' => $e->getFile(),
                'line' => $e->getLine(),
            ]);
            throw $e;
        }
    }

    /**
     * 获取技师位置信息
     *
     * @param  int  $userId  用户ID
     * @return array 位置信息
     */
    public function getLocation($userId)
    {
        try {
            // 改进：直接使用 coach 模型
            $user = MemberUser::find($userId);
            abort_if(! $user, 404, '用户不存在');
            abort_if(! $user->coach, 404, '技师信息不存在');

            // 获取常用位置信息
            $location = $user->coach->locations()
                ->where('type', TechnicianLocationType::COMMON->value)
                ->first();

            $result = [
                'address' => $location ? $location->location : null,
            ];

            // 记录日志
            Log::info('获取技师常用位置信息成功', [
                'coach_id' => $user->coach->id,
                'location' => $result,
            ]);

            return $result;

        } catch (\Exception $e) {
            Log::error('获取技师常用位置信息异常', [
                'coach_id' => $user->coach->id ?? null,
                'error' => $e->getMessage(),
                'file' => $e->getFile(),
                'line' => $e->getLine(),
            ]);
            throw $e;
        }
    }

    /**
     * 设置技师排班时间(每天通用)
     *
     * @param  int  $userId  技师用户ID
     * @param  array  $timeRanges  时间段数组 格式: [
     *                             ['start_time' => '09:00', 'end_time' => '12:00'],
     *                             ['start_time' => '14:00', 'end_time' => '18:00']
     *                             ]
     *
     * @throws \Exception
     */
    public function setSchedule(int $userId, array $timeRanges): array
    {
        return DB::transaction(function () use ($userId, $timeRanges) {
            try {
                // 获取技师信息
                $user = MemberUser::with(['coach'])->findOrFail($userId);
                $coach = $user->coach;
                abort_if(! $coach, 404, '技师信息不存在');

                // 验证并排序时间段
                $sortedRanges = $this->validateAndSortTimeRanges($timeRanges);

                // 创建或更新排班记录
                $schedule = CoachSchedule::updateOrCreate(
                    [
                        'coach_id' => $coach->id,
                    ],
                    [
                        'time_ranges' => json_encode($sortedRanges),
                        'state' => 1,
                    ]
                );

                // 更新Redis缓存
                $this->updateScheduleCache($coach->id, $sortedRanges);

                // 记录日志
                Log::info('技师排班设置成功', [
                    'coach_id' => $coach->id,
                    'time_ranges' => $sortedRanges,
                ]);

                return [
                    'status' => true,
                    'message' => '排班设置成功',
                    'data' => [
                        'coach_id' => $coach->id,
                        'time_ranges' => $sortedRanges,
                        'updated_at' => $schedule->updated_at->toDateTimeString(),
                    ],
                ];

            } catch (\Exception $e) {
                Log::error('技师排班设置失败', [
                    'user_id' => $userId,
                    'time_ranges' => $timeRanges,
                    'error' => $e->getMessage(),
                    'trace' => $e->getTraceAsString(),
                ]);
                throw $e;
            }
        });
    }

    /**
     * 验证并排序时间段
     */
    private function validateAndSortTimeRanges(array $timeRanges): array
    {
        // 验证时间段数组
        abort_if(empty($timeRanges), 400, '必须至少设置一个时间段');

        // 验证每个时间段格式并转换为分钟数进行比较
        $ranges = collect($timeRanges)->map(function ($range) {
            abort_if(! isset($range['start_time'], $range['end_time']),
                400, '时间段格式错误');

            // 验证时间格式
            foreach (['start_time', 'end_time'] as $field) {
                abort_if(! preg_match('/^([01][0-9]|2[0-3]):[0-5][0-9]$/', $range[$field]),
                    400, '时间格式错误，应为HH:mm格式');
            }

            // 转换为分钟数便于比较
            $startMinutes = $this->timeToMinutes($range['start_time']);
            $endMinutes = $this->timeToMinutes($range['end_time']);

            // 验证时间先后
            abort_if($startMinutes >= $endMinutes,
                400, "时间段 {$range['start_time']}-{$range['end_time']} 结束时间必须大于开始时间");

            return [
                'start_time' => $range['start_time'],
                'end_time' => $range['end_time'],
                'start_minutes' => $startMinutes,
                'end_minutes' => $endMinutes,
            ];
        })
            ->sortBy('start_minutes')
            ->values();

        // 验证时间段是否重叠
        $ranges->each(function ($range, $index) use ($ranges) {
            if ($index > 0) {
                $prevRange = $ranges[$index - 1];
                abort_if($range['start_minutes'] <= $prevRange['end_minutes'],
                    400, "时间段 {$prevRange['start_time']}-{$prevRange['end_time']} 和 ".
                         "{$range['start_time']}-{$range['end_time']} 之间存在重叠");
            }
        });

        // 返回排序后的时间段，只保留需要的字段
        return $ranges->map(function ($range) {
            return [
                'start_time' => $range['start_time'],
                'end_time' => $range['end_time'],
            ];
        })->toArray();
    }

    /**
     * 将时间转换为分钟数
     */
    private function timeToMinutes(string $time): int
    {
        [$hours, $minutes] = explode(':', $time);

        return (int) $hours * 60 + (int) $minutes;
    }

    /**
     * 更新Redis缓存
     */
    private function updateScheduleCache(int $coachId, array $timeRanges): void
    {
        try {
            $cacheKey = "coach:schedule:{$coachId}";
            $cacheData = [
                'updated_at' => now()->toDateTimeString(),
                'time_ranges' => $timeRanges,
            ];

            Redis::setex($cacheKey, 86400, json_encode($cacheData));

            // 清除相关的可预约时间段缓存
            $this->clearTimeSlotCache($coachId);

        } catch (\Exception $e) {
            Log::error('更新排班缓存失败', [
                'coach_id' => $coachId,
                'error' => $e->getMessage(),
            ]);
            // 缓存更新失败不影响主流程
        }
    }

    /**
     * 清除可预约时间段缓存
     */
    private function clearTimeSlotCache(int $coachId): void
    {
        try {
            $pattern = "coach:timeslots:{$coachId}:*";
            $keys = Redis::keys($pattern);
            if (! empty($keys)) {
                Redis::del($keys);
            }
        } catch (\Exception $e) {
            Log::error('清除时间段缓存失败', [
                'coach_id' => $coachId,
                'error' => $e->getMessage(),
            ]);
        }
    }
}