VitalApp/lib/pages/medical/widgets/urinalysis.dart

import 'dart:async';

import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';
import 'package:get/get.dart';
import 'package:vitalapp/architecture/app_parameters.dart';
import 'package:vitalapp/architecture/utils/prompt_box.dart';
import 'package:vitalapp/components/button.dart';
import 'package:vitalapp/components/dialog_input.dart';
import 'package:vitalapp/managers/device_controller_manager.dart';
import 'package:vitalapp/pages/mappers/urine.dart';
import 'package:vitalapp/pages/medical/widgets/device_status_position.dart';
import 'package:vnote_device_plugin/consts/types.dart';
import 'package:vitalapp/managers/interfaces/models/device.dart';
import 'package:vitalapp/pages/medical/widgets/exam_card.dart';
import 'package:vitalapp/pages/medical/controller.dart';
import 'package:vitalapp/pages/medical/models/worker.dart';
import 'package:vitalapp/pages/medical/widgets/device_status.dart';
import 'package:vnote_device_plugin/devices/urine.dart';
import 'package:vnote_device_plugin/models/exams/urine.dart';
import 'package:fis_common/logger/logger.dart';

///  尿常规
class Urinalysis extends StatefulWidget {
  const Urinalysis({
    super.key,
    this.examData,
  });

  final String? examData;

  @override
  State<Urinalysis> createState() => _ExamUrinalysisState();
}

class _ExamUrinalysisState extends State<Urinalysis> {
  var controller = Get.find<MedicalController>();
  bool get isPureSoftwareMode => AppParameters.data.isPureSoftwareMode;
  DeviceControllerManager? urinaly;
  UrineDeviceWorker? worker;
  UrineExamData? urineExamData;
  bool isConnectFail = false;
  bool isAutoTesting = false;
  int errorCount = 0;
  String? get deviceType => MedicalController.typeConvertMap[DeviceTypes.URINE];

  WorkerStatus connectStatus = WorkerStatus.connecting;

  List<Map<String, String>> urinalysis = [
    {"name": '尿白细胞', "key": 'LEU'},
    {"name": '红细胞/潜血', "key": 'BLD'},
    {"name": '尿亚硝酸盐', "key": 'NIT'},
    {"name": '酮体', "key": 'KET'},
    {"name": '尿胆原', "key": 'UBG'},
    {"name": '胆红素', "key": 'BIL'},
    {"name": '尿蛋白', "key": 'PRO'},
    {"name": '葡萄糖', "key": 'GLU'},
    {"name": '酸碱度', "key": 'PH'},
    {"name": '尿比重', "key": 'SG'},
    {"name": '维生素C', "key": 'VC'},
  ];

  Map _value = {};
  @override
  void initState() {
    WidgetsBinding.instance.addPostFrameCallback((timeStamp) {
      initData();
      currentDevice();
      controller.changePatient.addListener(_onPatientChange);
    });

    super.initState();
  }

  Future<void> currentDevice() async {
    DeviceModel? device = await controller.getDevice(DeviceTypes.URINE);
    if (device == null) {
      connectStatus = WorkerStatus.unboundDevice;
      return;
    }
    urinaly =
        DeviceControllerManager(DeviceTypes.URINE, device.model, device.mac);
    worker = urinaly!.worker as UrineDeviceWorker;
    connectStatus = urinaly!.connectStatus;

    loadListeners();
    worker!.connect();
  }

  void loadListeners() {
    worker!.successEvent.addListener(_onSuccess);
    worker!.connectErrorEvent.addListener(_onConnectFail);
    worker!.connectedEvent.addListener(_onConnectSuccess);
    worker!.disconnectedEvent.addListener(_onDisconnected);
  }

  Future<void> initData() async {
    if (controller.diagnosisDataValue.isNotEmpty) {
      if (controller.diagnosisDataValue.keys.contains("Urine")) {
        _value = controller.diagnosisDataValue["Urine"];
      } else {
        for (var key in controller.diagnosisDataValue.keys) {
          if (urinalysis.any((e) => e['key'] == key)) {
            _value[key] = controller.diagnosisDataValue[key];
          }
        }
      }
    } else {
      _value = {};
    }
    setState(() {});
  }

  void releaseListeners() {
    if (worker != null) {
      worker!.connectErrorEvent.removeListener(_onConnectFail);
      worker!.connectedEvent.removeListener(_onConnectSuccess);
      worker!.successEvent.removeListener(_onSuccess);
      worker!.disconnectedEvent.removeListener(_onDisconnected);
      // worker!.errorEvent.removeListener(_onError);
    }
  }

  /// 尝试重连
  Future<void> tryReconnect() async {
    //await worker.disconnect();
    //5s后在执行，是为了防止重连与断开事件一直相互触发
    Future.delayed(const Duration(seconds: 5), () async {
      //如果5秒后仍然是未连接状态，则重试连接
      if (connectStatus == WorkerStatus.disconnected ||
          connectStatus == WorkerStatus.connectionFailed ||
          connectStatus == WorkerStatus.connecting) {
        await disconnect();
        await connect();
      }
    });
  }

  Future<void> disconnect() async {
    await worker?.disconnect();
  }

  Future<void> connect() async {
    await worker?.connect();
  }

  @override
  void dispose() async {
    controller.changePatient.removeListener(_onPatientChange);
    urinaly?.dispose();
    releaseListeners();
    disconnect();
    worker?.dispose();

    super.dispose();
  }

  void _onSuccess(_, UrineExamData e) {
    setState(() {
      isAutoTesting = false;
      urineExamData = e;
      controller.diagnosisDataValue[deviceType!] =
          UrineExamDataMapper.convertUrineExamDataToMap(urineExamData!);
      _value = controller.diagnosisDataValue[deviceType!];
      controller.saveCachedRecord();
      connectStatus = WorkerStatus.connected;
    });
  }

  void _onConnectFail(sender, e) {
    print('连接设备失败');

    logger.i("设备连接失败:${worker!.mac}");
    if (errorCount < 3) {
      errorCount++;
      tryReconnect();
    } else {
      isConnectFail = true;
    }

    connectStatus = WorkerStatus.connectionFailed;
    setState(() {});
  }

  void _onConnectSuccess(sender, e) {
    logger.i("设备连接成功:${worker!.mac}");
    isConnectFail = false;
    errorCount = 0;
    connectStatus = WorkerStatus.connected;
    setState(() {});
  }

  void _onError(sender, e) async {
    PromptBox.toast("测试失败，请确定放好试纸并且试纸已浸湿尿液");
    isAutoTesting = false;
    setState(() {});
  }

  void _onDisconnected(sender, e) {
    print('设备连接中断 errorCount:$errorCount');
    logger.i("设备连接中断:${worker!.mac} errorCount:$errorCount");
    if (errorCount < 3) {
      errorCount++;

      tryReconnect();
    } else {
      isConnectFail = true;
    }
    connectStatus = WorkerStatus.disconnected;
    setState(() {});
  }

  @override
  Widget build(BuildContext context) {
    return Stack(
      children: [
        _buildUrinalysis(),
        if (!isPureSoftwareMode) ...[
          if (!isConnectFail)
            DeviceStatusPosition(
              deviceStatus: DeviceStatus(connectStatus: connectStatus),
            )
          else
            _buildErrorButton(),
        ],
      ],
    );
  }

  Widget _buildErrorButton() {
    return DeviceStatusPosition(
      deviceStatus: Row(
        children: [
          const Text(
            '请确认设备是否启动',
            style: TextStyle(fontSize: 24, color: Colors.red),
          ),
          IconButton(
            onPressed: () {
              tryReconnect();
              setState(() {
                connectStatus = WorkerStatus.connecting;
                isConnectFail = false;
              });
            },
            icon: const Icon(Icons.refresh),
            iconSize: 32,
          ),
        ],
      ),
    );
  }

  Widget _buildUrinalysis() {
    return ExamCard(
      title: '尿常规',
      content: Container(
        alignment: Alignment.center,
        padding: const EdgeInsets.only(
          bottom: 20,
          right: 30,
          left: 40,
        ),
        constraints: const BoxConstraints(minHeight: 50),
        child: GridView.count(
          shrinkWrap: true,
          childAspectRatio: kIsWeb ? 4.5 : 4,
          crossAxisCount: 2, // 列数为2，即两列布局
          children: urinalysis.map((item) {
            return _buildUrineItem(item);
          }).toList(),
        ),
      ),
    );
  }

  Widget _buildUrineItem(Map<String, String> urine) {
    String displayValue = "";
    var value = _value[urine['key']!];
    if (value is String) {
      displayValue = value;
    }
    return InkWell(
      onTap: () {
        _input(urine['name']!, urine['key']!);
      },
      child: Row(
        mainAxisAlignment: MainAxisAlignment.start,
        crossAxisAlignment: CrossAxisAlignment.center,
        children: [
          Container(
            alignment: Alignment.centerLeft,
            width: 100,
            height: 55,
            child: Column(
              crossAxisAlignment: CrossAxisAlignment.start,
              children: [
                Text(
                  urine['key']!,
                  style: const TextStyle(
                    fontSize: 22,
                    color: Colors.black,
                  ),
                ),
                Text(
                  '(${urine['name']!})',
                  textAlign: TextAlign.center,
                  style: const TextStyle(
                    fontSize: 16,
                  ),
                ),
              ],
            ),
          ),
          Container(
            height: 55,
            width: 140,
            alignment: Alignment.centerLeft,
            child: Text(
              displayValue,
              // text: _value.isEmpty ? '--' : _value,
              maxLines: 2,
              style: const TextStyle(
                fontSize: 30,
              ),
            ),
          )
        ],
      ),
    );
  }

  Future<void> _input(String name, String key) async {
    String? result = await VDialogInput(
      title: name,
      initialValue: _value[key],
    ).show();
    if (result?.isNotEmpty ?? false) {
      _value[key] = result ?? '';
    }
    controller.diagnosisDataValue[deviceType!] = _value;
    controller.saveCachedRecord();
    // widget.urinalysis(_value);
    setState(() {});
  }

  void _onPatientChange(Object sender, String e) {
    setState(() {
      _value = {};
      controller.diagnosisDataValue[deviceType!] = {};
    });
  }
}