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/viewModel/SOAP_view_model.dart';
import 'package:doctor_app_flutter/core/viewModel/project_view_model.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/screens/base/base_view.dart';
import 'package:doctor_app_flutter/util/translations_delegate_base.dart';
import 'package:doctor_app_flutter/widgets/shared/app-textfield-custom.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/borderedButton.dart';
import 'package:doctor_app_flutter/widgets/shared/divider_with_spaces_around.dart';
import 'package:doctor_app_flutter/widgets/shared/expandable-widget-header-body.dart';
import 'package:flutter/material.dart';
import 'package:hexcolor/hexcolor.dart';
import 'package:provider/provider.dart';

// Author Mosa Abuzaid

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

  AddExaminationPage(
      {this.mySelectedExamination,
      this.addSelectedExamination,
      this.removeExamination});

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

class _AddExaminationPageState extends State<AddExaminationPage> {
  @override
  Widget build(BuildContext context) {
    return BaseView<SOAPViewModel>(
      onModelReady: (model) async {
        if (model.physicalExaminationList.length == 0) {
          await model.getMasterLookup(MasterKeysService.PhysicalExamination);
        }
      },
      builder: (_, model, w) => AppScaffold(
        baseViewModel: model,
        isShowAppBar: false,
        backgroundColor: Color.fromRGBO(248, 248, 248, 1),
        body: Column(
          mainAxisAlignment: MainAxisAlignment.start,
          children: [
            Container(
              padding:
                  EdgeInsets.only(left: 16, top: 70, right: 16, bottom: 16),
              color: Colors.white,
              child: Row(
                mainAxisAlignment: MainAxisAlignment.spaceBetween,
                crossAxisAlignment: CrossAxisAlignment.center,
                children: [
                  Expanded(
                    child: AppText(
                      "${TranslationBase.of(context).addExamination}",
                      fontSize: SizeConfig.textMultiplier * 3.3,
                      color: Colors.black,
                      fontWeight: FontWeight.w700,
                    ),
                  ),
                  InkWell(
                    onTap: () {
                      Navigator.of(context).pop();
                    },
                    child: Icon(
                      Icons.clear,
                      size: 40,
                    ),
                  )
                ],
              ),
            ),
            Expanded(
              child: SingleChildScrollView(
                child: Column(
                  children: [
                    Container(
                      margin: EdgeInsets.all(16.0),
                      padding: EdgeInsets.all(0.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(
                        children: [
                          ExaminationsListSearchWidget(
                            masterList: model.physicalExaminationList,
                            isServiceSelected: (master) =>
                                isServiceSelected(master),
                            removeHistory: (history) {
                              setState(() {
                                widget.removeExamination(history);
                              });
                            },
                            addHistory: (selectedExamination) {
                              setState(() {
                                widget.mySelectedExamination
                                    .add(selectedExamination);
                              });
                            },
                          ),
                        ],
                      ),
                    ),
                  ],
                ),
              ),
            ),
            Container(
              padding: EdgeInsets.all(16),
              color: Colors.white,
              child: BorderedButton(
                "${TranslationBase.of(context).addExamination}",
                backgroundColor: HexColor("#359846"),
                textColor: Colors.white,
                vPadding: 12,
                radius: 12,
                fontWeight: FontWeight.w600,
                fontSize: SizeConfig.textMultiplier * 2.5,
                fontFamily: 'Poppins',
                handler: () {
                  widget.addSelectedExamination();
                },
              ),
            )
          ],
        ),
      ),
    );
  }

  isServiceSelected(MasterKeyModel masterKey) {
    Iterable<MySelectedExamination> exam = widget.mySelectedExamination.where(
        (element) =>
            masterKey.id == element.selectedExamination.id &&
            masterKey.typeId == element.selectedExamination.typeId);
    if (exam.length > 0) {
      return true;
    }
    return false;
  }
}

class ExaminationsListSearchWidget extends StatefulWidget {
  final Function(MasterKeyModel) removeHistory;
  final Function(MySelectedExamination) addHistory;
  final bool Function(MasterKeyModel) isServiceSelected;
  final List<MasterKeyModel> masterList;

  ExaminationsListSearchWidget(
      {this.removeHistory,
      this.addHistory,
      this.isServiceSelected,
      this.masterList});

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

class _ExaminationsListSearchWidgetState
    extends State<ExaminationsListSearchWidget> {
  int expandedIndex = -1;
  List<MasterKeyModel> items = List();
  TextEditingController filteredSearchController = TextEditingController();

  @override
  void initState() {
    items.addAll(widget.masterList);
    super.initState();
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children: [
        AppTextFieldCustom(
          height: MediaQuery.of(context).size.height * 0.080,
          hintText: TranslationBase.of(context).searchExamination,
          isDropDown: true,
          hasBorder: false,
          controller: filteredSearchController,
          onChanged: (value) {
            filterSearchResults(value);
          },
          suffixIcon: Icon(
            Icons.search,
            color: Colors.black,
          ),
        ),
        DividerWithSpacesAround(
          height: 2,
        ),
        ...items.mapIndexed((index, item) {
          return AddExaminationWidget(
            item: item,
            addHistory: widget.addHistory,
            removeHistory: widget.removeHistory,
            isServiceSelected: widget.isServiceSelected,
            isExpand: index == expandedIndex,
            expandClick: () {
              setState(() {
                if (expandedIndex == index) {
                  expandedIndex = -1;
                } else {
                  expandedIndex = index;
                }
              });
            },
          );
        }).toList(),
      ],
    );
  }

  void filterSearchResults(String query) {
    List<MasterKeyModel> dummySearchList = List();
    dummySearchList.addAll(widget.masterList);
    if (query.isNotEmpty) {
      List<MasterKeyModel> dummyListData = List();
      dummySearchList.forEach((item) {
        if (item.nameAr.toLowerCase().contains(query.toLowerCase()) ||
            item.nameEn.toLowerCase().contains(query.toLowerCase())) {
          dummyListData.add(item);
        }
      });
      setState(() {
        items.clear();
        items.addAll(dummyListData);
      });
      return;
    } else {
      setState(() {
        items.clear();
        items.addAll(widget.masterList);
      });
    }
  }
}

class AddExaminationWidget extends StatefulWidget {
  MasterKeyModel item;
  final Function(MasterKeyModel) removeHistory;
  final Function(MySelectedExamination) addHistory;
  final bool Function(MasterKeyModel) isServiceSelected;
  bool isExpand;
  final Function expandClick;

  AddExaminationWidget({
    this.item,
    this.removeHistory,
    this.addHistory,
    this.isServiceSelected,
    this.isExpand,
    this.expandClick,
  });

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

class _AddExaminationWidgetState extends State<AddExaminationWidget> {
  int status = 3;
  TextEditingController remarksController = TextEditingController();
  MySelectedExamination examination = MySelectedExamination();

  @override
  void initState() {

    examination.selectedExamination = widget.item;
    super.initState();
  }
  @override
  Widget build(BuildContext context) {
    ProjectViewModel projectViewModel = Provider.of(context);

    return Container(
      child: HeaderBodyExpandableNotifier(
        headerWidget: Row(
          mainAxisAlignment: MainAxisAlignment.spaceBetween,
          children: [
            Expanded(
              child: CheckboxListTile(
                title: AppText(
                  projectViewModel.isArabic
                      ? widget.item.nameAr != null && widget.item.nameAr != ""
                          ? widget.item.nameAr
                          : widget.item.nameEn
                      : widget.item.nameEn,
                  fontWeight: FontWeight.normal,
                  fontFamily: 'Poppins',
                  fontSize: SizeConfig.textMultiplier * 2.0,
                ),
                value: widget.isServiceSelected(widget.item),
                activeColor: HexColor("#D02127"),
                onChanged: (newValue) {
                  setState(() {
                    if (widget.isServiceSelected(widget.item)) {
                      widget.removeHistory(widget.item);
                      widget.expandClick();
                    } else {
                      examination.isNormal = status == 1;
                      examination.isAbnormal = status == 2;
                      examination.notExamined = status == 3;
                      examination.remark = remarksController.text;
                      widget.addHistory(examination);
                      widget.expandClick();
                    }
                  });
                },
                controlAffinity: ListTileControlAffinity.leading,
                contentPadding: EdgeInsets.all(0),
              ),
            ),
            Container(
              margin: EdgeInsets.symmetric(horizontal: 8),
              child: InkWell(
                  onTap: widget.expandClick,
                  child: Icon(widget.isExpand
                      ? Icons.keyboard_arrow_up
                      : Icons.keyboard_arrow_down)),
            ),
          ],
        ),
        bodyWidget: Container(
          padding: EdgeInsets.symmetric(horizontal: 12),
          child: Column(
            crossAxisAlignment: CrossAxisAlignment.start,
            children: [
              Container(
                margin: EdgeInsets.only(bottom: 8),
                child: AppText(
                  TranslationBase.of(context).status,
                  fontWeight: FontWeight.bold,
                  fontFamily: 'Poppins',
                  fontSize: SizeConfig.textMultiplier * 1.6,
                ),
              ),
              Row(
                children: [
                  Expanded(
                      child: Row(
                    children: [
                      InkWell(
                        onTap: () {
                          setState(() {
                            status = 1;
                          });
                          examination.isNormal = true;
                          examination.isAbnormal = false;
                          examination.notExamined = false;
                        },
                        child: Container(
                          padding: EdgeInsets.all(2.0),
                          margin: EdgeInsets.symmetric(horizontal: 6),
                          width: 20,
                          height: 20,
                          decoration: BoxDecoration(
                            color: Colors.white,
                            shape: BoxShape.circle,
                            border: Border.all(color: Colors.grey, width: 1),
                          ),
                          child: Container(
                            decoration: BoxDecoration(
                              color: status == 1
                                  ? HexColor("#D02127")
                                  : Colors.white,
                              shape: BoxShape.circle,
                            ),
                          ),
                        ),
                      ),
                      AppText(
                        TranslationBase.of(context).normal,
                        fontWeight: FontWeight.normal,
                        fontFamily: 'Poppins',
                        fontSize: SizeConfig.textMultiplier * 1.6,
                      ),
                    ],
                  )),
                  Expanded(
                      child: Row(
                    children: [
                      InkWell(
                        onTap: () {
                          setState(() {
                            status = 2;
                          });
                          examination.isNormal = false;
                          examination.isAbnormal = true;
                          examination.notExamined = false;
                        },
                        child: Container(
                          padding: EdgeInsets.all(2.0),
                          margin: EdgeInsets.symmetric(horizontal: 6),
                          width: 20,
                          height: 20,
                          decoration: BoxDecoration(
                            color: Colors.white,
                            shape: BoxShape.circle,
                            border: Border.all(color: Colors.grey, width: 1),
                          ),
                          child: Container(
                            decoration: BoxDecoration(
                              color: status == 2
                                  ? HexColor("#D02127")
                                  : Colors.white,
                              shape: BoxShape.circle,
                            ),
                          ),
                        ),
                      ),
                      AppText(
                        TranslationBase.of(context).abnormal,
                        fontWeight: FontWeight.normal,
                        fontFamily: 'Poppins',
                        fontSize: SizeConfig.textMultiplier * 1.6,
                      ),
                    ],
                  )),
                  Expanded(
                      child: Row(
                    children: [
                      InkWell(
                        onTap: () {
                          setState(() {
                            status = 3;
                          });
                          examination.isNormal = false;
                          examination.isAbnormal = false;
                          examination.notExamined = true;
                        },
                        child: Container(
                          padding: EdgeInsets.all(2.0),
                          margin: EdgeInsets.symmetric(horizontal: 6),
                          width: 20,
                          height: 20,
                          decoration: BoxDecoration(
                            color: Colors.white,
                            shape: BoxShape.circle,
                            border: Border.all(color: Colors.grey, width: 1),
                          ),
                          child: Container(
                            decoration: BoxDecoration(
                              color: status == 3
                                  ? HexColor("#D02127")
                                  : Colors.white,
                              shape: BoxShape.circle,
                            ),
                          ),
                        ),
                      ),
                      Expanded(
                        child: AppText(
                          TranslationBase.of(context).notExamined,
                          fontWeight: FontWeight.normal,
                          fontFamily: 'Poppins',
                          fontSize: SizeConfig.textMultiplier * 1.6,
                        ),
                      ),
                    ],
                  )),
                ],
              ),
              Container(
                margin: EdgeInsets.only(top: 8),
                child: AppTextFieldCustom(
                  hintText: TranslationBase.of(context).remarks,
                  controller: remarksController,
                  minLines: 2,
                  maxLines: 4,
                  inputType: TextInputType.multiline,
                  onChanged: (value){
                    examination.remark = value;
                  },
                ),
              ),
            ],
          ),
        ),
        isExpand: widget.isExpand,
      ),
    );
  }
}

extension FicListExtension<T> on List<T> {
  /// Maps each element of the list.
  /// The [map] function gets both the original [item] and its [index].
  Iterable<E> mapIndexed<E>(E Function(int index, T item) map) sync* {
    for (var index = 0; index < length; index++) {
      yield map(index, this[index]);
    }
  }
}
