stadtbote-app/lib/content_views/task_list_page.dart

import 'dart:convert';

import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:intl/intl.dart';
import 'package:isar/isar.dart';
import 'package:stadtbote/content_views/utils/content_view_widget.dart';
import 'package:stadtbote/content_views/utils/header_info.dart';
import 'package:stadtbote/messages/pop_content_view_message.dart';
import 'package:stadtbote/model/job.dart';
import 'package:stadtbote/model/job_tour.dart';
import 'package:stadtbote/popups/tasks_popups/arrived_popup.dart';
import 'package:stadtbote/popups/tasks_popups/commision_number_popup.dart';
import 'package:stadtbote/popups/tasks_popups/pickup_delivery_status_popup.dart';
import 'package:stadtbote/popups/tasks_popups/receipt_giver_popup.dart';
import 'package:stadtbote/popups/tasks_popups/scan_barcodes_popup.dart';
import 'package:stadtbote/popups/tasks_popups/signature_popup.dart';
import 'package:stadtbote/popups/tasks_popups/station_notice_popup.dart';
import 'package:stadtbote/popups/tasks_popups/take_photos_popup.dart';
import 'package:stadtbote/protocoll_messages/accept_job_message.dart';
import 'package:stadtbote/protocoll_messages/fin_task_message.dart';
import 'package:stadtbote/protocoll_messages/fin_tour_message.dart';
import 'package:stadtbote/protocoll_messages/pic_message.dart';
import 'package:stadtbote/tools/constants.dart';
import 'package:stadtbote/tools/message_service.dart';
import 'package:stadtbote/tools/mqtt_core.dart';

import '../main.dart';
import '../model/task_info.dart';
import '../tools/util.dart';

class TaskListPage extends ContentViewWidget {
  const TaskListPage({super.key, required this.job, required this.tour, this.readOnly = false});

  final Job job;

  final JobTour tour;

  final bool readOnly;

  @override
  State<TaskListPage> createState() => _TaskListPageState();

  @override
  Future<HeaderInfo> getHeaderInfo(BuildContext context) async {
    return HeaderInfo(
        titleWidget: const Text(
          'Liste der Aufgaben',
          style: TextStyle(
            color: Colors.white,
            fontSize: 20.0,
          ),
        ),
        rightButtonEnabled: true,
        rightButtonVisible: true,
        rightButtonImage: Util.fetchFutureIcon(const Icon(Icons.help_outline, size: 20.0, color: Colors.white)),
        rightButtonOnPressed: () async {
          await Util.startBrowser('https://app.assecutor.de/help/sb/app/context/002/index.html');
        });
  }
}

class _TaskListPageState extends State<TaskListPage> {
  late bool _initCompleted = false;

  late List<TaskInfo> _taskList;

  List<Uint8List> _photos = [];

  late String _commisionNumber;

  @override
  void initState() {
    Future.delayed(const Duration(seconds: 0), () async {
      _taskList = await _fetchTaskList();

      _commisionNumber = widget.tour.com;

      _initCompleted = true;

      setState(() {});
    });

    super.initState();
  }

  @override
  Widget build(BuildContext context) {
    if (!_initCompleted) {
      return Util.getWaitWidget(context);
    }

   var steps = _initSteps();

    return Padding(
      padding: const EdgeInsets.all(8.0),
      child: SingleChildScrollView(
        scrollDirection: Axis.vertical,
        padding: const EdgeInsets.all(0),
        child: AbsorbPointer(
          absorbing: widget.readOnly,
          child: Column(
            children: [
              Visibility(
                visible: _commisionNumber.length > 0,
                child: Row(
                  children: [
                    Text('Komm-#: $_commisionNumber', style: const TextStyle(fontSize: 20), textAlign: TextAlign.left),
                  ],
                ),
              ),
              const SizedBox(height: 10),
              Column(
                crossAxisAlignment: CrossAxisAlignment.start,
                children: steps,
              ),
            ],
          ),
        ),
      ),
    );
  }

  List<Widget> _initSteps() {
    List<Widget> steps = [];
    for (int i=0; i<_taskList.length; i++) {
      var taskInfo = _taskList[i];

      var textColor = isTaskActive(i) ? Colors.black : const Color(0x33000000);

      var optional = taskInfo.task.opt != null && taskInfo.task.opt == true;
      steps.add(
        ListTile(
          minVerticalPadding: 0,
          title: Container(
            padding: const EdgeInsets.all(0),
            height: 60,
            child: Row(
              mainAxisAlignment: MainAxisAlignment.start,
              crossAxisAlignment: CrossAxisAlignment.stretch,
              children: <Widget>[
                Stack(
                  children: [
                    Positioned(
                      left: 16.5,
                      top: i == 0 ? 40 : 40,
                      child: Container(
                          height: i == widget.tour.tasks.length - 1 ? 0 : 20,
                          width: 6,
                          color: isTaskActive(i) ? Constants.colorPrimary : Constants.colorPrimaryOpaque,
                      ),
                    ),
                    Column(
                      children: [
                        Container(
                          width: 40,
                          height: 40,
                          decoration: BoxDecoration(
                            shape: BoxShape.circle,
                            color: isTaskActive(i) ? Constants.colorPrimary : Constants.colorPrimaryOpaque,
                          ),
                          child: const Icon(Icons.check, size: 30.0, color: Colors.white),
                        ),
                      ],
                    ),
                  ],
                ),
                const SizedBox(width: 20),
                Column(
                  crossAxisAlignment: CrossAxisAlignment.start,
                  mainAxisAlignment: MainAxisAlignment.start,
                  children: [
                    Text(
                      taskInfo.task.topic + (optional ? "" : " *"),
                      textAlign: TextAlign.left,
                      style: TextStyle(
                        color: textColor,
                        fontSize: 15.0,
                      ),
                    ),
                    const SizedBox(height: 5),
                    SizedBox(
                      width: MediaQuery.of(context).size.width * 0.7,
                      child: Text(
                        taskInfo.additionalText ?? '',
                        textAlign: TextAlign.left,
                        overflow: TextOverflow.ellipsis,
                        style: TextStyle(
                          color: textColor,
                          fontSize: 12.0,
                        ),
                      ),
                    ),
                  ],
                ),
              ],
            ),
          ),
          onTap: () {
            if (isTaskActive(i)) {
              _processTask(taskInfo);
            }
          },
        ),
      );
    }

    return steps;
  }

  Future<List<TaskInfo>> _fetchTaskList() async {
    List<TaskInfo> taskList = [];

    for(var task in widget.tour.tasks) {
      var taskInfo = await MyApp.isarInstance.taskInfos.filter().sIdEqualTo(task.sId).findFirst();
      if (taskInfo == null) {
        taskInfo = TaskInfo();
        taskInfo.id = await TaskInfo.getNextId();
        taskInfo.sId = task.sId;
        taskInfo.answer = null;
        taskInfo.additionalText = null;
        taskInfo.completed = task.opt != null ? task.opt! : false;
      }

      taskInfo.task = task;
      taskList.add(taskInfo);
    }

    return taskList;
  }

  void _processTask(TaskInfo taskInfo) {
    Util.logInfo("Process of Task \"${taskInfo.task.sId} started");

    switch(taskInfo.task.type) {
      case 2:
        _processSignature(taskInfo);
        break;

      case 3:
        _processTaskArrivedOrFinished(taskInfo);
        break;

      case 4:
        _processTakePhotos(taskInfo);
        break;

      case 5:
        _processScanBarcodes(taskInfo);
        break;

      case 7:
        _processReceiptGiver(taskInfo);
        break;

      case 8:
        _processStationNotice(taskInfo);
        break;

      case 9:
        _processCommissionNumber(taskInfo);
        break;

      case 11:
        _processPickupDeliveryStatusTask(taskInfo);
        break;
    }
  }

  _processTaskArrivedOrFinished(TaskInfo taskInfo) {
    showTaskArrivedPopup(context, taskInfo, () {
      DateFormat dateFormat = DateFormat("dd.MM.yyyy HH:mm");

      var answer = _createAnswerHeader(taskInfo);

      taskInfo.answer = jsonEncode(answer.toJson());
      taskInfo.additionalText = dateFormat.format(DateTime.now());
      taskInfo.completed = true;

      _sendArrivedMessage(taskInfo);

      setState(() {});

      _finishTaskProcessing(taskInfo);
    });
  }

  _processCommissionNumber(TaskInfo taskInfo) {
    showComissionNumberPopup(context, taskInfo, (comissionNumber) {
      var answer = _createAnswerHeader(taskInfo);
      answer.val = comissionNumber;

      taskInfo.answer = jsonEncode(answer.toJson());
      taskInfo.additionalText = comissionNumber;
      taskInfo.completed = true;

      _commisionNumber = comissionNumber;

      setState(() {});

      _finishTaskProcessing(taskInfo);
    });
  }

  _processScanBarcodes(TaskInfo taskInfo) {
    showScanBarcodesPopup(context, taskInfo, (List<String> barcodes) {
      var answer = _createAnswerHeader(taskInfo);
      answer.codes = [];
      for(var barcode in barcodes) {
        answer.codes!.add(barcode);
      }

      taskInfo.answer = jsonEncode(answer.toJson());
      taskInfo.additionalText = "Barcodes gescannt";
      taskInfo.completed = true;

      setState(() {});

      _finishTaskProcessing(taskInfo);
    });
  }

  _processTakePhotos(TaskInfo taskInfo) {
    showTakePhotosPopup(context, taskInfo, (List<Uint8List>? photos) {
      if (photos != null) {
        _photos = photos;

        taskInfo.additionalText = "Fotos aufgenommen";
        taskInfo.completed = true;

        setState(() {});

        _finishTaskProcessing(taskInfo);
      }
    });
  }

  void _processStationNotice(TaskInfo taskInfo) {
    showStationNoticePopup(context, taskInfo, (notice) {
      var answer = _createAnswerHeader(taskInfo);
      answer.val = notice;

      taskInfo.answer = jsonEncode(answer.toJson());
      taskInfo.additionalText = notice;
      taskInfo.completed = true;

      _finishTaskProcessing(taskInfo);

      setState(() {});
    });
  }

  void _processReceiptGiver(TaskInfo taskInfo) {
    showReceiptGiverPopup(context, taskInfo, (receiptGiver) {
      var answer = _createAnswerHeader(taskInfo);
      answer.val = receiptGiver;

      taskInfo.answer = jsonEncode(answer.toJson());
      taskInfo.additionalText = receiptGiver;
      taskInfo.completed = true;

      setState(() {});

      _finishTaskProcessing(taskInfo);
    });
  }

  void _processPickupDeliveryStatusTask(TaskInfo taskInfo) {
    Future.delayed(const Duration(seconds: 1), () async {
      showPickupDeliveryStatusPopup(context, taskInfo, (tourEntry) {
        var answer = _createAnswerHeader(taskInfo);
        answer.code = tourEntry!.code;

        taskInfo.answer = jsonEncode(answer.toJson());
        taskInfo.additionalText = tourEntry.text;
        taskInfo.completed = true;

        _finishTaskProcessing(taskInfo);

        setState(() {});
      });
    });
  }

  void _processSignature(TaskInfo taskInfo) {
    MyApp.suppressAcceptDialog = true;

    SystemChrome.setPreferredOrientations([DeviceOrientation.landscapeLeft]);

    Future.delayed(const Duration(seconds: 1), () async {
      showSignaturePopup(context, taskInfo, (String? signature) {
        MyApp.suppressAcceptDialog = false;

        SystemChrome.setPreferredOrientations([DeviceOrientation.portraitUp]);

        if (signature != null) {
          var answer = _createAnswerHeader(taskInfo);
          answer.sign = signature;

          taskInfo.answer = jsonEncode(answer.toJson());
          taskInfo.completed = true;

          _sendFinTourMessage();

          _finishTaskProcessing(taskInfo);

          MessageService().publish<PopContentViewMessage>(Constants.messageTopicPopContentView, arguments: PopContentViewMessage(count: 2));
        }
      });
    });
  }

  _finishTaskProcessing(TaskInfo taskInfo) async {
    Util.logInfo('Task ${taskInfo.task.sId} finished');

    await MyApp.isarInstance.writeTxn(() async {
      await MyApp.isarInstance.taskInfos.put(taskInfo);
    });
  }

  bool isTaskActive(int index) {
    var currentTaskInfo = _taskList[index];

    if (currentTaskInfo.completed && !currentTaskInfo.task.reenter!) return false;

    for (var taskInfo in _taskList)
    {
      if (taskInfo == currentTaskInfo) break;

      if (!taskInfo.task.opt! && !taskInfo.completed) return false;
    }

    if (currentTaskInfo.task.reenter!) return true;

    return true;
  }

  _sendArrivedMessage(TaskInfo taskInfo) {
    var finTaskMessage = FinTaskMessage();
    finTaskMessage.finTask = FinTask();
    finTaskMessage.finTask.trId = widget.tour.id;
    finTaskMessage.finTask.task = Task();
    finTaskMessage.finTask.task.sId = taskInfo.task.sId;
    finTaskMessage.finTask.task.time = DateTime.now().toIso8601String();

    var position = MyApp.currentPosition;
    if (position != null) {
      finTaskMessage.finTask.task.pos = FinTaskPos();
      finTaskMessage.finTask.task.pos!.lat = position.latitude;
      finTaskMessage.finTask.task.pos!.long = position.longitude;
    } else {
      finTaskMessage.finTask.task.pos = null;
    }

    MqttCore.instance.publishPayloadMessage("job", finTaskMessage.toJson());
  }

  FinTourTask _createAnswerHeader(TaskInfo taskInfo) {
    var position = MyApp.currentPosition;

    var finTourTask = FinTourTask();
    finTourTask.sId = taskInfo.task.sId;
    finTourTask.time = DateTime.now().toIso8601String();
    if (position != null) {
      finTourTask.pos = FinTaskPos();
      finTourTask.pos!.lat = position.latitude;
      finTourTask.pos!.long = position.longitude;
      finTourTask.pos!.acc = position.accuracy.toInt();
    } else {
      finTourTask.pos = null;
    }

    return finTourTask;
  }

  _sendFinTourMessage() async {
    var finTourMessage = FinTourMessage();
    finTourMessage.finTour = FinTour();
    finTourMessage.finTour.trId = widget.tour.id;
    finTourMessage.finTour.com = _commisionNumber;

    var position = MyApp.currentPosition;
    if (position != null) {
      finTourMessage.finTour.track = Track();
      finTourMessage.finTour.track!.time = DateTime.now().toIso8601String();
      finTourMessage.finTour.track!.pos = FinTaskPos();
      finTourMessage.finTour.track!.pos!.lat = position.latitude;
      finTourMessage.finTour.track!.pos!.long = position.longitude;
    }

    finTourMessage.finTour.tasks = [];
    for(var taskInfo in _taskList) {
      if (taskInfo.answer != null) {
        var finTourTask = FinTourTask.fromJson(jsonDecode(taskInfo.answer!));

        finTourMessage.finTour.tasks.add(finTourTask);
      }
    }

    MqttCore.instance.publishPayloadMessage("fin_tour", finTourMessage.toJson());

    widget.tour.state = Constants.stateFinishedNotConfirmed;
      await MyApp.isarInstance.writeTxn(() async {
      await MyApp.isarInstance.jobs.put(widget.job);
    });

    _sendImages();

    await _checkJobFinished();
  }

  _sendImages() {
    Future.delayed(const Duration(seconds: 1), () {
      if (_photos.isNotEmpty) {
        int photoIndex = 0;

        for (var photoData in _photos) {
          var message = PicMessage();
          message.pic = PicData();
          message.pic.trId = widget.tour.id;
          message.pic.num = photoIndex;
          message.pic.time = DateTime.now().millisecondsSinceEpoch;
          message.pic.data = base64Encode(photoData);

          var position = MyApp.currentPosition;
          if (position != null) {
            message.pos = PicMessagePos();
            message.pos!.lat = position.latitude;
            message.pos!.long = position.longitude;
          }

          MqttCore.instance.publishPayloadMessage("job", message.toJson());
        }
      }
    });
  }

  Future<void> _checkJobFinished() async {
    var jobFinished = true;

    for (var tour in widget.job.tours) {
      if (tour.state == 0) {
        jobFinished = false;

        break;
      }
    }

    if (jobFinished) {
      widget.job.state = 2;
      await MyApp.isarInstance.writeTxn(() async {
        await MyApp.isarInstance.jobs.put(widget.job);
      });
    }
  }
}