fluffychat/lib/pangea/toolbar/reading_assistance/select_mode_controller.dart

import 'dart:async';
import 'dart:io';

import 'package:flutter/foundation.dart';

import 'package:matrix/matrix.dart';
import 'package:path_provider/path_provider.dart';

import 'package:fluffychat/pangea/analytics_misc/lemma_emoji_setter_mixin.dart';
import 'package:fluffychat/pangea/common/utils/async_state.dart';
import 'package:fluffychat/pangea/events/event_wrappers/pangea_message_event.dart';
import 'package:fluffychat/pangea/events/models/pangea_token_text_model.dart';
import 'package:fluffychat/pangea/speech_to_text/speech_to_text_response_model.dart';
import 'package:fluffychat/pangea/toolbar/message_practice/message_audio_card.dart';
import 'package:fluffychat/pangea/toolbar/reading_assistance/select_mode_buttons.dart';
import 'package:fluffychat/widgets/matrix.dart';

class _TranscriptionLoader extends AsyncLoader<SpeechToTextResponseModel> {
  final PangeaMessageEvent messageEvent;
  _TranscriptionLoader(this.messageEvent) : super();

  @override
  Future<SpeechToTextResponseModel> fetch() => messageEvent.requestSpeechToText(
        MatrixState.pangeaController.userController.userL1!.langCodeShort,
        MatrixState.pangeaController.userController.userL2!.langCodeShort,
      );
}

class _STTTranslationLoader extends AsyncLoader<String> {
  final PangeaMessageEvent messageEvent;
  _STTTranslationLoader(this.messageEvent) : super();

  @override
  Future<String> fetch() => messageEvent.requestSttTranslation(
        langCode:
            MatrixState.pangeaController.userController.userL1!.langCodeShort,
        l1Code:
            MatrixState.pangeaController.userController.userL1!.langCodeShort,
        l2Code:
            MatrixState.pangeaController.userController.userL2!.langCodeShort,
      );
}

class _TranslationLoader extends AsyncLoader<String> {
  final PangeaMessageEvent messageEvent;
  _TranslationLoader(this.messageEvent) : super();

  @override
  Future<String> fetch() => messageEvent.requestRespresentationByL1();
}

class _AudioLoader extends AsyncLoader<(PangeaAudioFile, File?)> {
  final PangeaMessageEvent messageEvent;
  _AudioLoader(this.messageEvent) : super();

  @override
  Future<(PangeaAudioFile, File?)> fetch() async {
    final audioBytes = await messageEvent.requestTextToSpeech(
      messageEvent.messageDisplayLangCode,
    );

    File? audioFile;
    if (!kIsWeb) {
      final tempDir = await getTemporaryDirectory();

      File? file;
      file = File('${tempDir.path}/${audioBytes.name}');
      await file.writeAsBytes(audioBytes.bytes);
      audioFile = file;
    }

    return (audioBytes, audioFile);
  }
}

class SelectModeController with LemmaEmojiSetter {
  final PangeaMessageEvent messageEvent;
  final _TranscriptionLoader _transcriptLoader;
  final _TranslationLoader _translationLoader;
  final _AudioLoader _audioLoader;
  final _STTTranslationLoader _sttTranslationLoader;

  SelectModeController(
    this.messageEvent,
  )   : _transcriptLoader = _TranscriptionLoader(messageEvent),
        _translationLoader = _TranslationLoader(messageEvent),
        _audioLoader = _AudioLoader(messageEvent),
        _sttTranslationLoader = _STTTranslationLoader(messageEvent);

  ValueNotifier<SelectMode?> selectedMode = ValueNotifier<SelectMode?>(null);

  final StreamController contentChangedStream = StreamController.broadcast();

  // Sometimes the same token is clicked twice. Setting it to the same value
  // won't trigger the notifier, so use the bool for force it to trigger.
  ValueNotifier<(PangeaTokenText?, bool)> playTokenNotifier =
      ValueNotifier<(PangeaTokenText?, bool)>((null, false));

  void dispose() {
    selectedMode.dispose();
    playTokenNotifier.dispose();
    _transcriptLoader.dispose();
    _translationLoader.dispose();
    _sttTranslationLoader.dispose();
    _audioLoader.dispose();
    contentChangedStream.close();
  }

  static List<SelectMode> get _textModes => [
        SelectMode.audio,
        SelectMode.translate,
        SelectMode.practice,
        SelectMode.emoji,
      ];

  static List<SelectMode> get _audioModes => [
        SelectMode.speechTranslation,
      ];

  ValueNotifier<AsyncState<String>> get translationState =>
      _translationLoader.state;

  ValueNotifier<AsyncState<SpeechToTextResponseModel>> get transcriptionState =>
      _transcriptLoader.state;

  ValueNotifier<AsyncState<String>> get speechTranslationState =>
      _sttTranslationLoader.state;

  (PangeaAudioFile, File?)? get audioFile => _audioLoader.value;

  List<SelectMode> get allModes {
    final validTypes = {MessageTypes.Text, MessageTypes.Audio};
    if (!messageEvent.event.status.isSent ||
        messageEvent.event.type != EventTypes.Message ||
        !validTypes.contains(messageEvent.event.messageType)) {
      return [];
    }

    return messageEvent.event.messageType == MessageTypes.Text
        ? _textModes
        : _audioModes;
  }

  List<SelectMode> get readingAssistanceModes {
    final validTypes = {MessageTypes.Text, MessageTypes.Audio};
    if (!messageEvent.event.status.isSent ||
        messageEvent.event.type != EventTypes.Message ||
        !validTypes.contains(messageEvent.event.messageType)) {
      return [];
    }

    if (messageEvent.event.messageType == MessageTypes.Text) {
      final lang = messageEvent.messageDisplayLangCode.split("-").first;

      final matchesL2 = lang ==
          MatrixState.pangeaController.userController.userL2!.langCodeShort;

      final matchesL1 = lang ==
          MatrixState.pangeaController.userController.userL1!.langCodeShort;

      return matchesL2
          ? _textModes
          : matchesL1
              ? []
              : [SelectMode.translate];
    }

    return _audioModes;
  }

  bool get isLoading => currentModeStateNotifier?.value is AsyncLoading;

  bool get isShowingExtraContent =>
      (selectedMode.value == SelectMode.translate &&
          _translationLoader.isLoaded) ||
      (selectedMode.value == SelectMode.speechTranslation &&
          _sttTranslationLoader.isLoaded) ||
      _transcriptLoader.isLoaded ||
      _transcriptLoader.isError;

  ValueNotifier<AsyncState>? get currentModeStateNotifier =>
      modeStateNotifier(selectedMode.value);

  ValueNotifier<AsyncState>? modeStateNotifier(SelectMode? mode) =>
      switch (mode) {
        SelectMode.audio => _audioLoader.state,
        SelectMode.translate => _translationLoader.state,
        SelectMode.speechTranslation => _sttTranslationLoader.state,
        _ => null,
      };

  void setSelectMode(SelectMode? mode) {
    if (selectedMode.value == mode) return;
    selectedMode.value = mode;
  }

  void setPlayingToken(PangeaTokenText? token) =>
      playTokenNotifier.value = (token, !playTokenNotifier.value.$2);

  Future<void> fetchAudio() => _audioLoader.load();
  Future<void> fetchTranslation() => _translationLoader.load();
  Future<void> fetchTranscription() => _transcriptLoader.load();
  Future<void> fetchSpeechTranslation() => _sttTranslationLoader.load();
}