addevent.dart

import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:flutter_datetime_picker/flutter_datetime_picker.dart';
import 'package:shared_preferences/shared_preferences.dart';
import 'datamodel.dart';
import 'databaseconnector.dart';
import 'dart:async';
import 'package:geolocator/geolocator.dart';

class AddEvent extends StatefulWidget {
  const AddEvent({Key? key}) : super(key: key);

  @override
  State<AddEvent> createState() => _AddEventPageState();
}

class _AddEventPageState extends State<AddEvent>  {
  bool syncGNSSData = true;
  bool _addButtonEnabled = true;
  late String long = "";
  late String lat = "";
  late String alt = "";
  late double accuracy = 0.0;
  late StreamSubscription<Position> streamHandler;  //For canceling GNSS stream on dispose
  final prefs = SharedPreferences.getInstance();  // Is async
  var database = DatabaseInstance();

  Future startGNSS() async {
    final EventStoreInstance eventStore = EventStoreInstance();
    debugPrint("Check Location Permission");
    bool serviceStatus = false;
    bool hasPermission = false;
    serviceStatus = await Geolocator.isLocationServiceEnabled();
    if(serviceStatus){
      LocationPermission permission = await Geolocator.checkPermission();

      if (permission == LocationPermission.denied) {
        permission = await Geolocator.requestPermission();
        if (permission == LocationPermission.denied) {
          debugPrint('Location permissions are denied');
        }else if(permission == LocationPermission.deniedForever){
          debugPrint('Location permissions are permanently denied');
        }else{
          hasPermission = true;
        }
      }else{
        hasPermission = true;
      }
      if(hasPermission){
        debugPrint('Location permissions granted');
        if(mounted){
          setState(() {
            //refresh the UI
          });}
        debugPrint('Starting location stream');
        streamHandler = Geolocator.getPositionStream(
            locationSettings: const LocationSettings(
              accuracy: LocationAccuracy.high,
              distanceFilter: 0,
            )).listen((Position position) {
          debugPrint('Get Location: Lat:' + position.latitude.toString() +
              ' Long:' + position.longitude.toString() +
              ' Alt:' + position.altitude.toString());

          long = position.longitude.toString();
          lat = position.latitude.toString();
          alt = position.altitude.toString();
          accuracy = position.accuracy;

          if (eventStore.gnssSync == true) {
            if(mounted){
              setState(() {
                //refresh UI on update
              });}
          }
        });
      }
    }else{
      debugPrint("GPS Service is not enabled, turn on GPS location");
    }
    if(mounted){
      setState(() {
        //refresh the UI
      });}
  }

  @override
  void initState() {
    startGNSS();
    super.initState();
  }

  @override
  void dispose() async {
    try {
      streamHandler.cancel();
      debugPrint('Cancel location stream');
    }catch(e){
      debugPrint('Canceling location stream failed');
    }

    /*Async update current event configuration to shared preferences*/
    final EventStoreInstance event = EventStoreInstance();
    event.storeToSharedPrefs();

    super.dispose();
  }

  bool _validateLatitude(value){
    if (value == ""){
      return true;  //Empty string is valid
    }
    var number = num.tryParse(value);
    if(number != null){
      if (number >= -90.0  && number <= 90.0){
        return true;  // Latitude valid
      }
    }
    return false;
  }

  bool _validateLongitude(value){
    if (value == ""){
      return true;  //Empty string is valid
    }
    var number = num.tryParse(value);
    if(number != null){
      if (number >= -180.0  && number <= 180.0){
        return true;  // Longitude valid
      }
    }
    return false;
  }

  bool _validateElevation(value){
    if (value == ""){
      return true;  //Empty string is valid
    }
    var number = num.tryParse(value);
    if(number != null){
      return true;  // Any numerical value is valid for elevation
    }
    return false;
  }

  bool _validateInput(){
    final EventStoreInstance event = EventStoreInstance();
    if (RegExp(r'^[a-z A-Z . \- 0-9 , ( ) + - _ :]+$').hasMatch(
        event.currentEvent.label)) {
      if (RegExp(r'^[a-z A-Z . \- 0-9 , ( ) + - _ :]+$').hasMatch(
          event.currentEvent.description) || event.currentEvent.description == '') {
        if(_validateLatitude(event.currentEvent.latitude)){
          if(_validateLongitude(event.currentEvent.longitude)){
            if(_validateElevation(event.currentEvent.elevation)){
              return true;
            }
          }
        }
      }
    }
    return false;
  }

  bool _addButtonStatus(){
    if((_validateInput() == true) && (_addButtonEnabled == true)){

      return true;
    }
    return false;
  }

  Future<void> _storeCurrentEvent() async {
    final EventStoreInstance event = EventStoreInstance();
    final ConfigurationStoreInstance configuration = ConfigurationStoreInstance();
    event.currentEvent.typeId = configuration.getEventIdFromName(event.currentEvent.type);
    event.currentEvent.status = "PENDING";
    await database.addEvent(event.currentEvent);  //TODO: display feedback after this async function
    HapticFeedback.vibrate(); //Feedback that adding event succeeded
    _addButtonEnabled = true; //Activate button for add more events
    setState(() {});

    //Update timestamp in UI
    var date = DateTime.now().toUtc();
    var isoDate = date.toIso8601String();
    event.currentEvent.startDate = isoDate;
    event.currentEvent.endDate = isoDate;
  }


  @override
  Widget build(BuildContext context) {
    /* Get singletons to access relevant data here.*/
    final EventStoreInstance eventStore = EventStoreInstance();
    final ConfigurationStoreInstance configuration = ConfigurationStoreInstance();
    String gnssStatusText = "";

    if (true == eventStore.gnssSync){
      // Update current event coordinates from GNSS stream
      eventStore.currentEvent.latitude = lat;
      eventStore.currentEvent.longitude = long;
      eventStore.currentEvent.elevation = alt;

      var date = DateTime.now().toUtc();
      var isoDate = date.toIso8601String();
      eventStore.currentEvent.startDate = isoDate;
      eventStore.currentEvent.endDate = isoDate;

      if(accuracy == 0.0){
        gnssStatusText = "No-Fix";
      }
      else{
        gnssStatusText = "Precision: "+ accuracy.toStringAsFixed(2) +"m";
      }
    }
    else{
      gnssStatusText = "GNSS Disabled"; // Just display existing event coordinates
    }

    if (configuration.initialized == true) {
      return Scaffold(
        appBar: AppBar(title: const Text("Add Event")),
        body: SingleChildScrollView(
          child: Container(
            margin: const EdgeInsets.symmetric(horizontal: 5.0),
            child:
            Column(
                mainAxisAlignment: MainAxisAlignment.spaceEvenly,
                children: <Widget>[
                  const SizedBox(height: 15.0),
                  TextFormField(
                    initialValue: eventStore.currentEvent.label,
                    autovalidateMode: AutovalidateMode.always,
                    decoration: const InputDecoration(
                      border: OutlineInputBorder(),
                      labelText: 'Label',
                    ),
                    onChanged: (value){
                      eventStore.currentEvent.label = value;
                      setState(() {});
                    },
                    validator: (value) {
                      if (!RegExp(r'^[a-z A-Z . \- 0-9 , ( ) + - _ :]+$').hasMatch(
                          value!)) {
                        return "Only: a-z , A-Z , _ , 0-9 , ,(Comma) , ( , ) , + , - , . , :";
                      } else {
                        return null; // Entered Text is valid
                      }
                    },
                  ),
                  const SizedBox(height: 15.0),
                  DropdownButtonFormField(
                      value: eventStore.currentEvent.type,
                      isExpanded: true,
                      decoration: const InputDecoration(
                        border: OutlineInputBorder(),
                        labelText: 'Event Type',
                      ),
                      items:
                      configuration.eventTypes.map((EventType event) {
                        return DropdownMenuItem(
                          value: event.name,
                          child: Text(event.name),
                        );
                      }).toList(),
                      onChanged: (value) {
                        eventStore.currentEvent.type = value.toString();
                      }
                  ),
                  const SizedBox(height: 15.0),
                  DropdownButtonFormField(
                      value: eventStore.currentEvent.urn,
                      isDense: false,
                      isExpanded: true,
                      decoration: const InputDecoration(
                        border: OutlineInputBorder(),
                        labelText: 'URN',
                      ),
                      items:
                      configuration.devices.map((Device device) {
                        return DropdownMenuItem(
                          value: device.urn,
                          child: Text(device.urn),
                        );
                      }).toList(),
                      onChanged: (value) {
                        eventStore.currentEvent.urn = value.toString();
                        eventStore.currentEvent.urnId =
                            configuration.getDeviceIdFromUrn(value.toString());
                      }
                  ),
                  const SizedBox(height: 15.0),
                  TextFormField(
                    initialValue: eventStore.currentEvent.description,
                    autovalidateMode: AutovalidateMode.always,
                    decoration: const InputDecoration(
                        border: OutlineInputBorder(),
                        labelText: 'Description'
                    ),
                    onChanged: (value){
                      eventStore.currentEvent.description = value;
                      setState(() {});
                    },
                    validator: (value) {
                      if (!RegExp(r'^[a-z A-Z . \- 0-9 , ( ) + - _ :]+$').hasMatch(
                          value!)) {
                        if(value == ''){
                          return null;  //An empty description is also allowed.
                        }
                        return "Only: a-z , A-Z , _ , 0-9 , ,(Comma) , ( , ) , + , - , . , :";
                      } else {
                        return null; // Entered Text is valid
                      }
                    },
                  ),
                  const SizedBox(height: 15.0),
                  Row(
                      mainAxisSize: MainAxisSize.max,
                      children: <Widget>[
                        Flexible(child:
                        TextFormField(
                          controller: TextEditingController(
                              text: eventStore.currentEvent.startDate),
                          readOnly: true,
                          decoration: const InputDecoration(
                            labelText: 'Timestamp',
                            //helperText: '', //Adds some space below field
                            border: OutlineInputBorder(),
                          ),
                          onTap: () {
                            DatePicker.showDateTimePicker(context,
                                showTitleActions: true,
                                onConfirm: (date) {
                                  //Only one field for start and end date.
                                  var isoDate = date.toIso8601String();
                                  eventStore.currentEvent.startDate = isoDate;
                                  eventStore.currentEvent.endDate = isoDate;
                                  debugPrint('Date set to : $isoDate');
                                  setState(() {});
                                },
                                currentTime: DateTime.now().toUtc(),
                                locale: LocaleType.en);
                          },
                        ),
                        ),
                        ElevatedButton(
                          onPressed: () {
                            var date = DateTime.now().toUtc();
                            var isoDate = date.toIso8601String();
                            eventStore.currentEvent.startDate = isoDate;
                            eventStore.currentEvent.endDate = isoDate;
                            debugPrint('Date set to : ' +
                                eventStore.currentEvent.endDate.toString());
                            setState(() {});
                          },
                          child: const Text('Now'),
                        ),
                      ]
                  ),
                  const SizedBox(height: 15.0),
                  TextFormField(
                    readOnly: false,
                    enabled: !eventStore.gnssSync,
                    keyboardType: TextInputType.number,
                    autovalidateMode: AutovalidateMode.onUserInteraction,
                    controller: TextEditingController(
                        text: eventStore.currentEvent.latitude.toString()),
                    decoration: const InputDecoration(
                      labelText: 'Latitude',
                      border: OutlineInputBorder(),
                    ),
                    onChanged: (value) {
                      eventStore.currentEvent.latitude = value;
                    },
                    onFieldSubmitted: (value){
                      if (!eventStore.gnssSync) {
                        setState(() {});
                      }
                    },
                    validator: (value) {
                      if (value == "") {
                        return null; // Empty value is allowed
                      }
                      final number = num.tryParse(value!);
                      if (number != null){
                        if (number >= -90.0  && number <= 90.0){
                          return null;  // Latitude valid
                        }
                      }
                      return "-90 => Latitude <= +90";
                    },
                  ),
                  const SizedBox(height: 15.0),
                  TextFormField(
                    readOnly: false,
                    enabled: !eventStore.gnssSync,
                    keyboardType: TextInputType.number,
                    autovalidateMode: AutovalidateMode.onUserInteraction,
                    controller: TextEditingController(
                        text: eventStore.currentEvent.longitude.toString()),
                    decoration: const InputDecoration(
                      labelText: 'Longitude',
                      border: OutlineInputBorder(),

                    ),
                    onChanged: (value) {
                      eventStore.currentEvent.longitude = value;
                    },
                    onFieldSubmitted: (value){
                      if (!eventStore.gnssSync) {
                        setState(() {});
                      }
                    },
                    validator: (value) {
                      if (value == "") {
                        return null; // Empty value is allowed
                      }
                      final number = num.tryParse(value!);
                      if (number != null){
                        if (number >= -180.0  && number <= 180.0){
                          return null;  // Longitude valid
                        }
                      }
                      return "-180 => Longitude <= +180";
                    },

                  ),
                  const SizedBox(height: 15.0),
                  TextFormField(
                    readOnly: false,
                    enabled: !eventStore.gnssSync,
                    keyboardType: TextInputType.number,
                    autovalidateMode: AutovalidateMode.onUserInteraction,
                    controller: TextEditingController(
                        text: eventStore.currentEvent.elevation.toString()),
                    decoration: const InputDecoration(
                      labelText: 'Elevation',
                      border: OutlineInputBorder(),
                    ),
                    onChanged: (value) {
                      eventStore.currentEvent.elevation = value;
                    },
                    onFieldSubmitted: (value){
                      if (!eventStore.gnssSync) {
                        setState(() {});
                      }
                    },
                    validator: (value) {
                      if (value == "") {
                        return null; // Empty value is allowed
                      }
                      final number = num.tryParse(value!);
                      if (number != null){
                        return null;  // Elevation valid
                      }
                      return "Only numerical values for elevation in [m]";
                    },
                  ),
                ]
            ),
          ),
        ),
        bottomNavigationBar: Row(
          mainAxisAlignment: MainAxisAlignment.end,
          children: [
            Text(gnssStatusText),
            const SizedBox(width: 10),
            Switch(
              value: eventStore.gnssSync,
              onChanged: (value) {
                eventStore.gnssSync = value;
                debugPrint('Switched to:' + eventStore.gnssSync.toString());
                setState(() {
                  //refresh the UI
                });
              },
            ),
            const SizedBox(width: 50),
            Container(
                margin: const EdgeInsets.symmetric(vertical: 10.0),
                child: _addButtonStatus() ?
                FloatingActionButton(
                  onPressed: () {
                    if (_validateInput()) {
                      _addButtonEnabled = false;  //Disable button until event is stored
                      _storeCurrentEvent();

                    }
                    setState(() {});
                  },
                  tooltip: 'Add Event',
                  child: const Icon(Icons.check),
                ) :
                FloatingActionButton(
                  enableFeedback: false,
                  backgroundColor: Colors.grey,
                  onPressed: () {
                    setState(() {
                      //refresh the UI
                    });
                  },
                  tooltip: 'Complete / correct inputs before adding the Event',
                  //child: const Icon(Icons.check),
                )
            ),
            const SizedBox(width: 5.0),
          ],
        ),
      );
    }else {
      return Scaffold(
        appBar: AppBar(title: const Text("Add Event")),
        body: Column(
          mainAxisAlignment: MainAxisAlignment.spaceEvenly,
          crossAxisAlignment: CrossAxisAlignment.end,
          children: <Widget>[
            Container(
              margin: const EdgeInsets.all(10.0),
              child:const Text(
                  'Check Configuration Page for initial setup!',
                  style: TextStyle(fontSize: 20)
              ),
            ),
          ],
        ),
      );
    }
  }
}