import 'package:doctor_app_flutter/config/config.dart';
import 'package:doctor_app_flutter/config/shared_pref_kay.dart';
import 'package:doctor_app_flutter/config/size_config.dart';
import 'package:doctor_app_flutter/core/enum/view_state.dart';
import 'package:doctor_app_flutter/core/model/doctor/doctor_profile_model.dart';
import 'package:doctor_app_flutter/core/model/note/CreateNoteModel.dart';
import 'package:doctor_app_flutter/core/model/note/note_model.dart';
import 'package:doctor_app_flutter/core/model/note/update_note_model.dart';
import 'package:doctor_app_flutter/core/model/patient/patiant_info_model.dart';
import 'package:doctor_app_flutter/core/model/patient/progress_note_request.dart';
import 'package:doctor_app_flutter/core/provider/robot_provider.dart';
import 'package:doctor_app_flutter/core/viewModel/patient_view_model.dart';
import 'package:doctor_app_flutter/core/viewModel/project_view_model.dart';
import 'package:doctor_app_flutter/icons_app/doctor_app_icons.dart';
import 'package:doctor_app_flutter/screens/patients/profile/soap_update/shared_soap_widgets/bottom_sheet_title.dart';
import 'package:doctor_app_flutter/utils/dr_app_toast_msg.dart';
import 'package:doctor_app_flutter/utils/extenstions_utils.dart';
import 'package:doctor_app_flutter/utils/translations_delegate_base_utils.dart';
import 'package:doctor_app_flutter/utils/utils.dart';
import 'package:doctor_app_flutter/widgets/shared/app_scaffold_widget.dart';
import 'package:doctor_app_flutter/widgets/shared/buttons/app_buttons_widget.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:permission_handler/permission_handler.dart';
import 'package:provider/provider.dart';
import 'package:speech_to_text/speech_recognition_error.dart';
import 'package:speech_to_text/speech_to_text.dart' as stt;

import '../../../../../widgets/shared/dialogs/dailog-list-select.dart';
import '../../../../base/base_view.dart';

class UpdateNoteOrder extends StatefulWidget {
  final NoteModel? note;
  final PatientViewModel patientModel;
  final PatiantInformtion patient;
  final int? visitType;
  final bool isUpdate;
  final bool isVidaPlusProject;
  final List<dynamic>? elementList;
  final Function(dynamic)? okFunction;

  const UpdateNoteOrder({Key? key, this.note, required this.patientModel, required this.patient, this.visitType, required this.isUpdate, this.elementList, this.okFunction, this.isVidaPlusProject = false}) : super(key: key);

  @override
  _UpdateNoteOrderState createState() => _UpdateNoteOrderState();
}

class _UpdateNoteOrderState extends State<UpdateNoteOrder> {
  dynamic selectValue;
  int selectedType = 0;
  bool isSubmitted = false;
  stt.SpeechToText speech = stt.SpeechToText();
  var recognizedWord;
  var event = RobotProvider();
  late ProjectViewModel projectViewModel;

  TextEditingController progressNoteController = TextEditingController();

  setSelectedType(int val) {
    setState(() {
      selectedType = val;
    });
  }

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

  @override
  Widget build(BuildContext context) {
    String keyId = 'ParameterCode';

    projectViewModel = Provider.of(context);

    if (widget.note != null) {
      progressNoteController.text = widget.note!.notes!;
      if (selectValue == null) selectValue = {};
      selectValue[keyId] = widget.note!.condition;
      selectValue['Description'] = widget.note!.conditionDescription;
    }

    return BaseView<PatientViewModel>(
      onModelReady: (model) {
        if(widget.isVidaPlusProject){
          model.getProgressNoteCondition();
        }else
        model.getStpMasterList(isLocalBusy: false);
      },
      builder: (_, model, w) => AppScaffold(
        isShowAppBar: false,
        backgroundColor: Theme.of(context).scaffoldBackgroundColor,
        body: SingleChildScrollView(
          child: Container(
            height: MediaQuery.of(context).size.height * 1.0,
            child: Padding(
              padding: EdgeInsets.all(0.0),
              child: Column(
                crossAxisAlignment: CrossAxisAlignment.start,
                children: [
                  BottomSheetTitle(
                    title: widget.visitType == 3
                        ? (widget.isUpdate ? TranslationBase.of(context).noteUpdate : TranslationBase.of(context).noteAdd) + TranslationBase.of(context).orderSheet
                        : (widget.isUpdate ? TranslationBase.of(context).noteUpdate : TranslationBase.of(context).noteAdd) + TranslationBase.of(context).progressNote,
                  ),
                  SizedBox(
                    height: 10.0,
                  ),
                  Container(
                    padding: EdgeInsets.only(right: 20, left: 20),
                    child: InkWell(
                      onTap: model.stpMasterList != null
                          ? () {
                              Utils.hideKeyboard(context);
                              ListSelectDialog dialog = ListSelectDialog(
                                list: model.stpMasterList,
                                attributeName: 'Description',
                                attributeValueId: model.stpMasterList.length == 1 ? model.stpMasterList[0]['${keyId}'].toString() : '${keyId}',
                                okText: TranslationBase.of(context).ok,
                                okFunction: (selectedValue) => {
                                  setState(() {
                                    selectValue = selectedValue;
                                    selectValue['isDefault'] = true;
                                  })
                                },
                              );
                              showDialog(
                                barrierDismissible: false,
                                context: context,
                                builder: (BuildContext context) {
                                  return dialog;
                                },
                              );
                            }
                          : null,
                      child: AppTextFieldCustom(
                        hintText: TranslationBase.of(context).selectCondition, //'Select Condition',
                        dropDownText: model.stpMasterList.length == 1
                            ? model.stpMasterList[0]['Description']
                            : selectValue == null
                                ? null
                                : selectValue['Description'],
                        enabled: false,
                        isTextFieldHasSuffix: true, onChanged: (value) {}, onFieldSubmitted: () {},
                      ),
                    ),
                  ),
                  SizedBox(
                    height: 10.0,
                  ),
                  Center(
                    child: FractionallySizedBox(
                      widthFactor: 0.9,
                      child: Column(
                        children: [
                          Stack(
                            children: [
                              AppTextFieldCustom(
                                hintText: widget.visitType == 3
                                    ? (widget.isUpdate ? TranslationBase.of(context).noteUpdate : TranslationBase.of(context).noteAdd) + TranslationBase.of(context).orderSheet
                                    : (widget.isUpdate ? TranslationBase.of(context).noteUpdate : TranslationBase.of(context).noteAdd) + TranslationBase.of(context).progressNote,
                                //TranslationBase.of(context).addProgressNote,
                                controller: progressNoteController,
                                maxLines: 40,
                                minLines: 20,
                                hasBorder: true,

                                // isTextFieldHasSuffix: true,
                                validationError: progressNoteController.text.isEmpty && isSubmitted ? TranslationBase.of(context).emptyMessage : null, onChanged: (value) {},
                                onFieldSubmitted: () {},
                              ),
                              Positioned(
                                  top: -2,
                                  //MediaQuery.of(context).size.height * 0,
                                  right: projectViewModel.isArabic ? MediaQuery.of(context).size.width * 0.75 : 15,
                                  child: Column(
                                    children: [
                                      IconButton(
                                        icon: Icon(DoctorApp.speechtotext, color: Colors.black, size: 35),
                                        onPressed: () {
                                          initSpeechState().then((value) => {onVoiceText()});
                                        },
                                      ),
                                    ],
                                  ))
                            ],
                          ),
                        ],
                      ),
                    ),
                  ),
                ],
              ),
            ),
          ),
        ),
        bottomSheet: Container(
          height: progressNoteController.text.isNotEmpty ? 130 : 70,
          margin: EdgeInsets.all(SizeConfig.widthMultiplier! * 5),
          child: Column(
            children: <Widget>[
              if (progressNoteController.text.isNotEmpty)
                Container(
                  margin: EdgeInsets.all(5),
                  child: AppButton(
                    title: TranslationBase.of(context).clearText,
                    onPressed: () {
                      setState(() {
                        progressNoteController.text = '';
                      });
                    },
                  ),
                ),
              Container(
                  margin: EdgeInsets.all(5),
                  child: AppButton(
                      title: widget.visitType == 3
                          ? (widget.isUpdate ? TranslationBase.of(context).noteUpdate : TranslationBase.of(context).noteAdd) + TranslationBase.of(context).orderSheet
                          : (widget.isUpdate ? TranslationBase.of(context).noteUpdate : TranslationBase.of(context).noteAdd) + TranslationBase.of(context).progressNote,
                      color: AppGlobal.appGreenColor,
                      // disabled: progressNoteController.text.isEmpty,
                      fontWeight: FontWeight.w700,
                      onPressed: () async {
                        setState(() {
                          isSubmitted = true;
                        });
                        if (progressNoteController.text.trim().isNotEmpty) {
                          Map<String, dynamic> profile = await sharedPref.getObj(DOCTOR_PROFILE);

                          DoctorProfileModel doctorProfile = DoctorProfileModel.fromJson(profile);
                          print("the values are ${(selectValue as Map?)?.isNullOrEmpty == true }");
                          if(selectValue == null || (selectValue as Map?)?.isNullOrEmpty == true) {
                            DrAppToastMsg.showErrorToast(TranslationBase.of(context).kindlySelectCondition);
                            return;
                          }
                          GifLoaderDialogUtils.showMyDialog(context);

                          if (widget.isUpdate) {
                            UpdateNoteReqModel reqModel = UpdateNoteReqModel(
                                admissionNo: int.parse(widget.patient.admissionNo!),
                                cancelledNote: false,
                                lineItemNo: widget.note!.lineItemNo,
                                createdBy: widget.note!.createdBy,
                                notes: progressNoteController.text,
                                verifiedNote: false,
                                patientTypeID: widget.patient.patientType,
                                patientOutSA: false,
                                conditionId: selectValue['ParameterCode']);
                            await widget.patientModel.updatePatientProgressNote(reqModel);
                          } else {
                            CreateNoteModel reqModel = CreateNoteModel(
                                admissionNo: (widget.isVidaPlusProject)?widget.patient.admissionID:int.parse(widget.patient.admissionNo!),
                                createdBy: doctorProfile.doctorID,
                                visitType: widget.visitType,
                                patientID: widget.patient.patientId,
                                nursingRemarks: '  ',
                                patientTypeID: widget.patient.patientType,
                                patientOutSA: false,
                                notes: progressNoteController.text,
                                conditionId: selectValue['ParameterCode']);

                            await widget.patientModel.createPatientProgressNote(reqModel, widget.patient, isVidaPlus: widget.isVidaPlusProject);
                          }

                          if (widget.patientModel.state == ViewState.ErrorLocal) {
                            Utils.showErrorToast(widget.patientModel.error);
                          } else {
                            ProgressNoteRequest progressNoteRequest = ProgressNoteRequest(
                                visitType: widget.visitType,
                                // if equal 5 then this will return progress note
                                admissionNo: (widget.isVidaPlusProject)?widget.patient.admissionID:int.parse(widget.patient.admissionNo!),
                                projectID: widget.patient.projectId,
                                patientTypeID: widget.patient.patientType,
                                languageID: 2);
                            await widget.patientModel.getPatientProgressNote(progressNoteRequest.toJson(),  widget.patient, isVidaPlus: widget.isVidaPlusProject);
                          }
                          GifLoaderDialogUtils.hideDialog(context);
                          DrAppToastMsg.showSuccesToast(TranslationBase.of(context).yourOrderAddedSuccessfully);
                          Navigator.of(context).pop();
                        } else {
                          Utils.showErrorToast(TranslationBase.of(context).youCannotAddOnlySpaces);
                        }
                      })),
            ],
          ),
        ),
      ),
    );
  }

  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) {
    recognizedWord = status == 'listening' ? 'Listening...' : 'Sorry....';
  }

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

  void resultListener(result) {
    recognizedWord = result.recognizedWords;
    event.setValue({"searchText": recognizedWord});
    if (result.finalResult == true) {
      setState(() {
        if (mounted) {
          // speech.stop();
          progressNoteController.text += recognizedWord + '\n';
          SpeechToText.closeAlertDialog(context);
        }
      });
    } else {
      print(result.finalResult);
    }
  }

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