<?php

namespace App\Services;

use App\Amqp\Producer\CancelUnInquiryOrdersDelayDirectProducer;
use App\Amqp\Producer\CancelUnpayOrdersDelayDirectProducer;
use App\Amqp\Producer\DoctorNotYetInquiryDelayDirectProducer;
use App\Constants\HttpEnumCode;
use App\Exception\BusinessException;
use App\Model\DiseaseClass;
use App\Model\DoctorConfigFollowPackage;
use App\Model\DoctorConfigFollowPackageItem;
use App\Model\DoctorConfigHealthPackage;
use App\Model\DoctorInquiryConfig;
use App\Model\HealthPackage;
use App\Model\HealthPackageProduct;
use App\Model\InquiryCaseProduct;
use App\Model\Order;
use App\Model\OrderCoupon;
use App\Model\OrderInquiry;
use App\Model\OrderInquiryCase;
use App\Model\OrderInquiryCoupon;
use App\Model\OrderServicePackage;
use App\Model\OrderServicePackageCase;
use App\Model\OrderServicePackageDetail;
use App\Model\OrderServicePackageInquiry;
use App\Model\OrderServicePackageProduct;
use App\Model\PatientFamily;
use App\Model\PatientFamilyHealth;
use App\Model\PatientFamilyPersonal;
use App\Model\Product;
use App\Model\SystemInquiryConfig;
use App\Model\UserCoupon;
use App\Model\UserDoctor;
use App\Utils\Log;
use App\Utils\PcreMatch;
use Hyperf\Amqp\Producer;
use Hyperf\DbConnection\Db;
use Hyperf\Snowflake\IdGeneratorInterface;
use Psr\Container\ContainerExceptionInterface;
use Psr\Container\NotFoundExceptionInterface;

class OrderServicePackageService extends BaseService
{
    /**
     * 获取患者已购买的某医生的服务包详情
     * @return array
     */
    public function getPatientBuyServiceDetail(): array
    {
        $user_info = $this->request->getAttribute("userInfo") ?? [];

        $doctor_id = $this->request->input("doctor_id");
        $family_id = $this->request->input("family_id");
        $service_type = $this->request->input("service_type");// 服务包类型 1：健康 2：随访
        $follow_package_item_id = $this->request->input("follow_package_item_id");

        if ($service_type == 2) {
            if (empty($follow_package_item_id)) {
                return fail();
            }
        }

        $result = array();
        $result['status'] = 1;
        $result['message'] = "";
        $result['data'] = NULL;

        // 检测家庭成员是否存在
        $params = array();
        $params['family_id'] = $family_id;
        $params['patient_id'] = $user_info['client_user_id'];
        $params['status'] = 1;
        $patient_family = PatientFamily::getOne($params);
        if (empty($patient_family)) {
            return fail(HttpEnumCode::HTTP_ERROR, "患者信息错误");
        }

        if ($service_type == 1) {
            $inquiry_mode = 8;
        } else {
            $inquiry_mode = 9;
        }

        // 检测是否存在同类型未完成的问诊订单
        $PatientOrderService = new PatientOrderService();
        $order_inquiry_id = $PatientOrderService->getNotFinishedOrderInquiry(1, $inquiry_mode, $user_info['client_user_id']);
        if (!empty($order_inquiry_id)) {
            // 获取问诊订单数据
            $params = array();
            $params['order_inquiry_id'] = $order_inquiry_id;
            $order_inquiry = OrderInquiry::getOne($params);
            if (empty($order_inquiry)) {
                return fail(HttpEnumCode::SERVER_ERROR);
            }

            $result['status'] = 4;
            $result['message'] = "当前患者存在进行中的问诊订单";
            $result['data']['order_no'] = $order_inquiry['inquiry_no'];
            $result['data']['order_inquiry_id'] = $order_inquiry['order_inquiry_id'];
            return success($result);
        }

        // 检测当前医生是否和患者存在未完成问诊订单
        $InquiryService = new InquiryService();
        $order_inquiry = $InquiryService->checkPatientDoctorProgressInquiry($user_info['client_user_id'], $doctor_id);
        if (!empty($order_inquiry)) {
            $result['status'] = 4;
            $result['message'] = "您和当前医生存在问诊中订单，无法够买服务包";
            $result['data']['order_no'] = $order_inquiry['inquiry_no'];
            $result['data']['order_inquiry_id'] = $order_inquiry['order_inquiry_id'];
            return success($result);
        }

        // 检测患者是否购买服务包
        $params = array();
        $params['user_id'] = $user_info['user_id'];
        $params['patient_id'] = $user_info['client_user_id'];
        $params['doctor_id'] = $doctor_id;
        $params['family_id'] = $family_id;
        $params['order_service_type'] = $service_type;

        $order_service_status = ['1', '2', '3'];
        $order_service_package = OrderServicePackage::getStatusOne($params, $order_service_status);
        if (empty($order_service_package)) {
            $result['message'] = "未购买";
            return success($result);
        }

        // 检测服务包订单订单状态
        if ($order_service_package['order_service_status'] == 1) {
            $result['status'] = 2;
            $result['message'] = "存在未支付订单";
            $result['data']['order_no'] = $order_service_package['order_service_no'];
            return success($result);
        }

        if ($order_service_package['order_service_status'] == 2) {
            $result['status'] = 2;
            $result['message'] = "您已购买该服务包，请耐心等待医生接诊";
            $result['data']['order_no'] = $order_service_package['order_service_no'];
            return success($result);
        }

        // 获取服务包订单详情
        $params = array();
        $params['order_service_no'] = $order_service_package['order_service_no'];
        $order_service_package_detail = OrderServicePackageDetail::getOne($params);
        if (empty($order_service_package_detail)) {
            return fail(HttpEnumCode::SERVER_ERROR);
        }

        // 检测随访包
        if ($service_type == 2) {
            // 检测服务周期是否相同，相同表示购买的同一个随访包
            $params = array();
            $params['follow_package_item_id'] = $follow_package_item_id;
            $doctor_config_follow_package_item = DoctorConfigFollowPackageItem::getOne($params);
            if (empty($doctor_config_follow_package_item)) {
                return fail(HttpEnumCode::HTTP_ERROR, "随访包选择错误");
            }

            $params = array();
            $params['follow_package_id'] = $doctor_config_follow_package_item['follow_package_id'];
            $params['doctor_id'] = $doctor_id;
            $doctor_config_follow_package = DoctorConfigFollowPackage::getOne($params);
            if (empty($doctor_config_follow_package)) {
                return fail(HttpEnumCode::HTTP_ERROR, "随访包选择错误");
            }
        }

        // 处理当月问诊次数
        // 3.5号购买，每月2次问诊次数。今天5.3，属于第几个月，这个月的开始时间和结束时间
        if ($order_service_package_detail['monthly_frequency'] != 0) {
            // 获取服务包当月已问诊次数
            $month_inquiry_count = $this->getCurrentMonthInquiryCount($order_service_package['pay_time'],$service_type,$user_info['user_id'], $doctor_id);

            if ($month_inquiry_count >= $order_service_package_detail['monthly_frequency']) {
                // 超出当月问诊次数
                $result['status'] = 3;
                $result['message'] = "超出服务包所包含的当月问诊次数";
                $result['data']['order_no'] = $order_service_package['order_service_no'];
                return success($result);
            }
        }

        // 未超出当月问诊次数或次数无限制
        $result['status'] = 5;
        $result['message'] = "已购买，未超出当月问诊次数";
        $result['data']['order_no'] = $order_service_package['order_service_no'];
        return success($result);
    }

    /**
     * 创建服务包订单
     * @return array
     * @throws ContainerExceptionInterface
     * @throws NotFoundExceptionInterface
     */
    public function addPatientServiceOrder(): array
    {
        $result = array();
        $result['status'] = 1;
        $result['message'] = "成功";
        $result['data'] = [
            "order_no" => "",
        ];

        $user_info = $this->request->getAttribute("userInfo") ?? [];
        $request_params = $this->request->all();

        // 检测参数
        if ($request_params['service_type'] == 2) {
            if (empty($request_params['follow_package_item_id'])) {
                return fail(HttpEnumCode::CLIENT_HTTP_ERROR);
            }
        }

        // 检测家庭成员是否存在
        $params = array();
        $params['family_id'] = $request_params['family_id'];
        $params['patient_id'] = $user_info['client_user_id'];
        $params['status'] = 1;
        $patient_family = PatientFamily::getOne($params);
        if (empty($patient_family)) {
            return fail(HttpEnumCode::HTTP_ERROR, "患者信息错误");
        }

        // 检测是否存在同类型未完成的问诊订单
        $PatientOrderService = new PatientOrderService();
        $order_inquiry_id = $PatientOrderService->getNotFinishedOrderInquiry($request_params['inquiry_type'], $request_params['inquiry_mode'], $user_info['client_user_id']);
        if (!empty($order_inquiry_id)) {
            // 获取问诊订单数据
            $params = array();
            $params['order_inquiry_id'] = $order_inquiry_id;
            $order_inquiry = OrderInquiry::getOne($params);
            if (empty($order_inquiry)) {
                return fail(HttpEnumCode::SERVER_ERROR);
            }

            $result['status'] = 4;
            $result['message'] = "当前患者存在进行中的问诊订单";
            $result['data']['order_no'] = $order_inquiry['order_inquiry_id'];
            return success($result);
        }

        // 检测当前医生是否和患者存在未完成问诊订单
        $InquiryService = new InquiryService();
        $order_inquiry = $InquiryService->checkPatientDoctorProgressInquiry($user_info['client_user_id'], $request_params['doctor_id']);
        if (!empty($order_inquiry)) {
            $result['status'] = 4;
            $result['message'] = "您和当前医生存在问诊中订单，无法够买服务包";
            $result['data']['order_no'] = $order_inquiry['order_inquiry_id'];
            return success($result);
        }

        // 检测所患疾病是否正确
        $params = array();
        $params['disease_class_id'] = $request_params['disease_class_id'];
        $params['disease_class_status'] = 1;
        $disease_class = DiseaseClass::getOne($params);
        if (empty($disease_class)) {
            return fail(HttpEnumCode::HTTP_ERROR, "疾病信息填写错误");
        }

        // 获取当前问诊医生信息
        $params = array();
        $params['doctor_id'] = $request_params['doctor_id'];
        $doctor = UserDoctor::getOne($params);
        if (empty($doctor)) {
            return fail(HttpEnumCode::HTTP_ERROR, "未知医生");
        }

        if ($doctor['idcard_status'] != 1) {
            return fail(HttpEnumCode::HTTP_ERROR, "当前医生无法接诊，请重新选择");
        }

        if ($doctor['iden_auth_status'] != 1) {
            return fail(HttpEnumCode::HTTP_ERROR, "当前医生无法接诊，请重新选择");
        }

        // 确定支付渠道
        // 支付渠道（1:小程序支付 2:微信扫码支付）
        if ($request_params['client_type'] == 1) {
            $inquiry_pay_channel = 1;
        } elseif ($request_params['client_type'] == 2) {
            $inquiry_pay_channel = 2;
        } else {
            return fail(HttpEnumCode::HTTP_ERROR, "支付方式错误");
        }

        // 处理复诊凭证
        if (!empty($request_params['diagnose_images'])) {
            // 医师资格证
            $diagnose_images = implode(',', $request_params['diagnose_images']);
            $diagnose_images = PcreMatch::pregRemoveOssWebsite($diagnose_images);
        }

        // 沟通次数，沟通时长
        $params = array();
        $params['inquiry_type'] = $request_params['inquiry_type'];
        $params['inquiry_mode'] = $request_params['inquiry_mode'];
        $system_inquiry_config = SystemInquiryConfig::getOne($params);
        if (empty($system_inquiry_config)) {
            return fail(HttpEnumCode::SERVER_ERROR, "订单创建失败");
        }

        // 检测患者是否购买服务包
        $params = array();
        $params['user_id'] = $user_info['user_id'];
        $params['patient_id'] = $user_info['client_user_id'];
        $params['doctor_id'] = $request_params['doctor_id'];
        $params['family_id'] = $request_params['family_id'];
        $params['order_service_type'] = $request_params['service_type'];

        $order_service_status = ['1', '2', '3'];
        $order_service_package = OrderServicePackage::getStatusOne($params, $order_service_status);
        if (!empty($order_service_package)) {
            // 检测服务包订单订单状态
            if ($order_service_package['order_service_status'] == 1) {
                $result['status'] = 2;
                $result['message'] = "存在未支付订单";
                $result['data']['order_no'] = (string)$order_service_package['order_service_no'];
                return success($result);
            }

            if ($order_service_package['order_service_status'] == 2) {
                $result['status'] = 2;
                $result['message'] = "您已购买该服务包，请耐心等待医生接诊";
                $result['data']['order_no'] = (string)$order_service_package['order_service_no'];
                return success($result);
            }
        }

        // 获取医生图文问诊价格
        $params = array();
        $params['doctor_id'] = $request_params['doctor_id'];
        $params['inquiry_type'] = 1;
        $params['inquiry_mode'] = 1;
        $doctor_inquiry_config = DoctorInquiryConfig::getOne($params);
        if (empty($doctor_inquiry_config)){
            return fail(HttpEnumCode::HTTP_ERROR, "订单创建失败");
        }

        $service_price = 0; // 订单金额
        $service_period = null; // 服务周期（天）
        $service_count = null; // 总服务次数（0表示不限次）
        $monthly_frequency = null; // 每月次数（0表示不限次）
        $single_inquiry_price = null; // 单次图文问诊价格

        // 健康包
        if ($request_params['service_type'] == 1) {
            // 健康包
            $params = array();
            $params['doctor_id'] = $request_params['doctor_id'];
            $doctor_config_health_package = DoctorConfigHealthPackage::getOne($params);
            if (empty($doctor_config_health_package)) {
                return fail(HttpEnumCode::HTTP_ERROR, "订单创建失败");
            }

            $params = array();
            $params['package_id'] = $doctor_config_health_package['package_id'];
            $health_package = HealthPackage::getOne($params);
            if (empty($health_package)){
                throw new BusinessException("创建订单失败");
            }

            // 订单金额
            $service_price = $doctor_config_health_package['service_price'];

            // 服务周期（天）
            $service_period = 90;

            // 总服务次数（0表示不限次）
            $service_count = $health_package['service_count'];

            // 每月次数（0表示不限次）
            $monthly_frequency = $health_package['monthly_frequency'];

            // 单次图文问诊价格
            $single_inquiry_price = $doctor_inquiry_config['inquiry_price'];
        }

        // 随访包
        if ($request_params['service_type'] == 2) {
            $params = array();
            $params['follow_package_item_id'] = $request_params['follow_package_item_id'];
            $doctor_config_follow_package_item = DoctorConfigFollowPackageItem::getOne($params);
            if (empty($doctor_config_follow_package_item)) {
                return fail(HttpEnumCode::HTTP_ERROR, "随访包选择错误");
            }

            $params = array();
            $params['follow_package_id'] = $doctor_config_follow_package_item['follow_package_id'];
            $params['doctor_id'] = $request_params['doctor_id'];
            $doctor_config_follow_package = DoctorConfigFollowPackage::getOne($params);
            if (empty($doctor_config_follow_package)) {
                return fail(HttpEnumCode::HTTP_ERROR, "随访包选择错误");
            }

            // 订单金额
            $service_price = $doctor_config_follow_package_item['service_price'];

            // 服务周期（天）
            $service_period = $doctor_config_follow_package_item['service_period'];

            // 总服务次数（0表示不限次）
            if ($doctor_config_follow_package['monthly_frequency'] != 0){
                $service_count = $service_period / 30 * $doctor_config_follow_package['monthly_frequency'];
            }else{
                $service_count = $doctor_config_follow_package['service_count'];
            }

            // 每月次数（0表示不限次）
            $monthly_frequency = $doctor_config_follow_package['monthly_frequency'];

            // 单次图文问诊价格
            $single_inquiry_price = $doctor_inquiry_config['inquiry_price'];
        }

        // 判断数据
        if ($service_price <= 0) {
            return fail(HttpEnumCode::HTTP_ERROR, "订单创建失败");
        }

        if ($service_period === null || $single_inquiry_price === null){
            return fail(HttpEnumCode::HTTP_ERROR, "订单创建失败");
        }

        // 处理订单类型
        $order_type = "";
        if ($request_params['service_type'] == 1) {
            $order_type = 5;
        }

        if ($request_params['service_type'] == 2) {
            $order_type = 4;
        }

        if (empty($order_type)) {
            return fail(HttpEnumCode::HTTP_ERROR, "订单创建失败");
        }

        if (\Hyperf\Config\config("app_env") == "dev"){
            $service_price = 0.01;
        }

        Db::beginTransaction();

        $generator = $this->container->get(IdGeneratorInterface::class);

        try {
            $coupon_amount_total = 0;
            // 实际付款金额
            $payment_amount_total = bcsub($service_price, $coupon_amount_total, 2);
            if ($payment_amount_total < 0) {
                $payment_amount_total = 0;
            }

            // 生成订单表
            $data = array();
            $data['user_id'] = $user_info['user_id'];
            $data['patient_id'] = $user_info['client_user_id'];
            $data['doctor_id'] = $request_params['doctor_id'];
            $data['order_type'] = $order_type; // 订单类型（1:问诊订单 2:药品订单 3:检测订单 4:随访包订单 5:健康包订单）
            $data['inquiry_pay_channel'] = $inquiry_pay_channel;// 支付渠道（1:小程序支付 2:微信扫码支付）
            $data['pay_status'] = 1;// 1:待支付
            $data['order_no'] = "S" . $generator->generate();// 订单编号
            $data['amount_total'] = $service_price;// 订单金额
            $data['coupon_amount_total'] = $coupon_amount_total;// 优惠卷总金额
            $data['payment_amount_total'] = $payment_amount_total;// 实际付款金额
            $order = Order::addOrder($data);
            if (empty($order)) {
                Db::rollBack();
                return fail(HttpEnumCode::SERVER_ERROR, "订单创建失败");
            }

            // 生成服务包订单
            $data = array();
            $data['order_id'] = $order['order_id'];
            $data['user_id'] = $user_info['user_id'];
            $data['patient_id'] = $user_info['client_user_id'];
            $data['doctor_id'] = $request_params['doctor_id'];
            $data['family_id'] = $request_params['family_id'];
            $data['order_service_type'] = $request_params['service_type'];
            $data['order_service_status'] = 1; // 订单状态（1:待支付 2:未开始 3:服务中 4:服务完成 5:服务取消）
            $data['pay_channel'] = $inquiry_pay_channel;// 支付渠道（1:小程序支付 2:微信扫码支付）
            $data['order_service_no'] = $order['order_no'];// 系统订单编号
            $data['amount_total'] = $service_price;// 订单金额
            $data['coupon_amount_total'] = $coupon_amount_total;// 优惠卷总金额
            $data['payment_amount_total'] = $payment_amount_total;// 实际付款金额
            $data['patient_name'] = $patient_family['card_name'];// 患者姓名-就诊人
            $data['patient_name_mask'] = $patient_family['card_name_mask'];// 患者姓名-就诊人(掩码)
            $data['patient_sex'] = $patient_family['sex'];// 患者性别-就诊人（0:未知 1:男 2:女）
            $data['patient_age'] = getIdCardAge($patient_family['id_number']);// 患者年龄-就诊人
            $order_service_package = OrderServicePackage::addOrderServicePackage($data);
            if (empty($order_service_package)) {
                Db::rollBack();
                return fail(HttpEnumCode::SERVER_ERROR, "订单创建失败");
            }

            // 生成服务包订单详情
            $data = array();
            $data['order_service_id'] = $order_service_package['order_service_id'];
            $data['order_id'] = $order_service_package['order_id'];
            if ($order_service_package['order_service_type'] == 1){
                $data['package_id'] = 1;
            }
            $data['order_service_no'] = $order_service_package['order_service_no'];
            $data['service_period'] = $service_period; // 服务周期（天）
            $data['service_count'] = $service_count; // 总服务次数（0表示不限次）
            $data['monthly_frequency'] = $monthly_frequency; // 每月次数（0表示不限次）
            $data['single_inquiry_price'] = $single_inquiry_price; // 单次图文问诊价格
            $data['service_price'] = $service_price; // 总服务价格
            $order_service_package_detail = OrderServicePackageDetail::addOrderServicePackageDetail($data);
            if (empty($order_service_package_detail)){
                Db::rollBack();
                return fail(HttpEnumCode::SERVER_ERROR, "订单创建失败");
            }

            // 增加患者服务包病例
            $data = array();
            $data['user_id'] = $user_info['user_id'];
            $data['patient_id'] = $user_info['client_user_id'];
            $data['order_id'] = $order['order_id'];
            $data['order_service_id'] = $order_service_package['order_service_id'];// 订单-id
            $data['family_id'] = $patient_family['family_id']; // 家庭成员id
            $data['relation'] = $patient_family['relation']; // 与患者关系（1:本人 2:父母 3:爱人 4:子女 5:亲戚 6:其他 ）
            $data['name'] = $patient_family['card_name']; // 患者名称
            $data['sex'] = $patient_family['sex']; // 患者性别（0:未知 1:男 2:女）
            $data['disease_class_id'] = $disease_class['disease_class_id']; // 疾病分类id-系统
            $data['disease_class_name'] = $disease_class['disease_class_name']; // 疾病名称-系统
            $data['diagnosis_date'] = $request_params['diagnosis_date']; // 确诊日期
            $data['disease_desc'] = $request_params['disease_desc']; // 病情描述（主诉）
            $data['diagnose_images'] = $diagnose_images ?? ""; // 复诊凭证(多个使用逗号分隔)
            if ($patient_family['age'] != null) {
                $data['age'] = getIdCardAge($patient_family['id_number']);// 患者年龄
            }

            // 过敏史
            if (array_key_exists("is_allergy_history", $request_params)) {
                if ($request_params['is_allergy_history'] !== null) {
                    $data['is_allergy_history'] = $request_params['is_allergy_history']; // 是否存在过敏史（0:否 1:是）
                    if ($request_params['allergy_history'] != "") {
                        $data['allergy_history'] = $request_params['allergy_history']; // 过敏史描述
                    }
                }
            }

            // 家族病史
            if (array_key_exists("is_family_history", $request_params)) {
                if ($request_params['is_family_history'] !== null) {
                    $data['is_family_history'] = $request_params['is_family_history']; // 是否存在家族病史（0:否 1:是）
                    if ($request_params['family_history'] != "") {
                        $data['family_history'] = $request_params['family_history']; // 家族病史描述
                    }
                }
            }

            // 是否备孕、妊娠、哺乳期（0:否 1:是）
            if (array_key_exists("is_pregnant", $request_params)) {
                if ($request_params['is_pregnant'] !== null) {
                    $data['is_pregnant'] = $request_params['is_pregnant']; // 是否备孕、妊娠、哺乳期（0:否 1:是）
                }
            }

            $order_service_package_case = OrderServicePackageCase::addOrderServicePackageCase($data);
            if (empty($order_service_package_case)) {
                Db::rollBack();
                return fail(HttpEnumCode::SERVER_ERROR, "订单创建失败");
            }

            // 增加至未支付取消订单延迟队列
            $time = 60 * 30;
            if (\Hyperf\Config\config('app_env') == "dev") {
                $time = 60 * 5;
            }

            $data = array();
            $data['order_no'] = $order_service_package['order_service_no'];
            $data['order_type'] = 4;

            $message = new CancelUnpayOrdersDelayDirectProducer($data);
            $message->setDelayMs(1000 * $time);
            $producer = $this->container->get(Producer::class);
            $res = $producer->produce($message);
            if (!$res) {
                Db::rollBack();
                return fail(HttpEnumCode::SERVER_ERROR, "订单创建失败");
            }

            Db::commit();
        } catch (\Exception $e) {
            Db::rollBack();
            return fail(HttpEnumCode::SERVER_ERROR, $e->getMessage());
        }

        $result['data']['order_no'] = (string)$order['order_no'];

        return success($result);
    }

    /**
     * 创建服务包问诊订单
     * @return array
     * @throws ContainerExceptionInterface
     * @throws NotFoundExceptionInterface
     */
    public function addServiceInquiryOrder(): array
    {
        $user_info = $this->request->getAttribute("userInfo") ?? [];
        $order_no = $this->request->route("order_no");

        try {
            // 检测患者是否购买服务包
            $params = array();
            $params['user_id'] = $user_info['user_id'];
            $params['patient_id'] = $user_info['client_user_id'];
            $params['order_service_no'] = $order_no;
            $order_service_package = OrderServicePackage::getOne($params);
            if (empty($order_service_package)) {
                return fail(HttpEnumCode::HTTP_ERROR, "患者未购买该服务包");
            }

            // 检测服务包订单订单状态
            if ($order_service_package['order_service_status'] == 1) {
                return fail(HttpEnumCode::HTTP_ERROR,"服务包订单未支付，不可使用");
            }

            if ($order_service_package['order_service_status'] == 2) {
                return fail(HttpEnumCode::HTTP_ERROR,"服务包订单未生效，不可使用");
            }

            if ($order_service_package['order_service_status'] == 5) {
                return fail(HttpEnumCode::HTTP_ERROR,"服务包订单已取消，不可使用");
            }

            if ($order_service_package['order_service_status'] == 4) {
                return fail(HttpEnumCode::HTTP_ERROR,"服务包订单已完成，不可使用");
            }

            // 获取服务包订单详情
            $params = array();
            $params['order_service_no'] = $order_service_package['order_service_no'];
            $order_service_package_detail = OrderServicePackageDetail::getOne($params);
            if (empty($order_service_package_detail)) {
                return fail(HttpEnumCode::SERVER_ERROR);
            }

            // 处理问诊类型
            if ($order_service_package['order_service_type'] == 1) {
                $inquiry_mode = 8;
            } else {
                $inquiry_mode = 9;
            }

            // 检测是否存在同类型未完成的问诊订单
            $PatientOrderService = new PatientOrderService();
            $order_inquiry_id = $PatientOrderService->getNotFinishedOrderInquiry(1, $inquiry_mode, $user_info['client_user_id']);
            if (!empty($order_inquiry_id)) {
                return fail(HttpEnumCode::HTTP_ERROR, "存在进行中的问诊订单,无法再次创建");
            }

            // 检测当前医生是否和患者存在未完成问诊订单
            $InquiryService = new InquiryService();
            $order_inquiry = $InquiryService->checkPatientDoctorProgressInquiry($user_info['client_user_id'], $order_service_package['doctor_id']);
            if (!empty($order_inquiry)) {
                return fail(HttpEnumCode::HTTP_ERROR, "存在问诊中订单,无法再次创建");
            }

            // 检测问诊次数
            // 3.5号购买，每月2次问诊次数。今天5.3，属于第几个月，这个月的开始时间和结束时间
            if ($order_service_package_detail['monthly_frequency'] != 0) {
                // 获取服务包当月已问诊次数
                $month_inquiry_count = $this->getCurrentMonthInquiryCount($order_service_package['pay_time'],$order_service_package['order_service_type'],$user_info['user_id'], $order_service_package['doctor_id']);

                if ($month_inquiry_count >= $order_service_package_detail['monthly_frequency']) {
                    return fail(HttpEnumCode::HTTP_ERROR, "超出服务包所包含的当月问诊次数");
                }
            }

            // 获取患者家庭成员信息表
            $params = array();
            $params['family_id'] = $order_service_package['family_id'];
            $params['patient_id'] = $order_service_package['patient_id'];
            $patient_family = PatientFamily::getOne($params);
            if (empty($patient_family)) {
                return fail(HttpEnumCode::HTTP_ERROR, "家庭成员数据错误");
            }

            // 获取患者家庭成员信息表-健康情况
            $params = array();
            $params['family_id'] = $order_service_package['family_id'];
            $patient_family_health = PatientFamilyHealth::getOne($params);

            // 获取患者家庭成员信息表-个人情况
            $params = array();
            $params['family_id'] = $order_service_package['family_id'];
            $patient_family_personal = PatientFamilyPersonal::getOne($params);

            // 检测医生状态
            $params = array();
            $params['doctor_id'] = $order_service_package['doctor_id'];
            $doctor = UserDoctor::getOne($params);
            if (empty($doctor)) {
                return fail(HttpEnumCode::HTTP_ERROR, "未知医生");
            }

            if ($doctor['idcard_status'] != 1) {
                return fail(HttpEnumCode::HTTP_ERROR, "当前医生无法接诊，请重新选择");
            }

            if ($doctor['iden_auth_status'] != 1) {
                return fail(HttpEnumCode::HTTP_ERROR, "当前医生无法接诊，请重新选择");
            }

            // 获取检测病例数据
            $params = array();
            $params['order_service_id'] = $order_service_package['order_service_id'];
            $order_service_package_case = OrderServicePackageCase::getOne($params);
            if (empty($order_service_package_case)) {
                return fail(HttpEnumCode::HTTP_ERROR, "问诊病例数据错误");
            }
            $order_service_package_case = $order_service_package_case->toArray();

            // 沟通次数，沟通时长
            $params = array();
            $params['inquiry_type'] = 1;
            $params['inquiry_mode'] = $inquiry_mode;
            $system_inquiry_config = SystemInquiryConfig::getOne($params);
            if (empty($system_inquiry_config)) {
                return fail(HttpEnumCode::SERVER_ERROR, "订单创建失败");
            }
        }catch (\Throwable $e){
            return fail(HttpEnumCode::HTTP_ERROR, $e->getMessage());
        }

        // 处理数据库业务
        Db::beginTransaction();
        try {
            $generator = $this->container->get(IdGeneratorInterface::class);

            // 新增订单表
            $data = array();
            $data['user_id'] = $order_service_package['user_id'];
            $data['patient_id'] = $order_service_package['patient_id'];
            $data['doctor_id'] = $order_service_package['doctor_id'];
            $data['order_type'] = 1; // 订单类型（1:问诊订单 2:药品订单 3:检测订单 4:随访包订单 5:健康包订单）
            $data['inquiry_pay_channel'] = 3; // 支付渠道（1:小程序支付 2:微信扫码支付）
            $data['pay_status'] = 2; // 1:待支付
            $data['order_no'] = "I" . $generator->generate(); // 订单编号
            $data['escrow_trade_no'] = "GD" . $generator->generate(); // 第三方支付流水号
            $data['amount_total'] = 0; // 订单金额
            $data['coupon_amount_total'] = 0; // 优惠卷总金额
            $data['payment_amount_total'] = 0; // 实际付款金额
            $order = Order::addOrder($data);
            if (empty($order)) {
                Db::rollBack();
                return fail(HttpEnumCode::HTTP_ERROR, "订单创建失败");
            }

            // 新增问诊订单
            $data = array();
            $data['order_id'] = $order['order_id'];
            $data['user_id'] = $order_service_package['user_id'];
            $data['patient_id'] = $order_service_package['patient_id'];
            $data['doctor_id'] = $order_service_package['doctor_id'];
            $data['family_id'] = $order_service_package['family_id'];
            $data['inquiry_type'] = 1; // 订单类型（1:专家问诊 2:快速问诊 3:公益问诊 4:问诊购药 5:检测）
            $data['inquiry_mode'] = $inquiry_mode; // 接诊方式（1:图文 2:视频 3:语音 4:电话 5:会员 6:疑难会诊 7:附赠 8:健康包 9:随访包）
            $data['inquiry_status'] = 3; // 问诊订单状态（1:待支付 2:待分配 3:待接诊 4:已接诊 5:已完成 6:已结束 7:已取消）
            $data['inquiry_pay_channel'] = 3; // 支付渠道（1:小程序支付 2:微信扫码支付 3:模拟支付）
            $data['inquiry_pay_status'] = 2; // 支付状态（1:未支付 2:已支付 3:支付中 4:支付失败 5:支付超时 6:支付关闭 7:已撤销 8:转入退款）
            $data['inquiry_no'] = $order['order_no'];// 订单编号
            $data['escrow_trade_no'] = $order['escrow_trade_no']; // 第三方支付流水号
            $data['amount_total'] = 0;// 订单金额
            $data['coupon_amount_total'] = 0;// 优惠卷总金额
            $data['payment_amount_total'] = 0;// 实际付款金额
            $data['times_number'] = $system_inquiry_config['times_number'];// 沟通次数（0为不限制次数）
            $data['duration'] = $system_inquiry_config['duration'];// 沟通时长（分钟，0为不限制时长）
            $data['pay_time'] = date('Y-m-d H:i:s', time());// 支付时间
            $data['patient_name'] = $patient_family['card_name'];// 患者姓名-就诊人
            $data['patient_name_mask'] = $patient_family['card_name_mask'];// 患者姓名-就诊人(掩码)
            $data['patient_sex'] = $patient_family['sex'];// 患者性别-就诊人（0:未知 1:男 2:女）
            $data['patient_age'] = $patient_family['age'];// 患者年龄-就诊人
            $order_inquiry = OrderInquiry::addOrderInquiry($data);
            if (empty($order_inquiry)) {
                Db::rollBack();
                return fail(HttpEnumCode::HTTP_ERROR, "订单创建失败");
            }

            // 新增问诊订单病例
            $data = array();
            $data['user_id'] = $order_service_package['user_id'];
            $data['patient_id'] = $order_service_package['patient_id'];
            $data['order_inquiry_id'] = $order_inquiry['order_inquiry_id'];// 订单-问诊id
            $data['family_id'] = $patient_family['family_id']; // 家庭成员id
            $data['relation'] = $patient_family['relation']; // 与患者关系（1:本人 2:父母 3:爱人 4:子女 5:亲戚 6:其他 ）
            $data['name'] = $patient_family['card_name']; // 患者名称
            $data['sex'] = $patient_family['sex']; // 患者性别（0:未知 1:男 2:女）
            $data['disease_class_id'] = $order_service_package_case['disease_class_id']; // 疾病分类id-系统
            $data['disease_class_name'] = $order_service_package_case['disease_class_name']; // 疾病名称-系统
            $data['diagnosis_date'] = $order_service_package_case['diagnosis_date']; // 确诊日期
            $data['disease_desc'] = $order_service_package_case['disease_desc']; // 病情描述（主诉）
            $data['diagnose_images'] = $order_service_package_case['diagnose_images'] ?? ""; // 复诊凭证(多个使用逗号分隔)

            if ($patient_family['age'] != null) {
                $data['age'] = getIdCardAge($patient_family['id_number']);// 患者年龄
            }

            // 身高（cm）
            if ($patient_family['height'] != null) {
                $data['height'] = $patient_family['height'];
            }

            // 体重（kg）
            if ($patient_family['weight'] != null) {
                $data['weight'] = $patient_family['weight'];
            }

            // 职业id-职业名称
            if ($patient_family['job_id'] != null) {
                $data['job_id'] = $patient_family['job_id'];
                if ($patient_family['job_name'] != null) {
                    $data['job_name'] = $patient_family['job_name'];
                }
            }

            // 民族id-民族名称
            if ($patient_family['nation_id'] != null) {
                $data['nation_id'] = $patient_family['nation_id'];
                if ($patient_family['nation_name'] != null) {
                    $data['nation_name'] = $patient_family['nation_name'];
                }
            }

            // 婚姻状况
            if ($patient_family['marital_status'] != null) {
                $data['marital_status'] = $patient_family['marital_status'];
            }

            // 家庭成员-健康情况
            if (!empty($patient_family_health)) {
                if ($patient_family_health['diagnosis_hospital'] != null) {
                    $data['diagnosis_hospital'] = $patient_family_health['diagnosis_hospital']; // 确诊医院
                }

                if ($patient_family_health['is_take_medicine'] != null) {
                    $data['is_take_medicine'] = $patient_family_health['is_take_medicine']; // 正在服药
                    if ($patient_family_health['drugs_name'] != null) {
                        $data['drugs_name'] = $patient_family_health['drugs_name']; // 正在服药名称
                    }
                }
            }

            // 家庭成员-个人情况
            if (!empty($patient_family_personal)) {
                if ($patient_family_personal['drink_wine_status'] != null) {
                    $data['drink_wine_status'] = $patient_family_personal['drink_wine_status']; // 饮酒状态
                }

                if ($patient_family_personal['smoke_status'] != null) {
                    $data['smoke_status'] = $patient_family_personal['smoke_status']; // 吸烟状态
                }

                if ($patient_family_personal['chemical_compound_status'] != null) {
                    $data['chemical_compound_status'] = $patient_family_personal['chemical_compound_status']; // 化合物状态
                    if ($patient_family_personal['chemical_compound_describe'] != null) {
                        $data['chemical_compound_describe'] = $patient_family_personal['chemical_compound_describe']; // 化合物描述
                    }
                }

                if ($patient_family_personal['is_operation'] != null) {
                    $data['is_operation'] = $patient_family_personal['is_operation']; // 是否存在手术
                    if ($patient_family_personal['operation'] != null) {
                        $data['operation'] = $patient_family_personal['operation']; // 手术描述
                    }
                }
            }

            // 过敏史
            if (array_key_exists("is_allergy_history", $order_service_package_case)) {
                if ($order_service_package_case['is_allergy_history'] !== null) {
                    $data['is_allergy_history'] = $order_service_package_case['is_allergy_history']; // 是否存在过敏史（0:否 1:是）
                    if ($order_service_package_case['allergy_history'] != "") {
                        $data['allergy_history'] = $order_service_package_case['allergy_history']; // 过敏史描述
                    }
                }
            }

            // 家族病史
            if (array_key_exists("is_family_history", $order_service_package_case)) {
                if ($order_service_package_case['is_family_history'] !== null) {
                    $data['is_family_history'] = $order_service_package_case['is_family_history']; // 是否存在家族病史（0:否 1:是）
                    if ($order_service_package_case['family_history'] != "") {
                        $data['family_history'] = $order_service_package_case['family_history']; // 家族病史描述
                    }
                }
            }

            // 是否备孕、妊娠、哺乳期（0:否 1:是）
            if (array_key_exists("is_pregnant", $order_service_package_case)) {
                if ($order_service_package_case['is_pregnant'] !== null) {
                    $data['is_pregnant'] = $order_service_package_case['is_pregnant']; // 是否备孕、妊娠、哺乳期（0:否 1:是）
                }
            }

            $order_inquiry_case = OrderInquiryCase::addOrderInquiryCase($data);
            if (empty($order_inquiry_case)) {
                Db::rollBack();
                return fail(HttpEnumCode::HTTP_ERROR, "订单创建失败");
            }

            // 新增服务包关联订单
            $data = array();
            $data['order_service_id'] = $order_service_package['order_service_id'];
            $data['order_inquiry_id'] = $order_inquiry['order_inquiry_id'];
            $data['order_service_no'] = $order_service_package['order_service_no'];
            $data['inquiry_no'] = $order_inquiry['inquiry_no'];
            $data['inquiry_status'] = $order_inquiry['inquiry_status'];
            $order_service_package_inquiry = OrderServicePackageInquiry::addOrderServicePackageInquiry($data);
            if (empty($order_service_package_inquiry)){
                Db::rollBack();
                return fail(HttpEnumCode::HTTP_ERROR, "订单创建失败");
            }

            // 加入未接诊取消订单延迟队列
            $time = 60 * 60 * 72;
            if (\Hyperf\Config\config('app_env') == "dev"){
                $time = 60 * 10;
            }

            $data = array();
            $data['order_inquiry_id'] = $order_inquiry['order_inquiry_id'];
            $data['order_no'] = $order_inquiry['inquiry_no'];
            $message = new CancelUnInquiryOrdersDelayDirectProducer($data);
            $message->setDelayMs(1000 * $time);
            $producer = $this->container->get(Producer::class);
            $res = $producer->produce($message);
            if (!$res) {
                Db::rollBack();
                return fail(HttpEnumCode::HTTP_ERROR, "订单创建失败");
            }

            Db::commit();
        }catch (\Throwable $e){
            Db::rollBack();
            return fail(HttpEnumCode::HTTP_ERROR, $e->getMessage());
        }

        // 处理消息业务
        try {
            // 获取订单医生数据
            $params = array();
            $params['doctor_id'] = $order_inquiry['doctor_id'];
            $user_doctor = UserDoctor::getOne($params);
            if (empty($user_doctor)) {
                return fail(HttpEnumCode::HTTP_ERROR, "医生数据错误");
            }

            // 发送im消息
            $imService = new ImService();

            // 等待医生接诊
            $imService->waitDoctorInquiry($order_inquiry, $user_doctor['user_id'], $order_inquiry['user_id']);

            // 检测问诊是否服务包首次问诊
            $OrderServicePackageService = new OrderServicePackageService();
            $is_first = $OrderServicePackageService->isFirstInquiryServicePackage($order_no);
            if ($is_first){
                // 首次
                // 发送站内、订阅失败发送短信消息-医生有新服务包订单
                $MessagePush = new MessagePush($user_doctor['user_id'], $order_inquiry['inquiry_no']);
                $MessagePush->doctorHaveNewServicePackage();
            }else{
                // 发送站内、订阅失败-医生有新的服务包问诊订单
                $MessagePush = new MessagePush($user_doctor['user_id'], $order_inquiry['inquiry_no']);
                $MessagePush->doctorHaveNewServicePackageInquiry();
            }

            // 加入xx时间未接诊通知队列
            $data = array();
            $data['order_inquiry_id'] = $order_inquiry['order_inquiry_id'];

            $time = 1000 * 60 * 60 * 24;
            $message = new DoctorNotYetInquiryDelayDirectProducer($data);
            $message->setDelayMs($time);
            $producer = $this->container->get(Producer::class);
            $producer->produce($message);
        } catch (\Exception $e) {
            // 验证失败
            return fail(HttpEnumCode::HTTP_ERROR, $e->getMessage());
        }

        $result = array();
        $result['order_inquiry_id'] = (string)$order_inquiry['order_inquiry_id'];
        $result['order_no'] = (string)$order['order_no'];
        return success($result);
    }

    /**
     * 检测是否可创建服务包问诊订单
     * @return array
     */
    public function getServicePackageInquiryCheck(): array
    {
        $user_info = $this->request->getAttribute("userInfo") ?? [];

        $order_no = $this->request->route("order_no");

        $result = array();
        $result['status'] = 1;
        $result['message'] = "";
        $result['data'] = NULL;

        try {
            // 检测患者是否购买服务包
            $params = array();
            $params['order_service_no'] = $order_no;
            $order_service_package = OrderServicePackage::getOne($params);
            if (empty($order_service_package)) {
                return fail(HttpEnumCode::HTTP_ERROR, "患者未购买服务包");
            }

            // 检测服务包订单订单状态
            if ($order_service_package['order_service_status'] == 1) {
                return fail(HttpEnumCode::HTTP_ERROR, "服务包未支付");
            }

            if ($order_service_package['order_service_status'] == 2) {
                $result['status'] = 2;
                $result['message'] = "已发起问诊，请耐心等待接诊";
                $result['data']['order_no'] = $order_service_package['order_service_no'];
                return success($result);
            }

            if ($order_service_package['order_service_status'] == 4) {
                $result['status'] = 2;
                $result['message'] = "服务已完成，请重新购买服务包";
                $result['data']['order_no'] = $order_service_package['order_service_no'];
                return success($result);
            }

            if ($order_service_package['order_service_status'] == 5) {
                $result['status'] = 2;
                $result['message'] = "服务已取消，请重新购买服务包";
                $result['data']['order_no'] = $order_service_package['order_service_no'];
                return success($result);
            }

            // 获取服务包订单详情
            $params = array();
            $params['order_service_no'] = $order_service_package['order_service_no'];
            $order_service_package_detail = OrderServicePackageDetail::getOne($params);
            if (empty($order_service_package_detail)) {
                return fail(HttpEnumCode::SERVER_ERROR);
            }

            // 处理问诊类型
            if ($order_service_package['order_service_type'] == 1) {
                $inquiry_mode = 8;
            } else {
                $inquiry_mode = 9;
            }

            // 检测是否存在同类型未完成的问诊订单
            $PatientOrderService = new PatientOrderService();
            $order_inquiry_id = $PatientOrderService->getNotFinishedOrderInquiry(1, $inquiry_mode, $user_info['client_user_id']);
            if (!empty($order_inquiry_id)) {
                // 获取问诊订单数据
                $params = array();
                $params['order_inquiry_id'] = $order_inquiry_id;
                $order_inquiry = OrderInquiry::getOne($params);
                if (empty($order_inquiry)) {
                    return fail(HttpEnumCode::SERVER_ERROR);
                }

                $result['status'] = 4;
                $result['message'] = "存在进行中的问诊订单，无法再次使用";
                $result['data']['order_no'] = $order_inquiry['inquiry_no'];
                $result['data']['order_inquiry_id'] = $order_inquiry['order_inquiry_id'];
                return success($result);
            }

            // 检测当前医生是否和患者存在未完成问诊订单
            $InquiryService = new InquiryService();
            $order_inquiry = $InquiryService->checkPatientDoctorProgressInquiry($user_info['client_user_id'], $order_service_package['doctor_id']);
            if (!empty($order_inquiry)) {
                $result['status'] = 4;
                $result['message'] = "您和当前医生存在问诊中订单，无法再次使用";
                $result['data']['order_no'] = $order_inquiry['inquiry_no'];
                $result['data']['order_inquiry_id'] = $order_inquiry['order_inquiry_id'];
                return success($result);
            }

            // 检测问诊次数
            // 3.5号购买，每月2次问诊次数。今天5.3，属于第几个月，这个月的开始时间和结束时间
            if ($order_service_package_detail['monthly_frequency'] != 0) {
                // 获取服务包当月已问诊次数
                $month_inquiry_count = $this->getCurrentMonthInquiryCount($order_service_package['pay_time'],$order_service_package['order_service_type'],$user_info['user_id'], $order_service_package['doctor_id']);

                if ($month_inquiry_count >= $order_service_package_detail['monthly_frequency']) {
                    // 超出当月问诊次数
                    $result['status'] = 3;
                    $result['message'] = "超出服务包所包含的当月问诊次数";
                    $result['data']['order_no'] = $order_service_package['order_service_no'];
                    return success($result);
                }
            }
        }catch (\Throwable $e){
            return fail(HttpEnumCode::SERVER_ERROR,$e->getMessage());
        }

        // 未超出当月问诊次数或次数无限制
        $result['message'] = "已购买，未超出当月问诊次数";
        $result['data']['order_no'] = $order_service_package['order_service_no'];
        return success($result);
    }

    /**
     * 取消未支付检测订单
     * @param string|int $order_no
     * @param string|int $cancel_reason 取消订单原因（1:主动取消 2:客服取消 3:支付超时）
     * @param string|int $cancel_remarks 取消备注
     * @return array
     */
    public function cancelUnpayServiceOrder(string|int $order_no, string|int $cancel_reason, string|int $cancel_remarks): array
    {
        $result = array();
        $result['status'] = 1;
        $result['message'] = "成功";

        // 获取检测订单数据
        $params = array();
        $params['order_service_no'] = $order_no;
        $order_service_package = OrderServicePackage::getOne($params);
        if (empty($order_service_package)) {
            $result['status'] = 0;
            $result['message'] = "未查询到对应订单数据";
            return $result;
        }

        // 检测订单状态
        if ($order_service_package['order_service_status'] == 5) {
            // 订单状态（1:待支付 2:未开始 3:服务中 4:服务完成 5:服务取消）
            $result['status'] = 0;
            $result['message'] = "订单已取消";
            return $result;
        }

        if ($order_service_package['order_service_status'] != 1) {
            // 订单状态（1:待支付 2:未开始 3:服务中 4:服务完成 5:服务取消）
            $result['status'] = 0;
            $result['message'] = "订单取消失败";
            return $result;
        }

        // 检测订单退款状态
        if (!in_array($order_service_package['refund_status'], [0, 4, 5])) {
            // 检测订单退款状态（0:无退款 1:申请退款 2:退款中 3:退款成功 4:拒绝退款 5:退款关闭 6:退款异常）
            $result['status'] = 0;
            $result['message'] = "订单正在退款中";
            return $result;
        }

        // 检测订单支付状态
        if ($order_service_package['pay_status'] == 2) {
            // 支付状态（1:未支付 2:已支付 3:支付中 4:支付失败 5:支付超时 6:支付关闭 7:已撤销 8:转入退款）
            $result['status'] = 0;
            $result['message'] = "订单已支付";
            return $result;
        }

        // 检测订单删除状态
        if ($order_service_package['is_delete'] == 1) {
            // 删除状态（0:否 1:是）
            $result['status'] = 2;
            $result['message'] = "订单已被删除";
            return $result;
        }

        // 取消检测订单
        $data = array();
        $data['order_service_status'] = 5; // 检测订单状态(1:待支付 2:待绑定 3:检测中 4:检测完成 5:已取消)
        if ($cancel_reason == 3) {
            $data['pay_status'] = 5; // 支付状态（1:未支付 2:已支付 3:支付中 4:支付失败 5:支付超时 6:支付关闭 7:已撤销 8:转入退款）
        }

        $data['cancel_time'] = date("Y-m-d H:i:s", time());
        $data['cancel_remarks'] = $cancel_remarks; // 取消订单备注
        $data['updated_at'] = date("Y-m-d H:i:s", time());

        $params = array();
        $params['order_service_id'] = $order_service_package['order_service_id'];
        OrderServicePackage::edit($params, $data);

        return $result;
    }

    /**
     * 获取服务包当月已问诊次数
     * @param string $start_time
     * @param string|int $service_type
     * @param string|int $user_id
     * @param string|int $doctor_id
     * @return int
     */
    public function getCurrentMonthInquiryCount(string $start_time,string|int $service_type,string|int $user_id,string|int $doctor_id): int
    {
            $month_inquiry_count = 0; // 当前所属月问诊次数

            // 获取当月问诊次数
            // 获取开启服务日期和今日的相差天数
            $diff = abs(time() - strtotime($start_time));
            $diff_days = ceil($diff / (60 * 60 * 24)); // 转换为天数

            // 获取当前月次
            $month_time = ceil($diff_days / 30);

            $days = (int)$month_time * 30;

            // 获取开始日期
            $end_date = date('Y-m-d H:i:s', strtotime($start_time . " +$days  days"));
            $start_date = date('Y-m-d H:i:s', strtotime($end_date . "-30 days"));

            $InquiryService = new InquiryService();
            $order_inquiry = $InquiryService->getPatientServiceInquiry($service_type, $user_id, $doctor_id, $start_date, $end_date);
            if (!empty($order_inquiry)) {
                $month_inquiry_count = count($order_inquiry);
            }

            return $month_inquiry_count;
    }

    /**
     * 获取服务包当前月时间区间
     * @param string $start_time
     * @return array
     */
    public function getCurrentMonthDate(string $start_time): array
    {
        // 获取开启服务日期和今日的相差天数
        $diff = abs(time() - strtotime($start_time));
        $diff_days = ceil($diff / (60 * 60 * 24)); // 转换为天数

        // 获取当前月次
        $month_time = ceil($diff_days / 30);

        $days = (int)$month_time * 30;

        // 当前所属月结束时间
        $current_month_finish_date = date('Y-m-d H:i:s', strtotime($start_time . " +$days  days"));

        // 当前所属月开始时间
        $current_month_start_date = date('Y-m-d H:i:s', strtotime($current_month_finish_date . "-30 days"));

        $result = array();
        $result['current_month_start_date'] = date('Y年m月d日 H时i分', strtotime($current_month_start_date));
        $result['current_month_finish_date'] = date('Y年m月d日 H时i分', strtotime($current_month_finish_date));

        return $result;
    }

    /**
     * 获取服务包内所有药品
     * @param string|int $package_id
     * @return array
     */
    public function getOrderServiceProduct(string|int $package_id): array
    {
        $params = array();
        $params['package_id'] = $package_id;
        $health_package_products = HealthPackageProduct::getList($params);
        if (empty($health_package_products)){
            return [];
        }

        return $health_package_products->toArray();
    }

    /**
     * 获取服务包内某一药品的总数量
     * @param string|int $package_id
     * @param string|int $product_id
     * @return int
     */
    public function getOrderServiceProductTotalQuantity(string|int $package_id,string|int $product_id): int
    {
        $total_quantity = 0;

        $params = array();
        $params['package_id'] = $package_id;
        $params['product_id'] = $product_id;
        $health_package_product = HealthPackageProduct::getOne($params);
        if (empty($health_package_product)){
            return $total_quantity;
        }

        return $health_package_product['quantity'];
    }

    /**
     * 获取服务包内某一药品的可使用数量
     * @param string|int $order_service_id
     * @param string|int $product_id
     * @param string|int $total_quantity
     * @return int
     */
    public function getOrderServiceProductCanUseQuantity(string|int $order_service_id,string|int $product_id,string|int $total_quantity): int
    {
        $remaining_quantity = 0;

        $params = array();
        $params['order_service_id'] = $order_service_id;
        $params['product_id'] = $product_id;
        $order_service_package_products = OrderServicePackageProduct::getList($params);
        if (empty($order_service_package_products)){
            return $remaining_quantity;
        }

        // 订单使用数量
        $used_quantity = 0;
        foreach ($order_service_package_products as $order_service_package_product){
            $used_quantity = $used_quantity + $order_service_package_product['used_quantity'];
        }

        // 剩余数量 = 总数量-使用数量
        $remaining_quantity = $total_quantity - $used_quantity;

        if ($remaining_quantity < 0){
            $remaining_quantity = 0;
        }

        return $remaining_quantity;
    }

    /**
     * 检测问诊是否服务包首次问诊
     * @param string|int $order_no
     * @return bool
     */
    public function isFirstInquiryServicePackage(string|int $order_no): bool
    {
        $params = array();
        $params['order_service_no'] = $order_no;
        $order_service_package_inquiry = OrderServicePackageInquiry::getList($params);
        if (empty($order_service_package_inquiry)){
            return true;
        }

        if (count($order_service_package_inquiry) == 1){
            return true;
        }

        return false;
    }

    /**
     * 获取服务包订单编号-通过问诊订单id
     * @param string|int $inquiry_no
     * @return string|int
     */
    public function getOrderServiceNoByOrderInquiryId(string|int $inquiry_no): string|int
    {
        $params = array();
        $params['inquiry_no'] = $inquiry_no;
        $order_service_package_inquiry = OrderServicePackageInquiry::getOne($params);
        if (empty($order_service_package_inquiry)){
            throw new BusinessException("订单错误");
        }

        return $order_service_package_inquiry['order_service_no'];
    }

    /**
     * 检测患者服务包内是否还存在剩余药品
     * @param string|int $order_no
     * @return bool
     */
    public function checkOrderServiceRemainingProduct(string|int $order_no): bool
    {
        // 获取健康包内容
        $params = array();
        $health_package = HealthPackage::getOne($params);
        if (empty($health_package)){
            return false;
        }

        // 获取服务包关联商品
        $params = array();
        $params['order_service_no'] = $order_no;
        $order_service_package = OrderServicePackage::getOne($params);
        if (empty($order_service_package)){
            return false;
        }

        $params = array();
        $params['package_id'] = $health_package['package_id'];
        $health_package_products = HealthPackage::getList($params);
        if (empty($health_package_products)){
            return false;
        }

        foreach ($health_package_products as $health_package_product){
            $params = array();
            $params['order_service_id'] = $order_service_package['order_service_id'];
            $params['product_id'] = $health_package_product['product_id'];
            $order_service_package_products = OrderServicePackageProduct::getList($params);

            $used_quantity = 0;
            foreach ($order_service_package_products as $order_service_package_product){
                $used_quantity = $used_quantity + $order_service_package_product['used_quantity'];
            }

            $remaining_quantity = $health_package_product['quantity'] - $used_quantity;

            // 存在一个可使用商品数量即返回
            if ($remaining_quantity > 0){
                return true;
            }
        }

        return false;
    }

    /**
     * 获取医生当日的服务包订单问诊金额-开始时间
     * @param string $doctor_id
     * @param string $date
     * @return int|string
     */
    public function getDoctorDayAmountTotal(string $doctor_id, string $date): int|string
    {
        $amount_total = 0;

        // 获取当天开始时间
        $start_date = date('Y-m-d 00:00:00', strtotime($date));

        // 获取当天结束时间
        $end_date = date('Y-m-d 23:59:59', strtotime($date));

        // 获取医生当日服务包订单
        $params = array();
        $params['doctor_id'] = $doctor_id;

        $order_service_status_params = [3];

        $start_time_params = [$start_date,$end_date];
        $order_service_packages = OrderServicePackage::getDoctorDayOrderServiceWithStartTime($params,$order_service_status_params,$start_time_params);
        foreach ($order_service_packages as $order_service_package){
            // 获取订单详情数据
            $params = array();
            $params['order_service_no'] = $order_service_package['order_service_no'];
            $order_service_package_detail = OrderServicePackageDetail::getOne($params);
            if (!empty($order_service_package_detail)){
                // 计算本次问诊服务包问诊金额
                $amount_total = bcmul(
                    (string)$order_service_package_detail['service_count'],
                    (string)$order_service_package_detail['single_inquiry_price'],
                    3
                );
            }
        }

        return $amount_total;
    }

    /**
     * 获取医生当日未完成的服务包订单问诊金额-结束时间
     * @param string $doctor_id
     * @param string $date
     * @return int|string
     */
    public function getDoctorDayNoFinishAmountTotal(string $doctor_id, string $date): int|string
    {
        $amount_total = 0;

        // 获取医生当日服务包订单
        $params = array();
        $params['doctor_id'] = $doctor_id;

        $order_service_status_params = [3];

        $start_time_params = date('Y-m-d H:i:s', strtotime($date));
        $order_service_packages = OrderServicePackage::getDoctorDayNoFinishOrderService($params,$order_service_status_params,$start_time_params);
        foreach ($order_service_packages as $order_service_package){
            // 获取订单详情数据
            $params = array();
            $params['order_service_no'] = $order_service_package['order_service_no'];
            $order_service_package_detail = OrderServicePackageDetail::getOne($params);
            if (!empty($order_service_package_detail)){
                // 计算本次问诊服务包问诊金额
                $amount_total = bcmul(
                    (string)$order_service_package_detail['service_count'],
                    (string)$order_service_package_detail['single_inquiry_price'],
                    3
                );
            }
        }

        return $amount_total;
    }

    /**
     * 获取im消息推送中，服务包订单相关的自定义参数
     * @param string|int $inquiry_no
     * @return array
     */
    public function getImServicePackageCloudCustomData(string|int $inquiry_no): array
    {
        $OrderServicePackageService = new OrderServicePackageService();

        // 获取服务包订单编号-通过问诊订单id
        $order_service_no = $OrderServicePackageService->getOrderServiceNoByOrderInquiryId($inquiry_no);

        $params = array();
        $params['order_service_no'] = $order_service_no;
        $order_service_package = OrderServicePackage::getOne($params);
        if (empty($order_service_package)){
            return [];
        }

        // 获取服务包订单详情
        $params = array();
        $params['order_service_no'] = $order_service_package['order_service_no'];
        $order_service_package_detail = OrderServicePackageDetail::getOne($params);
        if (empty($order_service_package_detail)){
            return [];
        }

        // 每月问诊次数（0表示不限次）
        $monthly_frequency = $order_service_package_detail['monthly_frequency'];

        // 获取服务包当月已问诊次数
        $month_inquiry_count = 0;
        if ($order_service_package_detail['monthly_frequency'] != 0) {
            $month_inquiry_count = $OrderServicePackageService->getCurrentMonthInquiryCount($order_service_package['pay_time'], $order_service_package['order_service_type'], $order_service_package['user_id'], $order_service_package['doctor_id']);
        }

        // 服务包当月剩余问诊次数
        $remaining_month_inquiry_count = $order_service_package_detail['monthly_frequency'] - $month_inquiry_count;

        // 服务包开始时间
        if (!empty($order_service_package['start_time'])){
            $service_package_start_time = date('Y-m-d H:i',strtotime($order_service_package['start_time']));
        }

        // 服务包结束时间
        if (!empty($order_service_package['finish_time'])){
            $service_package_finish_time = date('Y-m-d H:i',strtotime($order_service_package['finish_time']));
        }

        // 服务包服务周期
        $service_period = $order_service_package_detail['service_period'];

        // 药品剩余数量
        $remaining_quantity = 0;

        // 获取服务包内所有药品
        if ($order_service_package['order_service_type'] == 1){
            $health_package_products = $OrderServicePackageService->getOrderServiceProduct($order_service_package_detail['package_id']);
            foreach ($health_package_products as $health_package_product) {
                // 获取服务包内某一药品的剩余数量
                $remaining_quantity = $OrderServicePackageService->getOrderServiceProductCanUseQuantity($order_service_package['order_service_id'],$health_package_product['product_id'],$health_package_product['quantity']);
            }
        }

        $result = array();
        $result['monthly_frequency'] = $monthly_frequency; // 每月问诊次数（0表示不限次）
        $result['month_inquiry_count'] = $month_inquiry_count; // 获取服务包当月已问诊次数
        $result['remaining_month_inquiry_count'] = $remaining_month_inquiry_count; // 服务包当月剩余问诊次数
        $result['service_package_start_time'] = $service_package_start_time ?? ""; // 服务包开始时间
        $result['service_package_finish_time'] = $service_package_finish_time ?? ""; // 服务包结束时间
        $result['service_period'] = $service_period; // 服务包服务周期
        $result['remaining_quantity'] = $remaining_quantity; // 药品剩余数量

        return $result;
    }

    /**
     * 获取患者家庭成员进行中的服务包订单
     * @param string|int $patient_user_id
     * @param string|int $family_id
     * @param string|int $doctor_id
     * @param string|int $service_type
     * @return array
     */
    public function getPatientFamilyInProgressServicePackage(string|int $patient_user_id,string|int $family_id,string|int $doctor_id,string|int $service_type): array
    {
        // 检测患者是否购买服务包
        $params = array();
        $params['user_id'] = $patient_user_id;
        $params['doctor_id'] = $doctor_id;
        $params['family_id'] = $family_id;
        $params['order_service_type'] = $service_type;

        $order_service_status = ['3'];
        $order_service_package = OrderServicePackage::getStatusOne($params, $order_service_status);
        if (empty($order_service_package)) {
            return [];
        }

        return $order_service_package->toArray();
    }

    /**
     * 获取患者家庭成员是否存在未支付的服务包订单
     * @param string|int $patient_user_id
     * @param string|int $family_id
     * @param string|int $doctor_id
     * @return array
     */
    public function getPatientFamilyNoPayServicePackage(string|int $patient_user_id,string|int $family_id,string|int $doctor_id): array
    {
        // 检测患者是否购买服务包
        $params = array();
        $params['user_id'] = $patient_user_id;
        $params['doctor_id'] = $doctor_id;
        $params['family_id'] = $family_id;

        $order_service_status = ['1'];
        $order_service_package = OrderServicePackage::getStatusOne($params, $order_service_status);
        if (empty($order_service_package)) {
            return [];
        }

        return $order_service_package->toArray();
    }
}