mohemm-flutter-app/lib/home/home_screen.dart

import 'dart:developer';

import 'package:connectivity/connectivity.dart';
import 'package:flutter/material.dart';
import 'package:queuing_system/core/api.dart';
import 'package:queuing_system/core/base/app_scaffold_widget.dart';
import 'package:queuing_system/core/config/config.dart';
import 'package:queuing_system/core/config/size_config.dart';
import 'package:queuing_system/core/response_model/patient_call.dart';
import 'package:queuing_system/header/app_header.dart';
import 'package:queuing_system/home/home_screen_components.dart';
import 'package:queuing_system/utils/call_by_voice.dart';
import 'package:queuing_system/utils/call_type.dart';
import 'package:queuing_system/utils/signalR_utils.dart';
import 'package:queuing_system/utils/utils.dart';
import 'package:queuing_system/widget/data_display/app_texts_widget.dart';

var DEVICE_IP = "10.10.15.11"; // Testing IP
// var DEVICE_IP = "10.10.14.11"; // Testing IP
// var DEVICE_IP = "10.10.15.11";

// var DEVICE_IP = "10.70.249.21"; // (Make sure by Haroon before use it) Production IP

class MyHomePage extends StatefulWidget {
  String title = "MyHomePage";

  @override
  State<MyHomePage> createState() => _MyHomePageState();
}

class _MyHomePageState extends State<MyHomePage> {
  SignalRHelper signalRHelper = SignalRHelper();

  List<Tickets> waitings = [];
  List<Tickets> isQueuePatients = [];

  bool isLoading = false;

  @override
  void dispose() {
    super.dispose();
  }

  @override
  void initState() {
    listenNetworkConnectivity();

    if (!signalRHelper.getConnectionState()) {
      signalRHelper.startSignalRConnection(DEVICE_IP, onUpdateAvailable: onUpdateAvailable, onConnect: onConnect, onConnecting: onConnecting, onDisconnect: onDisconnect);
    }

    super.initState();
  }

  TextEditingController controller = TextEditingController();

  @override
  Widget build(BuildContext context) {
    return AppScaffold(
      appBar: AppHeader(),
      body: content(),
      bottomNavigationBar: Container(
        color: Colors.grey.withOpacity(0.1),
        height: Utils.getHeight(),
        width: double.infinity,
        child: Row(
          crossAxisAlignment: CrossAxisAlignment.center,
          mainAxisAlignment: MainAxisAlignment.spaceBetween,
          children: [
            Row(
              children: [
                const SizedBox(width: 20),
                AppText(
                  "Powered By",
                  fontSize: SizeConfig.getWidthMultiplier() * 2.6,
                  fontFamily: 'Poppins-Medium.ttf',
                ),
                const SizedBox(width: 20),
                Image.asset(
                  "assets/images/cloud_logo.png",
                  height: SizeConfig.getHeightMultiplier() * 4,
                ),
              ],
            ),
            Row(
              children: [
                const SizedBox(width: 60),
                SizedBox(
                    width: 200,
                    child: TextField(
                      controller: controller,
                    )),
                const SizedBox(width: 30),
                isLoading
                    ? const CircularProgressIndicator()
                    : ElevatedButton(
                        onPressed: onUpdateIPPressed,
                        child: const Text(
                          "Update IP",
                          style: TextStyle(color: Colors.white),
                        ),
                        style: ElevatedButton.styleFrom(backgroundColor: AppGlobal.appRedColor),
                      ),
                const SizedBox(width: 30),
                Text("IP: $DEVICE_IP", style: const TextStyle(fontWeight: FontWeight.w600)),
                const SizedBox(width: 20),
              ],
            ),
          ],
        ),
      ),
    );
  }

  onUpdateIPPressed() async {
    // if (controller.text.isNotEmpty) {
    //   isLoading = true;
    //   setState(() {});
    //   DEVICE_IP = controller.text;
    //
    //   await signalRHelper.connection.stop();
    //   if (!signalRHelper.getConnectionState()) {
    //     await signalRHelper.startSignalRConnection(DEVICE_IP, onUpdateAvailable: onUpdateAvailable, onConnect: onConnect, onConnecting: onConnecting, onDisconnect: onDisconnect);
    //   }
    //
    //   controller.clear();
    //   waitings.clear();
    //   isLoading = false;
    //   setState(() {});
    // }
  }

  Widget content() {
    // waitings.removeAt(0);
    // waitings = waitings.sublist(0,3);
    voiceCall();

    if (waitings.isEmpty) {
      // No Patient in Queue
      return noPatientInQueue();
    } else if (waitings.length > 3) {
      // Return Content With Side List
      return priorityTicketsWithSideList(waitings);
    } else {
      // Return Content In Center Aligned
      return priorityTickets(waitings);
    }
  }

  String getCallTypeText(Tickets ticket) {
    final callType = ticket.getCallType();
    switch (callType) {
      case CallType.RECEPTION:
        return "Please Visit Doctor";
        break;
      case CallType.NURSE:
        return "Please Visit Nurse";
        break;
      case CallType.DOCTOR:
        return "Please Visit Doctor";
        break;
      case CallType.NONE:
        return "";
        break;
      default:
        return "";
    }
  }

  CallByVoice voiceCaller;
  int callFlag = 0;

  voiceCall() async {
    //TODO: After calling this voice call, we should delay for milliseconds that is given by API. After that we will check if there are more patients in isQueuePatients we will remove the patient from waiting list and then update the state

    if (waitings.isNotEmpty && voiceCaller == null) {
      final postVoice = getCallTypeText(waitings.first);
      voiceCaller = CallByVoice(waitings.first.callNoStr.toString(), preVoice: "Ticket Number", postVoice: postVoice, lang: 'en');
      await voiceCaller.startCalling();
      voiceCaller = null;
    }
    if (isQueuePatients.isNotEmpty) {
      await Future.delayed(Duration(milliseconds: int.parse(isQueuePatients.first.queueDuration) * 10)).whenComplete(() async {
        isQueuePatients.removeAt(0);
        Tickets ticket = waitings.elementAt(0);
        waitings.removeAt(0);
        waitings.add(ticket);
        if (isQueuePatients.isNotEmpty) {
          setState(() {});
        }
        if (isQueuePatients.isEmpty && callFlag == 1) {
          callFlag == 0;
          await Future.delayed(const Duration(seconds: 3));
        }
      });
    }
  }

  onUpdateAvailable(data) async {
    if (isQueuePatients.isNotEmpty && callFlag == 0) {
      callFlag = 1;
      return;
    }
    waitings.clear();
    API.getCallRequestInfoByClinicInfo(DEVICE_IP, onSuccess: (waitingCalls, isQueuePatientsCalls) {
      setState(() {
        waitings = waitingCalls;
        isQueuePatients = isQueuePatientsCalls;
        // currents = currentInClinic;
      });

      log("--------------------");
      log("waiting: $waitings");
      log("isQueuePatients: $isQueuePatients");
      log("--------------------");

      updateTickets();
    }, onFailure: (error) {});
  }

  updateTickets() {
    if (waitings != null && waitings.isNotEmpty) {
      List<Tickets> _ticketsToUpdate = waitings.where((t) => t.callUpdated == false).toList();
      API.callUpdateNotIsQueueRecordByIDAsync(DEVICE_IP, ticket: _ticketsToUpdate.first, onSuccess: (tickets_updated) {
        log("[${tickets_updated.length}] Tickets Updated: $tickets_updated");
      }, onFailure: (e) {
        log("API UPDate Tickets Failed with : ${e.toString()}");
      });
    }
  }

  onConnect() {
    log("SignalR: onConnect");
  }

  onDisconnect(exception) {
    log("SignalR: onDisconnect");
    // signalRHelper.startSignalRConnection(DEVICE_IP, onUpdateAvailable: onUpdateAvailable, onConnect: onConnect, onConnecting: onConnecting, onDisconnect: onDisconnect);
  }

  onConnecting() {
    log("SignalR: onConnecting");
  }

  listenNetworkConnectivity() async {
    Connectivity().onConnectivityChanged.listen((event) {
      switch (event) {
        case ConnectivityResult.wifi:
          signalRHelper.connection.start();
          break;
        case ConnectivityResult.none:
          signalRHelper.closeConnection(context);
          break;
        case ConnectivityResult.mobile:
          break;
      }
    });
  }
}