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/master_lookup_key.dart';
import 'package:doctor_app_flutter/core/enum/viewstate.dart';
import 'package:doctor_app_flutter/core/viewModel/SOAP_view_model.dart';
import 'package:doctor_app_flutter/core/viewModel/auth_view_model.dart';
import 'package:doctor_app_flutter/core/viewModel/project_view_model.dart';
import 'package:doctor_app_flutter/models/SOAP/GetPhysicalExamReqModel.dart';
import 'package:doctor_app_flutter/models/SOAP/master_key_model.dart';
import 'package:doctor_app_flutter/models/SOAP/my_selected_examination.dart';
import 'package:doctor_app_flutter/models/SOAP/post_physical_exam_request_model.dart';
import 'package:doctor_app_flutter/models/doctor/doctor_profile_model.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/translations_delegate_base.dart';
import 'package:doctor_app_flutter/widgets/shared/Text.dart';
import 'package:doctor_app_flutter/widgets/shared/TextFields.dart';
import 'package:doctor_app_flutter/widgets/shared/app_buttons_widget.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/expandable-widget-header-body.dart';
import 'package:doctor_app_flutter/widgets/transitions/fade_page.dart';
import 'package:flutter/material.dart';
import 'package:font_awesome_flutter/font_awesome_flutter.dart';
import 'package:hexcolor/hexcolor.dart';
import 'package:provider/provider.dart';

import 'examination-item-card.dart';
import 'objective-add-examination-page.dart';

class UpdateObjectivePage extends StatefulWidget {
  final Function changePageViewIndex;
  final Function changeLoadingState;

  final List<MySelectedExamination> mySelectedExamination;
  final PatiantInformtion patientInfo;

  UpdateObjectivePage(
      {Key key,
      this.changePageViewIndex,
      this.mySelectedExamination,
      this.patientInfo,
      this.changeLoadingState});

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

class _UpdateObjectivePageState extends State<UpdateObjectivePage> {
  bool isSysExaminationExpand = false;

  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: 0.5,
      )),
    );
  }

  @override
  Widget build(BuildContext context) {
    final screenSize = MediaQuery.of(context).size;
    ProjectViewModel projectViewModel = Provider.of(context);

    return BaseView<SOAPViewModel>(
        onModelReady: (model) async {
          widget.mySelectedExamination.clear();
          GetPhysicalExamReqModel getPhysicalExamReqModel =
              GetPhysicalExamReqModel(
                  patientMRN: widget.patientInfo.patientMRN,
                  episodeID: widget.patientInfo.episodeNo.toString(),
                  appointmentNo: widget.patientInfo.appointmentNo);

          await model.getPatientPhysicalExam(getPhysicalExamReqModel);
          if (model.patientPhysicalExamList.isNotEmpty) {
            if (model.physicalExaminationList.length == 0) {
              await model
                  .getMasterLookup(MasterKeysService.PhysicalExamination);
            }
            model.patientPhysicalExamList.forEach((element) {
              MasterKeyModel examMaster = model.getOneMasterKey(
                masterKeys: MasterKeysService.PhysicalExamination,
                id: element.examId,
              );
              MySelectedExamination tempEam = MySelectedExamination(
                  selectedExamination: examMaster,
                  remark: element.remarks,
                  isNormal: element.isNormal,
                  createdBy: element.createdBy,
                  notExamined: element.notExamined,
                  isNew: element.isNew,
                  isAbnormal: element.isAbnormal);
              widget.mySelectedExamination.add(tempEam);
            });
          }

          widget.changeLoadingState(false);
        },
        builder: (_, model, w) => AppScaffold(
            isShowAppBar: false,
            // baseViewModel: model,
            body: Column(
              mainAxisAlignment: MainAxisAlignment.spaceBetween,
              children: [
                Expanded(
                  child: SingleChildScrollView(
                    physics: ScrollPhysics(),
                    child: Container(
                      color: Color.fromRGBO(248, 248, 248, 1),
                      child: Center(
                        child: FractionallySizedBox(
                          widthFactor: 0.95,
                          child: Container(
                            margin: EdgeInsets.all(8.0),
                            padding: EdgeInsets.all(12.0),
                            decoration: BoxDecoration(
                              shape: BoxShape.rectangle,
                              color: Colors.white,
                              borderRadius: BorderRadius.circular(12),
                              border: Border.fromBorderSide(BorderSide(
                                color: Colors.grey.shade400,
                                width: 0.4,
                              )),
                            ),
                            child: Column(
                              mainAxisAlignment: MainAxisAlignment.start,
                              children: [
                                HeaderBodyExpandableNotifier(
                                  headerWidget: Row(
                                    mainAxisAlignment:
                                        MainAxisAlignment.spaceBetween,
                                    children: [
                                      Row(
                                        children: [
                                          AppText(
                                            "${TranslationBase.of(context).physicalSystemExamination}",
                                            fontFamily: 'Poppins',
                                            fontSize:
                                                SizeConfig.textMultiplier * 2.0,
                                            fontWeight: isSysExaminationExpand
                                                ? FontWeight.w700
                                                : FontWeight.normal,
                                          ),
                                          Icon(
                                            FontAwesomeIcons.asterisk,
                                            color: AppGlobal.appPrimaryColor,
                                            size: 12,
                                          )
                                        ],
                                      ),
                                      InkWell(
                                          onTap: () {
                                            setState(() {
                                              isSysExaminationExpand =
                                                  !isSysExaminationExpand;
                                            });
                                          },
                                          child: Icon(isSysExaminationExpand
                                              ? Icons.keyboard_arrow_up
                                              : Icons.keyboard_arrow_down))
                                    ],
                                  ),
                                  bodyWidget: Column(
                                    children: [
                                      InkWell(
                                        onTap: () {
                                          openExaminationList(context);
                                        },
                                        child: Container(
                                          padding: EdgeInsets.symmetric(
                                              vertical: 8, horizontal: 8.0),
                                          margin:
                                              EdgeInsets.symmetric(vertical: 8),
                                          decoration: BoxDecoration(
                                            border: Border.all(
                                                color: Colors.grey.shade400,
                                                width: 0.5),
                                            borderRadius: BorderRadius.all(
                                              Radius.circular(8),
                                            ),
                                            color: Colors.white,
                                          ),
                                          child: Row(
                                            mainAxisAlignment:
                                                MainAxisAlignment.spaceBetween,
                                            crossAxisAlignment:
                                                CrossAxisAlignment.center,
                                            children: [
                                              Expanded(
                                                  child: Column(
                                                crossAxisAlignment:
                                                    CrossAxisAlignment.start,
                                                children: [
                                                  AppText(
                                                    "${TranslationBase.of(context).addExamination}",
                                                    fontSize: SizeConfig
                                                            .textMultiplier *
                                                        1.8,
                                                    color: Colors.black,
                                                    fontWeight: FontWeight.bold,
                                                  ),
                                                  AppText(
                                                    "${TranslationBase.of(context).searchHere}",
                                                    fontSize: SizeConfig
                                                            .textMultiplier *
                                                        1.8,
                                                    color: Colors.grey.shade700,
                                                    fontWeight: FontWeight.bold,
                                                  ),
                                                ],
                                              )),
                                              Icon(
                                                Icons.add_box_rounded,
                                                size: 25,
                                              )
                                            ],
                                          ),
                                        ),
                                      ),
                                      /* ...List.generate(
                                          widget.mySelectedExamination.length,
                                              (index) => Container(
                                            child: ExaminationIitemCard(
                                                widget.mySelectedExamination[
                                                index], () {
                                              removeExamination(widget
                                                  .mySelectedExamination[
                                              index]
                                                  .selectedExamination);
                                            }),
                                          )),*/
                                      Column(
                                        children: widget.mySelectedExamination
                                            .map((examination) {
                                          return ExaminationIitemCard(
                                              examination, () {
                                            removeExamination(examination
                                                .selectedExamination);
                                          });
                                        }).toList(),
                                      )
                                    ],
                                  ),
                                  isExpand: isSysExaminationExpand,
                                ),
                              ],
                            ),
                          ),
                        ),
                      ),
                    ),
                  ),
                ),
                Container(
                  margin: EdgeInsets.symmetric(horizontal: 16, vertical: 8),
                  child: Row(
                    children: [
                      Expanded(
                        child: AppButton(
                          title: TranslationBase.of(context).previous,
                          color: HexColor("#EAEAEA"),
                          fontColor: Colors.black,
                          onPressed: () {
                            widget.changePageViewIndex(0);
                          },
                        ),
                      ),
                      SizedBox(
                        width: 10,
                      ),
                      Expanded(
                        child: AppButton(
                          title: TranslationBase.of(context).next,
                          loading: model.state == ViewState.BusyLocal,
                          color: widget.mySelectedExamination != null &&
                              widget.mySelectedExamination.length > 0
                              ? HexColor("#D02127")
                              : HexColor("#A5A5A5"),
                          fontColor: widget.mySelectedExamination != null &&
                          widget.mySelectedExamination.length > 0 ? Colors.white : HexColor("#5A5A5A"),
                          disabled: widget.mySelectedExamination != null &&
                                  widget.mySelectedExamination.length > 0
                              ? false
                              : true,
                          fontWeight: FontWeight.bold,
                          onPressed: () async {
                            await submitUpdateObjectivePage(model);
                          },
                        ),
                      ),
                    ],
                  ),
                ),
              ],
            )));
  }

  submitUpdateObjectivePage(SOAPViewModel model) async {
    if (widget.mySelectedExamination.isNotEmpty) {
      Map profile = await sharedPref.getObj(DOCTOR_PROFILE);

      DoctorProfileModel doctorProfile = DoctorProfileModel.fromJson(profile);
      PostPhysicalExamRequestModel postPhysicalExamRequestModel =
          new PostPhysicalExamRequestModel();
      widget.mySelectedExamination.forEach((exam) {
        if (postPhysicalExamRequestModel.listHisProgNotePhysicalExaminationVM ==
            null)
          postPhysicalExamRequestModel.listHisProgNotePhysicalExaminationVM =
              [];

        postPhysicalExamRequestModel.listHisProgNotePhysicalExaminationVM
            .add(ListHisProgNotePhysicalExaminationVM(
                patientMRN: widget.patientInfo.patientMRN,
                episodeId: widget.patientInfo.episodeNo,
                appointmentNo: widget.patientInfo.appointmentNo,
                remarks: exam.remark ?? '',
                createdBy: exam.createdBy ?? doctorProfile.doctorID,
                createdOn: DateTime.now().toIso8601String(),
                editedBy: doctorProfile.doctorID,
                editedOn: DateTime.now().toIso8601String(),
                examId: exam.selectedExamination.id,
                examType: exam.selectedExamination.typeId,
                isAbnormal: exam.isAbnormal,
                isNormal: exam.isNormal,
                // masterDescription: exam.selectedExamination,
                notExamined: exam.notExamined,
                examinationType: exam.isNormal
                    ? 1
                    : exam.isAbnormal
                        ? 2
                        : 3,
                examinationTypeName: exam.isNormal
                    ? "Normal"
                    : exam.isAbnormal
                        ? 'AbNormal'
                        : "Not Examined",
                isNew: exam.isNew));
      });

      if (model.patientPhysicalExamList.isEmpty) {
        await model.postPhysicalExam(postPhysicalExamRequestModel);
      } else {
        await model.patchPhysicalExam(postPhysicalExamRequestModel);
      }

      if (model.state == ViewState.ErrorLocal) {
        helpers.showErrorToast(model.error);
      } else {
        widget.changeLoadingState(true);

        widget.changePageViewIndex(2);
      }
    } else {
      // widget.changeLoadingState(true);
      //
      // widget.changePageViewIndex(2);

      helpers.showErrorToast(TranslationBase.of(context).examinationErrorMsg);
    }
  }

  removeExamination(MasterKeyModel masterKey) {
    Iterable<MySelectedExamination> history = widget.mySelectedExamination
        .where((element) =>
            masterKey.id == element.selectedExamination.id &&
            masterKey.typeId == element.selectedExamination.typeId);

    if (history.length > 0)
      setState(() {
        widget.mySelectedExamination.remove(history.first);
      });
  }

  openExaminationList(BuildContext context) {
    Navigator.push(
      context,
      FadePage(
        page: AddExaminationPage(
            mySelectedExamination: widget.mySelectedExamination,
            addSelectedExamination: () {
              setState(() {
                Navigator.of(context).pop();
              });
            },
            removeExamination: (masterKey) => removeExamination(masterKey)),
      ),
    );
    /*showModalBottomSheet(
        backgroundColor: Colors.white,
        isScrollControlled: true,
        context: context,
        builder: (context) {
          return AddExaminationDailog(
            mySelectedExamination: widget.mySelectedExamination,
            addSelectedExamination: () {
              setState(() {
                Navigator.of(context).pop();
              });
            },
            removeExamination: (masterKey) => removeExamination(masterKey),
          );
        });*/
  }
}

class AddExaminationDailog extends StatefulWidget {
  final List<MySelectedExamination> mySelectedExamination;
  final Function addSelectedExamination;
  final Function(MasterKeyModel) removeExamination;

  const AddExaminationDailog(
      {Key key,
      this.mySelectedExamination,
      this.addSelectedExamination,
      this.removeExamination})
      : super(key: key);

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

class _AddExaminationDailogState extends State<AddExaminationDailog> {
  @override
  Widget build(BuildContext context) {
    return FractionallySizedBox(
      heightFactor: 0.7,
      child: BaseView<SOAPViewModel>(
          onModelReady: (model) async {
            if (model.physicalExaminationList.length == 0) {
              await model
                  .getMasterLookup(MasterKeysService.PhysicalExamination);
            }
          },
          builder: (_, model, w) => AppScaffold(
                baseViewModel: model,
                isShowAppBar: false,
                body: Center(
                    child: Container(
                        child: FractionallySizedBox(
                  widthFactor: 0.9,
                  child: Column(
                      crossAxisAlignment: CrossAxisAlignment.start,
                      children: [
                        SizedBox(
                          height: 16,
                        ),
                        AppText(
                          TranslationBase.of(context).physicalSystemExamination,
                          fontWeight: FontWeight.bold,
                          fontSize: 16,
                        ),
                        SizedBox(
                          height: 16,
                        ),
                        /*MasterKeyCheckboxSearchWidget(
                          model: model,
                          hintSearchText:
                              TranslationBase.of(context).searchExamination,
                          buttonName:
                              TranslationBase.of(context).addExamination,
                          masterList: model.physicalExaminationList,
                          removeHistory: (history) {
                            setState(() {
                              widget.removeExamination(history);
                            });
                          },
                          addHistory: (history) {
                            setState(() {
                              MySelectedExamination mySelectedExamination =
                                  new MySelectedExamination(
                                      selectedExamination: history);
                              widget.mySelectedExamination
                                  .add(mySelectedExamination);
                            });
                          },
                          addSelectedHistories: () {
                            widget.addSelectedExamination();
                          },
                          isServiceSelected: (master) =>
                              isServiceSelected(master),
                        ),*/
                      ]),
                ))),
              )),
    );
  }
}
