AppFlowy/frontend/app_flowy/lib/workspace/application/doc/share_bloc.dart

import 'dart:async';
import 'dart:io';
import 'package:app_flowy/startup/startup.dart';
import 'package:app_flowy/workspace/application/doc/share_service.dart';
import 'package:app_flowy/workspace/application/markdown/delta_markdown.dart';
import 'package:app_flowy/workspace/presentation/widgets/dialogs.dart';
import 'package:flowy_sdk/protobuf/flowy-text-block/entities.pb.dart';
import 'package:flowy_sdk/protobuf/flowy-folder-data-model/view.pb.dart';
import 'package:flowy_sdk/protobuf/flowy-error/errors.pb.dart';
import 'package:freezed_annotation/freezed_annotation.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:path_provider/path_provider.dart';
import 'package:dartz/dartz.dart';
part 'share_bloc.freezed.dart';

class DocShareBloc extends Bloc<DocShareEvent, DocShareState> {
  ShareService service;
  View view;
  DocShareBloc({required this.view, required this.service}) : super(const DocShareState.initial()) {
    on<DocShareEvent>((event, emit) async {
      await event.map(
        shareMarkdown: (ShareMarkdown value) async {
          await service.exportMarkdown(view.id).then((result) {
            result.fold(
              (value) => emit(DocShareState.finish(left(_convertDeltaToMarkdown(value)))),
              (error) => emit(DocShareState.finish(right(error))),
            );
          });

          emit(const DocShareState.loading());
        },
        shareLink: (ShareLink value) {},
        shareText: (ShareText value) {},
      );
    });
  }

  bool checkFile = false;

  ExportData _convertDeltaToMarkdown(ExportData value) {
    final result = deltaToMarkdown(value.data);
    value.data = result;
    writeFile(result);
    return value;
  }

  Future<Directory> appFlowyDocumentDirectory() async {
    Directory documentsDir = await getApplicationDocumentsDirectory();

    switch (integrationEnv()) {
      case IntegrationMode.develop:
        return Directory('${documentsDir.path}/flowy_dev').create();
      case IntegrationMode.release:
        return Directory('${documentsDir.path}/flowy').create();
      case IntegrationMode.test:
        return Directory("${Directory.current.path}/.sandbox");
    }
  }

  Future<String> get _localPath async {
    final dir = await appFlowyDocumentDirectory();
    return dir.path;
  }

  Future<File> get _localFile async {
    final path = await _localPath;
    checkFile = true;
    return File('$path/${view.name}.md');
  }

  Future<File> writeFile(String md) async {
    final file = await _localFile;
    if (checkFile)
      BubbleNotification(msgTitle: 'Export To Markdown', msgBody: 'File saved to $file');
    else
      BubbleNotification(msgTitle: 'Failed to write to file', msgBody: '$file');
    return file.writeAsString(md);
  }
}

@freezed
class DocShareEvent with _$DocShareEvent {
  const factory DocShareEvent.shareMarkdown() = ShareMarkdown;
  const factory DocShareEvent.shareText() = ShareText;
  const factory DocShareEvent.shareLink() = ShareLink;
}

@freezed
class DocShareState with _$DocShareState {
  const factory DocShareState.initial() = _Initial;
  const factory DocShareState.loading() = _Loading;
  const factory DocShareState.finish(Either<ExportData, FlowyError> successOrFail) = _Finish;
}