import 'package:doctor_app_flutter/config/size_config.dart';
import 'package:doctor_app_flutter/core/enum/viewstate.dart';
import 'package:doctor_app_flutter/core/viewModel/patient-referral-viewmodel.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-header-new-design-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/text_fields/app-textfield-custom.dart';
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:intl/intl.dart';

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;

  @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'];

    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: PatientProfileHeaderNewDesignAppBar(
            patient, patientType, arrivalType),
        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,
                          ),
                          AppTextFieldCustom(
                            hintText:
                                TranslationBase.of(context).dietTypeRemarks,
                            controller: _remarksController,
                            inputType: TextInputType.multiline,
                            minLines: 4,
                            maxLines: 6,
                          ),
                        ],
                      ),
                    )
                  ],
                ),
                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,
      )),
    );
  }
}
