user_view.dart

import 'dart:convert';
import 'dart:io';
import 'dart:typed_data';

import 'package:digital_3g_common/backend_switcher.dart';
import 'package:digital_3g_common/theme.dart';
import 'package:digital_3g_common/ui.dart';
import 'package:encrypt/encrypt.dart';
import 'package:encrypt/encrypt_io.dart';
import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:http/http.dart' as http;
import 'package:intl/date_symbol_data_local.dart';
import 'package:intl/intl.dart';
import 'package:path_provider/path_provider.dart';
import 'package:pointycastle/asymmetric/api.dart';
import 'package:provider/provider.dart';
import 'package:qr_flutter/qr_flutter.dart';

import '../api/auth_api.dart';
import '../api/user_api.dart';

class FormData {
  DateTime? certificationDate;
  TimeOfDay? certificationTime;
  bool isTested;
  bool isRecovered;
  bool isVaccinated;

  FormData({
    this.certificationDate,
    this.certificationTime,
    this.isTested = false,
    this.isRecovered = false,
    this.isVaccinated = false,
  });

  void resetBools() {
    isTested = false;
    isRecovered = false;
    isVaccinated = false;
  }
}

class UserView extends StatefulWidget {
  const UserView({key}) : super(key: key);

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

class _UserViewState extends State<UserView> {
  FormData _formData = FormData(
    certificationDate: DateTime.now(),
    certificationTime: TimeOfDay.now(),
  );

  final DateFormat _dateFormat = DateFormat.yMd();
  final DateFormat _timeFormat = DateFormat.Hm();

  String _expiryText = '';

  http.Client? _client;

  UserApi? _userApi;

  @override
  Widget build(BuildContext context) {
    return ListView(
      children: [
        PaddedCard(
          child: Column(
            crossAxisAlignment: CrossAxisAlignment.stretch,
            children: [
              Text('Datenaufnahme', style: Theme.of(context).textTheme.headline5),
              CheckboxListTile(
                title: const Text('Getestet'),
                value: _formData.isTested,
                onChanged: (bool? input) {
                  ScaffoldMessenger.of(context).clearSnackBars();
                  setState(() {
                    _formData.resetBools();
                    _formData.isTested = input ?? false;
                    _expiryText = _makeExpiryString();
                  });
                },
              ),
              CheckboxListTile(
                title: const Text('Genesen'),
                value: _formData.isRecovered,
                onChanged: (bool? input) {
                  ScaffoldMessenger.of(context).clearSnackBars();
                  setState(() {
                    _formData.resetBools();
                    _formData.isRecovered = input ?? false;
                    _expiryText = _makeExpiryString();
                  });
                },
              ),
              CheckboxListTile(
                title: const Text('Geimpft'),
                value: _formData.isVaccinated,
                onChanged: (bool? input) {
                  ScaffoldMessenger.of(context).clearSnackBars();
                  setState(() {
                    _formData.resetBools();
                    _formData.isVaccinated = input ?? false;
                    _expiryText = _makeExpiryString();
                  });
                },
              ),
              if (!_formData.isVaccinated) const Divider(),
              if (!_formData.isVaccinated)
                ListTile(
                    title: const Text('Nachweisdatum'),
                    trailing:
                        Text(_dateFormat.format(_formData.certificationDate ?? DateTime.now())),
                    onTap: () async {
                      ScaffoldMessenger.of(context).clearSnackBars();
                      final date = await showDatePicker(
                        context: context,
                        cancelText: 'Abbrechen',
                        confirmText: 'Bestätigen',
                        fieldLabelText: 'Datum',
                        fieldHintText: 'z.B. 01/04/2021',
                        helpText: 'Nachweisdatum einstellen',
                        initialDate: _formData.certificationDate ?? DateTime.now(),
                        firstDate: DateTime.now().subtract(const Duration(days: 1000)),
                        lastDate: DateTime.now(),
                      );
                      if (date != null) {
                        setState(() {
                          _formData.certificationDate = date;
                          _expiryText = _makeExpiryString();
                        });
                      }
                    }),
              if (_formData.isTested)
                ListTile(
                    title: const Text('Nachweiszeit'),
                    trailing: Text(_formData.certificationTime?.format(context) ??
                        _timeFormat.format(DateTime.now())),
                    onTap: () async {
                      ScaffoldMessenger.of(context).clearSnackBars();
                      final time = await showTimePicker(
                        cancelText: 'Abbrechen',
                        confirmText: 'Bestätigen',
                        minuteLabelText: 'Minuten',
                        hourLabelText: 'Stunden',
                        helpText: 'Nachweiszeit auswählen',
                        initialEntryMode: TimePickerEntryMode.dial,
                        context: context,
                        initialTime: _formData.certificationTime ?? TimeOfDay.now(),
                      );
                      if (time != null) {
                        final now = DateTime.now();
                        if (_formData.certificationDate?.year == now.year &&
                            _formData.certificationDate?.month == now.month &&
                            _formData.certificationDate?.day == now.day &&
                            (time.hour > now.hour ||
                                (time.hour == now.hour && time.minute > now.minute))) {
                          ScaffoldMessenger.of(context).showSnackBar(const SnackBar(
                              content: Text(
                                  'Der gewählte Testzeitpunkt kann nicht benutzt werden, da er in der Zukunft liegt.')));
                        } else {
                          setState(() {
                            _formData.certificationTime = time;
                            _expiryText = _makeExpiryString();
                          });
                        }
                      }
                    }),
              const Divider(),
              const Text('Gültig bis:'),
              Text(_expiryText, style: Theme.of(context).textTheme.headline6),
            ],
          ),
        ),
        const Divider(),
        Padding(
          padding: const EdgeInsets.all(16.0),
          child: ElevatedButton(
            onPressed: _formData.isRecovered || _formData.isVaccinated || _formData.isTested
                ? _onShowCode
                : null,
            child: const Text('QR-Code zeigen', textScaleFactor: 1.2),
          ),
        ),
      ],
    );
  }

  @override
  void didChangeDependencies() async {
    await initializeDateFormatting('de', null);
    _client = Provider.of<AuthApi>(context, listen: false).client;
    _userApi = UserApi(_client!, BlocProvider.of<BackendSwitcher>(context).state);
    super.didChangeDependencies();
  }

  @override
  void initState() {
    super.initState();
    _initKey();
    _expiryText = _makeExpiryString();
  }

  DateTime? _calculateExpiryDate(FormData form) {
    var date = form.certificationDate;
    var time = form.certificationTime;
    if (form.isTested) {
      date = DateTime(date!.year, date.month, date.day).add(const Duration(hours: 48));
      date = date.add(Duration(hours: time!.hour, minutes: time.minute));
    } else if (form.isRecovered) {
      if (DateTime.now().difference(date!) < const Duration(days: 29)) {
        throw Exception('test');
      }
      date = DateTime(date.year, date.month + 6, date.day - 1, 23, 59);
    } else if (form.isVaccinated) {
      final now = DateTime.now();
      final thisSs = DateTime(now.year, 4);
      final thisWs = DateTime(now.year, 10);
      if (now.isAfter(thisSs) && now.isBefore(thisWs)) {
        date = thisWs;
      } else if (now.isAfter(thisWs) && now.isAfter(thisSs)) {
        date = DateTime(now.year + 1, 4);
      } else if (now.isBefore(thisWs) && now.isBefore(thisSs)) {
        date = thisSs;
      }
    } else {
      return null;
    }
    return date;
  }

  Future<Uint8List?> _getPublicKey() async {
    final response =
        await _client!.get(Uri.parse('${BlocProvider.of<BackendSwitcher>(context).state}/pubkey'));

    if (response.statusCode == 200) {
      return response.bodyBytes;
    } else {
      return null;
    }
  }

  Future<void> _initKey() async {
    if (Provider.of<AuthApi>(context, listen: false).user?.credentials == null) return;

    final basePath = (await getApplicationDocumentsDirectory()).path;
    final keyFile = File('$basePath/public_key.pem');

    if (await keyFile.exists()) {
      await keyFile.delete();
    }
    await keyFile.create(recursive: true);
    try {
      keyFile.writeAsBytes((await _getPublicKey())!);
    } catch (e) {
      await keyFile.delete();
    }
  }

  String _makeExpiryString() {
    DateTime? expiry;
    try {
      expiry = _calculateExpiryDate(_formData);
    } catch (e) {
      if (e.toString().contains('test')) {
        return 'Bitte ein gültiges Datum wählen';
      }
    }

    return expiry != null
        ? '${_dateFormat.format(expiry)} ${_timeFormat.format(expiry)}'
        : 'Bitte zuerst die Nachweisart wählen';
  }

  Future<String> _onEncrypt() async {
    final basePath = (await getApplicationDocumentsDirectory()).path;

    RSAPublicKey publicKey;
    try {
      publicKey = await parseKeyFromFile<RSAPublicKey>('$basePath/public_key.pem');
    } catch (e) {
      final keyFile = File('$basePath/public_key.pem');
      if (keyFile.existsSync()) {
        await File('$basePath/public_key.pem').delete();
      }
      await keyFile.writeAsBytes((await _getPublicKey())!);
      publicKey = await parseKeyFromFile<RSAPublicKey>('$basePath/public_key.pem');
    }

    final encrypter = Encrypter(RSA(publicKey: publicKey, encoding: RSAEncoding.OAEP));

    DateTime? expiry;
    try {
      expiry = _calculateExpiryDate(_formData);
    } on Exception catch (e) {
      if (e.toString().contains('test')) {
        ScaffoldMessenger.of(context).showSnackBar(const SnackBar(
            content: Text('Das Nachweisdatum vom PCR Test muss mindestens 28 Tage zurück liegen')));
      }
    }

    if (expiry != null) {
      final encrypted =
          encrypter.encrypt(_calculateExpiryDate(_formData)!.toUtc().toIso8601String());
      return base64.encode(encrypted.bytes);
    } else {
      ScaffoldMessenger.of(context).showSnackBar(
          const SnackBar(content: Text('Endzeitpunkt konnte nicht errechnet werden')));
      return '';
    }
  }

  Future<void> _onShowCode() async {
    ScaffoldMessenger.of(context).clearSnackBars();

    final encrypted = await _onEncrypt();

    if (encrypted.isEmpty) return;

    final signed = await _userApi!.signTicket(encrypted);

    if (signed == null) {
      ScaffoldMessenger.of(context).showSnackBar(const SnackBar(
        content: Text(
            'Code konnte nicht signiert werden. Bitte prüfe die Eingaben auf Korrekt- und Sinnhaftigkeit.'),
        duration: Duration(seconds: 5),
      ));
      return;
    }

    _resetForm();

    await showDialog(
      context: context,
      builder: (BuildContext context) => Dialog(
        insetPadding: const EdgeInsets.all(8.0),
        clipBehavior: Clip.antiAlias,
        child: Column(
          crossAxisAlignment: CrossAxisAlignment.center,
          mainAxisSize: MainAxisSize.min,
          children: [
            QrImage(
              data: signed.combinedString,
              version: QrVersions.auto,
              size: MediaQuery.of(context).size.width - 32.0,
            ),
            MaterialButton(
              onPressed: () => Navigator.of(context).pop(),
              child: const Icon(
                Icons.close_rounded,
                size: 48.0,
                color: Colors.white,
              ),
              minWidth: MediaQuery.of(context).size.width - 16.0,
              padding: const EdgeInsets.all(16.0),
              color: primary,
            ),
          ],
        ),
      ),
    );
  }

  void _resetForm() {
    setState(() {
      _formData = FormData(
        certificationDate: DateTime.now(),
        certificationTime: TimeOfDay.now(),
      );
    });
  }
}