import 'dart:async';

import 'package:doctor_app_flutter/core/enum/viewstate.dart';
import 'package:doctor_app_flutter/core/service/AnalyticsService.dart';
import 'package:doctor_app_flutter/core/service/VideoCallService.dart';
import 'package:doctor_app_flutter/core/viewModel/LiveCarePatientViewModel.dart';
import 'package:doctor_app_flutter/core/viewModel/SOAP_view_model.dart';
import 'package:doctor_app_flutter/models/SOAP/PostEpisodeReqModel.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/screens/live_care/end_call_screen.dart';
import 'package:doctor_app_flutter/screens/patients/profile/profile_screen/profile_gird_for_InPatient.dart';
import 'package:doctor_app_flutter/screens/patients/profile/profile_screen/profile_gird_for_other.dart';
import 'package:doctor_app_flutter/screens/patients/profile/profile_screen/profile_gird_for_search.dart';
import 'package:doctor_app_flutter/util/NotificationPermissionUtils.dart';
import 'package:doctor_app_flutter/util/helpers.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/buttons/app_buttons_widget.dart';
import 'package:doctor_app_flutter/widgets/shared/loader/gif_loader_dialog_utils.dart';
import 'package:flutter/material.dart';
import 'package:hexcolor/hexcolor.dart';
import 'package:quiver/async.dart';

import '../../../../locator.dart';
import '../../../../routes.dart';

class PatientProfileScreen extends StatefulWidget {
  @override
  _PatientProfileScreenState createState() => _PatientProfileScreenState();
}

class _PatientProfileScreenState extends State<PatientProfileScreen> with SingleTickerProviderStateMixin {
  PatiantInformtion patient;
  LiveCarePatientViewModel _liveCareViewModel = LiveCarePatientViewModel();

  bool isFromSearch = false;
  bool isFromLiveCare = false;

  bool isInpatient = false;
  bool isMyPatient = false;
  bool isCallFinished = false;
  bool isDischargedPatient = false;
  bool isSearchAndOut = false;
  bool isCallStarted = false;
  String patientType;
  String arrivalType;
  String from;
  String to;
  TabController _tabController;
  int index = 0;
  int _activeTab = 0;

  StreamController<String> videoCallDurationStreamController;
  Stream<String> videoCallDurationStream = (() async* {})();
  @override
  void initState() {
    _tabController = TabController(length: 2, vsync: this);
    super.initState();
    videoCallDurationStreamController = StreamController();
    videoCallDurationStream = videoCallDurationStreamController.stream;
  }

  @override
  void dispose() {
    _tabController.dispose();
    super.dispose();
    if (isFromLiveCare) {
      _liveCareViewModel.removePatientFromDoctorList(patient.vcId);
    }
  }

  @override
  void didChangeDependencies() {
    super.didChangeDependencies();
    final routeArgs = ModalRoute.of(context).settings.arguments as Map;
    patient = routeArgs['patient'];
    patientType = routeArgs['patientType'];
    arrivalType = routeArgs['arrivalType'];
    from = routeArgs['from'];
    to = routeArgs['to'];
    if (routeArgs.containsKey("isSearch")) {
      isFromSearch = routeArgs['isSearch'];
    }
    if (routeArgs.containsKey("isInpatient")) {
      isInpatient = routeArgs['isInpatient'];
    }
    if (routeArgs.containsKey("isDischargedPatient")) {
      isDischargedPatient = routeArgs['isDischargedPatient'];
    }
    if (routeArgs.containsKey("isSearchAndOut")) {
      isSearchAndOut = routeArgs['isSearchAndOut'];
    }
    if (routeArgs.containsKey("isFromLiveCare")) {
      isFromLiveCare = routeArgs['isFromLiveCare'];
    }
    if (routeArgs.containsKey("isCallFinished")) {
      isCallFinished = routeArgs['isCallFinished'];
    }
    if (routeArgs.containsKey("isMyPatient")) {
      isMyPatient = routeArgs['isMyPatient'];
    }
    if (isInpatient)
      _activeTab = 0;
    else
      _activeTab = 1;
  }

  StreamSubscription callTimer;
  callConnected() {
    callTimer = CountdownTimer(Duration(minutes: 90), Duration(seconds: 1)).listen(null)
      ..onDone(() {
        callTimer.cancel();
      })
      ..onData((data) {
        var t = Helpers.timeFrom(duration: data.elapsed);
        videoCallDurationStreamController.sink.add(t);
      });
  }

  callDisconnected() {
    callTimer.cancel();
    videoCallDurationStreamController.sink.add(null);

    setState(() {
      isCallStarted = false;
    });
  }

  @override
  Widget build(BuildContext context) {
    final screenSize = MediaQuery.of(context).size;
    return BaseView<LiveCarePatientViewModel>(
      onModelReady: (model) async {
        if (isFromLiveCare && patient.patientStatus == 1) await model.addPatientToDoctorList(patient.vcId);
      },
      builder: (_, model, w) => AppScaffold(

        baseViewModel: model,

        appBarTitle: TranslationBase.of(context).patientProfile,
        isShowAppBar: false,
        body: Column(
          children: [
            Stack(
              children: [
                Column(
                  children: [
                    PatientProfileHeaderNewDesignAppBar(patient, arrivalType ?? '0', patientType,
                        videoCallDurationStream: videoCallDurationStream,
                        isInpatient: isInpatient,
                        isFromLiveCare: isFromLiveCare,
                        height: (patient.patientStatusType != null && patient.patientStatusType == 43)
                            ? 210
                            : isDischargedPatient
                                ? 240
                                : 0,
                        isDischargedPatient: isDischargedPatient),
                    Container(
                      height: !isSearchAndOut
                          ? isDischargedPatient
                              ? MediaQuery.of(context).size.height * 0.64
                              : MediaQuery.of(context).size.height * 0.65
                          : MediaQuery.of(context).size.height * 0.69,
                      child: ListView(
                        children: [
                          Container(
                            child: isSearchAndOut
                                ? ProfileGridForSearch(
                                    patient: patient,
                                    patientType: patientType,
                                    arrivalType: arrivalType,
                                    isInpatient: isInpatient,
                                    from: from,
                                    to: to,
                                  )
                                : isInpatient
                                    ? ProfileGridForInPatient(
                                        patient: patient,
                                        patientType: patientType,
                                        arrivalType: arrivalType,
                                        isInpatient: isInpatient,
                                        from: from,
                                        to: to,
                                        isDischargedPatient: isDischargedPatient,
                                        isFromSearch: isFromSearch,
                                      )
                                    : ProfileGridForOther(
                                        patient: patient,
                                        patientType: patientType,
                                        arrivalType: arrivalType,
                                        isInpatient: isInpatient,
                                        isFromLiveCare: isFromLiveCare,
                                        from: from,
                                        to: to,
                                      ),
                          ),
                          SizedBox(
                            height: MediaQuery.of(context).size.height * 0.05,
                          )
                        ],
                      ),
                    ),
                  ],
                ),
                if ( (isInpatient && isMyPatient )? true:isFromLiveCare
                    ? patient.episodeNo != null
                    : patient.patientStatusType != null && patient.patientStatusType == 43)
                  BaseView<SOAPViewModel>(
                      onModelReady: (model) async {
                        model.getDoctorProfile();
                      },
                      builder: (_, model, w) => Positioned(
                            top: 180,
                            left: 20,
                            right: 20,
                            child: Row(
                              children: [
                                Expanded(child: Container()),
                                if (patient.episodeNo == 0)
                                  AppButton(
                                    title:
                                        "${TranslationBase.of(context).createNew}\n${TranslationBase.of(context).episode}",
                                    color: isFromLiveCare
                                        ? Colors.red.shade700
                                        : patient.patientStatusType == 43
                                            ? Colors.red.shade700
                                            : Colors.grey.shade700,
                                    fontColor: Colors.white,
                                    vPadding: 8,
                                    radius: 30,
                                    hPadding: 20,
                                    fontWeight: FontWeight.normal,
                                    fontSize: 1.6,
                                    icon: Image.asset(
                                      "assets/images/create-episod.png",
                                      color: Colors.white,
                                      height: 30,
                                    ),
                                    onPressed: () async {
                                      if ((isFromLiveCare && patient.appointmentNo != null) ||
                                          patient.patientStatusType == 43) {
                                        await locator<AnalyticsService>().logEvent(
                                          eventCategory: "Patient Profile",
                                          eventAction: "Create Episode",
                                        );
                                        PostEpisodeReqModel postEpisodeReqModel = PostEpisodeReqModel(
                                            appointmentNo: int.parse(patient.appointmentNo.toString()),
                                            patientMRN: patient.patientMRN);
                                        GifLoaderDialogUtils.showMyDialog(context);
                                        await model.postEpisode(postEpisodeReqModel);
                                        GifLoaderDialogUtils.hideDialog(context);
                                        patient.episodeNo = model.episodeID;
                                        Navigator.of(context)
                                            .pushNamed(CREATE_EPISODE, arguments: {'patient': patient});
                                      }
                                    },
                                  ),
                                if (patient.episodeNo != 0)
                                  AppButton(
                                      title:
                                          "${TranslationBase.of(context).update}\n${TranslationBase.of(context).episode}",
                                      color: (isInpatient &&isMyPatient ) || isFromLiveCare
                                          ? Colors.red.shade700
                                          : patient.patientStatusType == 43
                                              ? Colors.red.shade700
                                              : Colors.grey.shade700,
                                      fontColor: Colors.white,
                                      vPadding: 8,
                                      radius: 30,
                                      hPadding: 20,
                                      fontWeight: FontWeight.normal,
                                      fontSize: 1.6,
                                      icon: Image.asset(
                                        "assets/images/modilfy-episode.png",
                                        color: Colors.white,
                                        height: 30,
                                      ),
                                      onPressed: () async {
                                        await locator<AnalyticsService>().logEvent(
                                          eventCategory: "Patient Profile ",
                                          eventAction: "Update Episode",
                                        );
                                        if ((isFromLiveCare &&
                                                patient.appointmentNo != null &&
                                                patient.appointmentNo != 0) ||
                                            patient.patientStatusType == 43 ||isInpatient ) {
                                          Navigator.of(context)
                                              .pushNamed(UPDATE_EPISODE, arguments: {'patient': patient});
                                        }
                                      }),
                              ],
                            ),
                          )),
              ],
            ),
          ],
        ),
        bottomSheet: isFromLiveCare
            ? Container(
                decoration: BoxDecoration(
                  color: Colors.white,
                  borderRadius: BorderRadius.all(
                    Radius.circular(0.0),
                  ),
                  border: Border.all(color: HexColor('#707070'), width: 0),
                ),
                height: MediaQuery.of(context).size.height * 0.1,
                width: double.infinity,
                child: Column(
                  children: [
                    SizedBox(
                      height: 10,
                    ),
                    Container(
                      child: FractionallySizedBox(
                        widthFactor: .80,
                        child: Center(
                          child: AppButton(
                            fontWeight: FontWeight.w700,
                            color: isCallFinished ? Colors.red[600] : Colors.green[600],
                            title: isCallFinished
                                ? TranslationBase.of(context).endCall
                                : TranslationBase.of(context).initiateCall,
                            disabled: isCallStarted || model.state == ViewState.BusyLocal,
                            onPressed: () async {
                              // TODO MOSA TEST
                              // AppPermissionsUtils
                              //     .requestVideoCallPermission(
                              //     context: context,
                              //     onTapGrant: () {
                              //       locator<VideoCallService>()
                              //           .openVideo(
                              //           model.startCallRes,
                              //           patient,
                              //           model.startCallRes != null ? model.startCallRes.isRecording : true, callConnected,
                              //           callDisconnected);
                              //     });
                              if (isCallFinished) {
                                Navigator.push(
                                    context,
                                    MaterialPageRoute(
                                        builder: (BuildContext context) => EndCallScreen(patient: patient),settings: RouteSettings(name: 'EndCallScreen'),),);
                              } else {
                                GifLoaderDialogUtils.showMyDialog(context);
                                await model.startCall(isReCall: false, vCID: patient.vcId);

                                if (model.state == ViewState.ErrorLocal) {
                                  GifLoaderDialogUtils.hideDialog(context);
                                  Helpers.showErrorToast(model.error);
                                } else {
                                  await model.getDoctorProfile();
                                  patient.appointmentNo = int.parse(model.startCallRes.appointmentNo.toString());
                                  patient.episodeNo = 0;
                                  model.updateInCallPatient(
                                      patient: patient,
                                      appointmentNo: int.parse(model.startCallRes.appointmentNo.toString()));
                                  setState(() {
                                    isCallStarted = true;
                                  });
                                  GifLoaderDialogUtils.hideDialog(context);
                                  AppPermissionsUtils.requestVideoCallPermission(
                                      context: context,
                                      onTapGrant: () {
                                        locator<VideoCallService>().openVideo(
                                            model.startCallRes,
                                            patient,
                                            model.startCallRes != null ? model.startCallRes.isRecording : true,
                                            callConnected,
                                            callDisconnected);
                                      });
                                }
                              }
                            },
                          ),
                        ),
                      ),
                    ),
                    SizedBox(
                      height: 5,
                    ),
                  ],
                ),
              )
            : null,
      ),
    );
  }
}

class AvatarWidget extends StatelessWidget {
  final Widget avatarIcon;

  AvatarWidget(this.avatarIcon);

  @override
  Widget build(BuildContext context) {
    return Container(
      decoration: BoxDecoration(
        boxShadow: [BoxShadow(color: Color.fromRGBO(0, 0, 0, 0.08), offset: Offset(0.0, 5.0), blurRadius: 16.0)],
        borderRadius: BorderRadius.all(Radius.circular(35.0)),
        color: Color(0xffCCCCCC),
      ),
      child: avatarIcon,
    );
  }
}
