doctor_app_flutter/lib/screens/patients/profile/referral/refer-patient-screen-in-patient.dart

import 'package:doctor_app_flutter/config/config.dart';
import 'package:doctor_app_flutter/config/size_config.dart';
import 'package:doctor_app_flutter/core/enum/viewstate.dart';
import 'package:doctor_app_flutter/core/provider/robot_provider.dart';
import 'package:doctor_app_flutter/core/viewModel/patient-referral-viewmodel.dart';
import 'package:doctor_app_flutter/icons_app/doctor_app_icons.dart';
import 'package:doctor_app_flutter/models/patient/patiant_info_model.dart';
import 'package:doctor_app_flutter/screens/base/base_view.dart';
import 'package:doctor_app_flutter/util/dr_app_toast_msg.dart';
import 'package:doctor_app_flutter/util/translations_delegate_base.dart';
import 'package:doctor_app_flutter/widgets/patients/profile/patient-profile-app-bar.dart';
import 'package:doctor_app_flutter/widgets/shared/app_scaffold_widget.dart';
import 'package:doctor_app_flutter/widgets/shared/app_texts_widget.dart';
import 'package:doctor_app_flutter/widgets/shared/buttons/app_buttons_widget.dart';
import 'package:doctor_app_flutter/widgets/shared/dialogs/dailog-list-select.dart';
import 'package:doctor_app_flutter/widgets/shared/loader/gif_loader_dialog_utils.dart';
import 'package:doctor_app_flutter/widgets/shared/speech-text-popup.dart';
import 'package:doctor_app_flutter/widgets/shared/text_fields/app-textfield-custom.dart';
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:intl/intl.dart';
import 'package:permission_handler/permission_handler.dart';
import 'package:speech_to_text/speech_recognition_error.dart';
import 'package:speech_to_text/speech_to_text.dart' as stt;

class PatientMakeInPatientReferralScreen extends StatefulWidget {
  @override
  _PatientMakeInPatientReferralScreenState createState() =>
      _PatientMakeInPatientReferralScreenState();
}

class _PatientMakeInPatientReferralScreenState
    extends State<PatientMakeInPatientReferralScreen> {
  PatiantInformtion patient;
  List<dynamic> referToList;
  dynamic _referTo;
  dynamic _selectedBranch;
  dynamic _selectedClinic;
  dynamic _selectedDoctor;
  dynamic _selectedFrequency;
  final _remarksController = TextEditingController();
  final _extController = TextEditingController();
  int _activePriority = 1;
  String appointmentDate;

  String branchError;
  String hospitalError;
  String clinicError;
  String doctorError;
  String frequencyError;
  stt.SpeechToText speech = stt.SpeechToText();
  var reconizedWord;
  var event = RobotProvider();

  @override
  void initState() {
    requestPermissions();
    event.controller.stream.listen((p) {
      if (p['startPopUp'] == 'true') {
        if (this.mounted) {
          initSpeechState().then((value) => {onVoiceText()});
        }
      }
    });
    super.initState();
  }

  onVoiceText() async {
    new SpeechToText(context: context).showAlertDialog(context);
    var lang = TranslationBase.of(AppGlobal.CONTEX).locale.languageCode;
    bool available = await speech.initialize(
        onStatus: statusListener, onError: errorListener);
    if (available) {
      speech.listen(
        onResult: resultListener,
        listenMode: stt.ListenMode.confirmation,
        localeId: lang == 'en' ? 'en-US' : 'ar-SA',
      );
    } else {
      print("The user has denied the use of speech recognition.");
    }
  }

  void errorListener(SpeechRecognitionError error) {
    event.setValue({"searchText": 'null'});
    //SpeechToText.closeAlertDialog(context);
    print(error);
  }

  void statusListener(String status) {
    reconizedWord = status == 'listening' ? 'Lisening...' : 'Sorry....';
  }

  void requestPermissions() async {
    Map<Permission, PermissionStatus> statuses = await [
      Permission.microphone,
    ].request();
  }

  void resultListener(result) {
    reconizedWord = result.recognizedWords;
    event.setValue({"searchText": reconizedWord});

    if (result.finalResult == true) {
      setState(() {
        SpeechToText.closeAlertDialog(context);
        speech.stop();
        _remarksController.text += reconizedWord + '\n';
      });
    } else {
      print(result.finalResult);
    }
  }

  Future<void> initSpeechState() async {
    bool hasSpeech = await speech.initialize(
        onError: errorListener, onStatus: statusListener);
    print(hasSpeech);
    if (!mounted) return;
  }

  @override
  Widget build(BuildContext context) {
    final routeArgs = ModalRoute.of(context).settings.arguments as Map;
    patient = routeArgs['patient'];
    String patientType = routeArgs['patientType'];
    String arrivalType = routeArgs['arrivalType'];
    bool isInpatient = routeArgs['isInpatient'];
    referToList = List();
    dynamic sameBranch = {
      "id": 1,
      "name": TranslationBase.of(context).sameBranch
    };
    dynamic otherBranch = {
      "id": 2,
      "name": TranslationBase.of(context).otherBranch
    };
    referToList.add(sameBranch);
    referToList.add(otherBranch);

    final screenSize = MediaQuery.of(context).size;

    return BaseView<PatientReferralViewModel>(
      onModelReady: (model) => model.getReferralFrequencyList(),
      builder: (_, model, w) => AppScaffold(
        baseViewModel: model,
        appBarTitle: TranslationBase.of(context).referPatient,
        isShowAppBar: true,
        appBar: PatientProfileAppBar(
          patient,
          isInpatient: isInpatient,
        ),
        body: SingleChildScrollView(
          child: Container(
            child: Column(
              mainAxisAlignment: MainAxisAlignment.spaceAround,
              children: [
                Column(
                  crossAxisAlignment: CrossAxisAlignment.start,
                  children: [
                    Container(
                      margin: EdgeInsets.all(16.0),
                      child: Column(
                        crossAxisAlignment: CrossAxisAlignment.start,
                        children: [
                          AppText(
                            "${TranslationBase.of(context).refer}",
                            fontFamily: 'Poppins',
                            fontSize: SizeConfig.textMultiplier * 1.6,
                            fontWeight: FontWeight.w600,
                          ),
                          AppText(
                            "${TranslationBase.of(context).patient}",
                            fontFamily: 'Poppins',
                            fontSize: SizeConfig.textMultiplier * 3,
                            fontWeight: FontWeight.bold,
                          )
                        ],
                      ),
                    ),
                    Container(
                      margin: EdgeInsets.symmetric(vertical: 0, horizontal: 16),
                      child: Column(
                        crossAxisAlignment: CrossAxisAlignment.start,
                        children: [
                          AppTextFieldCustom(
                            height: screenSize.height * 0.075,
                            hintText: TranslationBase.of(context).branch,
                            dropDownText:
                                _referTo != null ? _referTo['name'] : null,
                            enabled: false,
                            isTextFieldHasSuffix: true,
                            validationError: branchError,
                            onClick: referToList != null
                                ? () {
                                    ListSelectDialog dialog = ListSelectDialog(
                                      list: referToList,
                                      attributeName: 'name',
                                      attributeValueId: 'id',
                                      okText: TranslationBase.of(context).ok,
                                      okFunction: (selectedValue) {
                                        setState(() {
                                          _referTo = selectedValue;
                                          _selectedBranch = null;
                                          _selectedClinic = null;
                                          _selectedDoctor = null;
                                          model
                                              .getDoctorBranch()
                                              .then((value) async {
                                            _selectedBranch = value;
                                            if (_referTo['id'] == 1) {
                                              GifLoaderDialogUtils.showMyDialog(
                                                  context);
                                              await model
                                                  .getClinics(_selectedBranch[
                                                      'facilityId'])
                                                  .then((_) =>
                                                      GifLoaderDialogUtils
                                                          .hideDialog(context));
                                              if (model.state ==
                                                  ViewState.ErrorLocal) {
                                                DrAppToastMsg.showErrorToast(
                                                    model.error);
                                              }
                                            } else {
                                              _selectedBranch = null;
                                            }
                                          });
                                        });
                                      },
                                    );
                                    showDialog(
                                      barrierDismissible: false,
                                      context: context,
                                      builder: (BuildContext context) {
                                        return dialog;
                                      },
                                    );
                                  }
                                : null,
                          ),
                          SizedBox(
                            height: 10,
                          ),
                          AppTextFieldCustom(
                            height: screenSize.height * 0.075,
                            hintText: TranslationBase.of(context).hospital,
                            dropDownText: _selectedBranch != null
                                ? _selectedBranch['facilityName']
                                : null,
                            enabled: false,
                            isTextFieldHasSuffix: true,
                            validationError: hospitalError,
                            onClick: model.branchesList != null &&
                                    model.branchesList.length > 0 &&
                                    _referTo != null &&
                                    _referTo['id'] == 2
                                ? () {
                                    ListSelectDialog dialog = ListSelectDialog(
                                      list: model.branchesList,
                                      attributeName: 'facilityName',
                                      attributeValueId: 'facilityId',
                                      okText: TranslationBase.of(context).ok,
                                      okFunction: (selectedValue) {
                                        setState(() async {
                                          _selectedBranch = selectedValue;
                                          _selectedClinic = null;
                                          _selectedDoctor = null;
                                          GifLoaderDialogUtils.showMyDialog(
                                              context);
                                          await model
                                              .getClinics(
                                                  _selectedBranch['facilityId'])
                                              .then((_) => GifLoaderDialogUtils
                                                  .hideDialog(context));
                                          if (model.state ==
                                              ViewState.ErrorLocal) {
                                            DrAppToastMsg.showErrorToast(
                                                model.error);
                                          }
                                        });
                                      },
                                    );
                                    showDialog(
                                      barrierDismissible: false,
                                      context: context,
                                      builder: (BuildContext context) {
                                        return dialog;
                                      },
                                    );
                                  }
                                : null,
                          ),
                          SizedBox(
                            height: 10,
                          ),
                          AppTextFieldCustom(
                            height: screenSize.height * 0.075,
                            hintText: TranslationBase.of(context).clinic,
                            dropDownText: _selectedClinic != null
                                ? _selectedClinic['ClinicDescription']
                                : null,
                            enabled: false,
                            isTextFieldHasSuffix: true,
                            validationError: clinicError,
                            onClick: _selectedBranch != null &&
                                    model.clinicsList != null &&
                                    model.clinicsList.length > 0
                                ? () {
                                    ListSelectDialog dialog = ListSelectDialog(
                                      list: model.clinicsList,
                                      attributeName: 'ClinicDescription',
                                      attributeValueId: 'ClinicID',
                                      usingSearch: true,
                                      hintSearchText:
                                          TranslationBase.of(context)
                                              .clinicSearch,
                                      okText: TranslationBase.of(context).ok,
                                      okFunction: (selectedValue) {
                                        setState(() async {
                                          _selectedDoctor = null;
                                          _selectedClinic = selectedValue;
                                          GifLoaderDialogUtils.showMyDialog(
                                              context);
                                          await model
                                              .getClinicDoctors(
                                                  patient,
                                                  _selectedClinic['ClinicID'],
                                                  _selectedBranch['facilityId'])
                                              .then((_) => GifLoaderDialogUtils
                                                  .hideDialog(context));
                                          if (model.state ==
                                              ViewState.ErrorLocal) {
                                            DrAppToastMsg.showErrorToast(
                                                model.error);
                                          }
                                        });
                                      },
                                    );
                                    showDialog(
                                      barrierDismissible: false,
                                      context: context,
                                      builder: (BuildContext context) {
                                        return dialog;
                                      },
                                    );
                                  }
                                : null,
                          ),
                          SizedBox(
                            height: 10,
                          ),
                          AppTextFieldCustom(
                            height: screenSize.height * 0.075,
                            hintText: TranslationBase.of(context).doctor,
                            dropDownText: _selectedDoctor != null
                                ? _selectedDoctor['Name']
                                : null,
                            enabled: false,
                            isTextFieldHasSuffix: true,
                            validationError: doctorError,
                            onClick: _selectedClinic != null &&
                                    model.doctorsList != null &&
                                    model.doctorsList.length > 0
                                ? () {
                                    ListSelectDialog dialog = ListSelectDialog(
                                      list: model.doctorsList,
                                      attributeName: 'Name',
                                      attributeValueId: 'DoctorID',
                                      usingSearch: true,
                                      hintSearchText:
                                          TranslationBase.of(context)
                                              .doctorSearch,
                                      okText: TranslationBase.of(context).ok,
                                      okFunction: (selectedValue) {
                                        setState(() {
                                          _selectedDoctor = selectedValue;
                                        });
                                      },
                                    );
                                    showDialog(
                                      barrierDismissible: false,
                                      context: context,
                                      builder: (BuildContext context) {
                                        return dialog;
                                      },
                                    );
                                  }
                                : () {
                                    if (_selectedClinic == null) {
                                      DrAppToastMsg.showErrorToast(
                                          "You need to select a clinic first");
                                    } else if (model.doctorsList == null ||
                                        model.doctorsList.length == 0) {
                                      DrAppToastMsg.showErrorToast(
                                          "There is no doctors for this clinic");
                                    }
                                  },
                          ),
                          SizedBox(
                            height: 10,
                          ),
                          AppText(
                            "${TranslationBase.of(context).priority}",
                            fontFamily: 'Poppins',
                            fontSize: SizeConfig.textMultiplier * 2.0,
                            fontWeight: FontWeight.w600,
                          ),
                          SizedBox(
                            height: 4,
                          ),
                          priorityBar(context, screenSize),
                          SizedBox(
                            height: 10,
                          ),
                          AppText(
                            "${TranslationBase.of(context).replayBefore}:  ${getPriority()}",
                            fontWeight: FontWeight.normal,
                            fontSize: SizeConfig.textMultiplier * 1.9,
                          ),
                          SizedBox(
                            height: 10,
                          ),
                          AppTextFieldCustom(
                            height: screenSize.height * 0.075,
                            hintText:
                                TranslationBase.of(context).referralFrequency,
                            dropDownText: _selectedFrequency != null
                                ? _selectedFrequency['Description']
                                : null,
                            enabled: false,
                            isTextFieldHasSuffix: true,
                            validationError: frequencyError,
                            onClick: () {
                              ListSelectDialog dialog = ListSelectDialog(
                                list: model.referralFrequencyList,
                                attributeName: 'Description',
                                attributeValueId: 'ParameterCode',
                                usingSearch: true,
                                hintSearchText: TranslationBase.of(context)
                                    .selectReferralFrequency,
                                okText: TranslationBase.of(context).ok,
                                okFunction: (selectedValue) {
                                  setState(() {
                                    _selectedFrequency = selectedValue;
                                  });
                                },
                              );
                              showDialog(
                                barrierDismissible: false,
                                context: context,
                                builder: (BuildContext context) {
                                  return dialog;
                                },
                              );
                            },
                          ),
                          SizedBox(
                            height: 10,
                          ),
                          AppTextFieldCustom(
                            hintText: TranslationBase.of(context).ext,
                            controller: _extController,
                            inputType: TextInputType.text,
                          ),
                          SizedBox(
                            height: 10,
                          ),
                          Stack(
                            children: [
                              AppTextFieldCustom(
                                hintText: "Remarks",
                                controller: _remarksController,
                                inputType: TextInputType.multiline,
                                minLines: 4,
                                maxLines: 6,
                              ),
                              Positioned(
                                top: 0,
                                //MediaQuery.of(context).size.height * 0,
                                right: 15,
                                child: IconButton(
                                  icon: Icon(
                                    DoctorApp.speechtotext,
                                    color: Colors.black,
                                    size: 35,
                                  ),
                                  onPressed: () {
                                    initSpeechState()
                                        .then((value) => {onVoiceText()});
                                  },
                                ),
                              ),
                            ],
                          ),
                        ],
                      ),
                    )
                  ],
                ),
                Column(
                  children: [
                    _remarksController.text.isEmpty
                        ? SizedBox()
                        : Container(
                            margin: EdgeInsets.all(5),
                            child: AppButton(
                              title: TranslationBase.of(context).clearText,
                              onPressed: () {
                                setState(() {
                                  _remarksController.text = '';
                                });
                              },
                            )),
                    Container(
                      margin: EdgeInsets.symmetric(horizontal: 16, vertical: 8),
                      child: AppButton(
                        title: TranslationBase.of(context).refer,
                        fontWeight: FontWeight.w700,
                        color: Color(0XFF359846),
                        onPressed: () async {
                          setState(() {
                            if (_referTo == null) {
                              branchError =
                                  TranslationBase.of(context).fieldRequired;
                            } else {
                              branchError = null;
                            }
                            if (_selectedBranch == null) {
                              hospitalError =
                                  TranslationBase.of(context).fieldRequired;
                            } else {
                              hospitalError = null;
                            }
                            if (_selectedClinic == null) {
                              clinicError =
                                  TranslationBase.of(context).fieldRequired;
                            } else {
                              clinicError = null;
                            }
                            if (_selectedDoctor == null) {
                              doctorError =
                                  TranslationBase.of(context).fieldRequired;
                            } else {
                              doctorError = null;
                            }
                            if (_selectedFrequency == null) {
                              frequencyError =
                                  TranslationBase.of(context).fieldRequired;
                            } else {
                              frequencyError = null;
                            }
                          });
                          if (_selectedFrequency == null ||
                              _selectedBranch == null ||
                              _selectedClinic == null ||
                              _selectedDoctor == null ||
                              _remarksController.text == null ||
                              _extController.text == null) return;
                          {
                            await model.makeInPatientReferral(
                                patient: patient,
                                projectID: _selectedBranch['facilityId'],
                                clinicID: _selectedClinic['ClinicID'],
                                doctorID: _selectedDoctor['DoctorID'],
                                frequencyCode:
                                    _selectedFrequency['ParameterCode'],
                                ext: _extController.text,
                                remarks: _remarksController.text,
                                priority: _activePriority,
                                referralDate: appointmentDate);
                            if (model.state == ViewState.ErrorLocal)
                              DrAppToastMsg.showErrorToast(model.error);
                            else {
                              DrAppToastMsg.showSuccesToast(
                                  TranslationBase.of(context)
                                      .referralSuccessMsg);
                              Navigator.pop(context);
                            }
                          }
                        },
                      ),
                    )
                  ],
                )
              ],
            ),
          ),
        ),
      ),
    );
  }

  Widget priorityBar(BuildContext _context, Size screenSize) {
    List<String> _priorities = [
      TranslationBase.of(context).veryUrgent.toUpperCase(),
      TranslationBase.of(context).urgent.toUpperCase(),
      TranslationBase.of(context).routine.toUpperCase(),
    ];
    return Container(
      height: screenSize.height * 0.070,
      decoration:
          containerBorderDecoration(Color(0Xffffffff), Color(0xFFCCCCCC)),
      child: Row(
        mainAxisSize: MainAxisSize.max,
        crossAxisAlignment: CrossAxisAlignment.center,
        children: _priorities.map((item) {
          bool _isActive = _priorities[_activePriority] == item ? true : false;
          return Expanded(
            child: InkWell(
              child: Center(
                child: Container(
                    height: screenSize.height * 0.070,
                    decoration: containerBorderDecoration(
                        _isActive ? Color(0XFFB8382B) : Colors.white,
                        _isActive ? Color(0XFFB8382B) : Colors.white),
                    child: Center(
                      child: Text(
                        item,
                        style: TextStyle(
                          fontSize: 12,
                          color: _isActive ? Colors.white : Colors.black,
                          //Colors.black,
                          fontWeight: FontWeight.bold,
                        ),
                      ),
                    )),
              ),
              onTap: () {
                print(_priorities.indexOf(item));
                setState(() {
                  _activePriority = _priorities.indexOf(item);
                });
              },
            ),
          );
        }).toList(),
      ),
    );
  }

  String getPriority() {
    DateTime date = DateTime.now();
    switch (_activePriority) {
      case 0:
        date = date.add(new Duration(hours: 3));
        break;
      case 1:
        date = date.add(new Duration(hours: 6));
        break;
      case 2:
        date = date.add(new Duration(days: 1));
        break;
    }
    var format = DateFormat('yyyy/mm/dd HH:mm a');
    var time = format.format(date);
    print(time);

    appointmentDate = time;
    return time;
  }

  BoxDecoration containerBorderDecoration(
      Color containerColor, Color borderColor) {
    return BoxDecoration(
      color: containerColor,
      shape: BoxShape.rectangle,
      borderRadius: BorderRadius.all(Radius.circular(6)),
      border: Border.fromBorderSide(BorderSide(
        color: borderColor,
        width: 2.0,
      )),
    );
  }
}