liangchengyou / wow_english

  import 'dart:async';
  

  import 'package:flutter/cupertino.dart';

  import 'package:flutter/foundation.dart';

  import 'package:flutter/material.dart';

  import 'package:flutter_bloc/flutter_bloc.dart';

  import 'package:flutter_screenutil/flutter_screenutil.dart';

  import 'package:wow_english/common/core/user_util.dart';

  import 'package:wow_english/common/request/dao/lesson_dao.dart';

  import 'package:wow_english/common/request/exception.dart';

  import 'package:wow_english/common/request/dao/listen_dao.dart';

  import 'package:wow_english/pages/section/section_type.dart';

  import 'package:wow_english/utils/audio_player_util.dart';

  import 'package:wow_english/utils/loading.dart';

  import 'package:wow_english/utils/toast_util.dart';

  import '../../../models/course_section_entity.dart';
  import '../../../models/course_unit_entity.dart';

  import '../../../utils/list_ext.dart';

  part 'section_event.dart';

  part 'section_state.dart';

  class SectionBloc extends Bloc<SectionEvent, SectionState> {

    PageController _pageController;
  
    PageController get pageController => _pageController;
  
    ///当前页索引
    int _currentPage = 0;
  
    int get currentPage => _currentPage;
  
    ScrollController _listController;
  
    ScrollController get listController => _listController;
  

    ScrollController _indicatorSrollController;
  
    ScrollController get indicatorSrollController => _indicatorSrollController;
  

    ///之前传进来是用于根据courseModuleCode获取主题色的，现在不用了。参数还是先留着，预防后面需要

    CourseUnitEntity _courseUnitEntity;
  
    CourseUnitEntity get courseUnitEntity => _courseUnitEntity;
  

    ///单元列表是否有刷新，有的话返回上一页时通知其刷新接口数据
    bool courseUnitEntityChanged = false;
  

    ///courseUnitId与课程环节列表的映射
    final Map<int, List<CourseSectionEntity>?> _courseSectionDatasMap = {};

    Map<int, List<CourseSectionEntity>?> get courseSectionDatasMap =>
        _courseSectionDatasMap;

    SectionBloc(this._courseUnitEntity, this._currentPage, this._pageController,

        this._listController, this._indicatorSrollController)

        : super(LessonInitial()) {

      on<RequestDataEvent>(_requestSectionsData);

      on<RequestEndClassEvent>(_requestEndClass);

      on<RequestEnterClassEvent>(_onEnterClass);

      on<CurrentUnitIndexChangeEvent>(_pageControllerChange);

      on<InitEvent>((event, emit) async {

        await AudioPlayerUtil.getInstance()
            .playAudio(AudioPlayerUtilType.countWithMe);

      });
    }

    void _requestSectionsData(

        RequestDataEvent event, Emitter<SectionState> emitter) async {

      try {
        await loading(() async {

          List<CourseSectionEntity>? courseSectionEntities =
              await LessonDao.courseSection(courseUnitId: event.courseUnitId);

          if (courseSectionEntities != null) {
            _courseSectionDatasMap[event.courseUnitId] =

                _filterReviewContent(courseSectionEntities);

            emitter(LessonDataLoadState());
          }

        });
      } catch (e) {
        if (e is ApiException) {

          showToast(e.message.toString());

        }
      }
    }

    void _onEnterClass(

        RequestEnterClassEvent event, Emitter<SectionState> emitter) async {

      emitter(RequestEnterClassState(event.courseLessonId, event.courseType));
    }
  
    ///进入课程接口请求函数封装
    ///onRequestEnterSuccess 接口请求成功后行为函数，比如跳转课程页面

    Future<void> requestEnterClass(
        String courseLessonId, FutureOr<void> Function() onRequestEnterSuccess,
        {FutureOr<void> Function(Object)? onRequestEnterFailed}) async {

      // await loading(() async {
      try {
        await ListenDao.enterClass(courseLessonId);
        await Future.sync(onRequestEnterSuccess);
      } catch (e) {
        if (e is ApiException) {
          showToast('进入课堂失败 ${e.message}');
        } else {
          showToast('进入课堂失败 $e');

        }

        if (onRequestEnterFailed != null) {
          await Future.sync(onRequestEnterFailed(e) as FutureOr Function());
        }
      }
      // });

    }
  

    void _requestEndClass(
        RequestEndClassEvent event, Emitter<SectionState> emitter) async {

      if (event.isCompleted) {
        await await ListenDao.endClass(event.courseLessonId,

            currentStep: event.currentStep, currentTime: event.currentTime);

      } else {

        await await ListenDao.exitClass(event.courseLessonId,

            currentStep: event.currentStep, currentTime: event.currentTime);

      }

      if (event.autoNextSection) {

        final nextCourseSection =

            await getNextCourseSection(int.parse(event.courseLessonId), emitter);

        if (nextCourseSection != null) {
          ///进入课堂

          add(RequestEnterClassEvent(
              nextCourseSection.id.toString(), nextCourseSection.courseType));

        }

      }

    }

    void _pageControllerChange(
        CurrentUnitIndexChangeEvent event, Emitter<SectionState> emitter) async {

      _currentPage = event.unitIndex;

      double indicatorWidth = 30.0.w; // 指示器宽度
  
      // 计算选中项的偏移量
      double offset = _currentPage * indicatorWidth -
          (_indicatorSrollController.position.viewportDimension -
                  indicatorWidth) /
              2;
  
      // 确保偏移量在合理范围内
      if (offset < 0) {
        offset = 0;
      } else if (offset >
          unlockPageCount() * indicatorWidth -
              _indicatorSrollController.position.viewportDimension) {
        offset = unlockPageCount() * indicatorWidth -
            _indicatorSrollController.position.viewportDimension;
      }
      _indicatorSrollController.animateTo(
        offset,
        duration: const Duration(milliseconds: 250),
        curve: Curves.easeInOut,
      );

      emitter(CurrentPageIndexState());
    }
  

    ///未锁定的页（单元）数

    int unlockPageCount() {

      // return _courseUnitEntity.courseUnitVOList
      //         ?.indexWhereOrNull((element) => element.lock == true) ??
      //     _courseUnitEntity.courseUnitVOList?.length ??
      //     0;
      return _courseUnitEntity.courseUnitVOList?.length ?? 0;

    }

    ///当前页的课程详情

    CourseUnitDetail getCourseUnitDetail({int? pageIndex}) {
      return _courseUnitEntity.courseUnitVOList![pageIndex ?? _currentPage];
    }
  
    ///根据courseLessonId查找对应的courseSection
    CourseSectionEntity? findCourseSectionById(int courseLessonId) {
      for (var entry in courseSectionDatasMap.entries) {
        var sectionList = entry.value;
        if (sectionList != null) {
          for (var section in sectionList) {
            if (section.id == courseLessonId) {
              return section;
            }
          }
        }
      }
      return null;
    }
  
    ///根据sortOrder查找对应的courseSection
    CourseSectionEntity? findCourseSectionBySort(int sortOrder) {
      for (var entry in courseSectionDatasMap.entries) {
        var sectionList = entry.value;
        if (sectionList != null) {
          for (var section in sectionList) {
            if (section.sortOrder == sortOrder) {
              return section;
            }
          }
        }
      }
      return null;
    }
  

    List<CourseSectionEntity> _filterReviewContent(
        List<CourseSectionEntity> courseSections) {
      if (!UserUtil.isAppReviewAccount()) {
        return courseSections;
      }
      return courseSections
          .where((section) => section.courseType != SectionType.pictureBook.value)
          .toList();
    }
  
    CourseSectionEntity? _findNextVisibleCourseSection(
        CourseSectionEntity currentSection) {
      if (!UserUtil.isAppReviewAccount()) {
        return findCourseSectionBySort(currentSection.sortOrder + 1);
      }
  
      final currentUnitSections =
          _courseSectionDatasMap[currentSection.courseUnitId];
      final nextSections = currentUnitSections
          ?.where((section) => section.sortOrder > currentSection.sortOrder)
          .toList()
        ?..sort((a, b) => a.sortOrder.compareTo(b.sortOrder));
      return nextSections?.firstOrNull;
    }
  

    ///根据courseLessonId查找对应的CourseUnitDetail
    CourseUnitDetail? findCourseUnitDetailById(int courseLessonId) {
      final curCourseSectionEntity = findCourseSectionById(courseLessonId);
      if (curCourseSectionEntity != null) {

        final curCourseUnitDetail = _courseUnitEntity.courseUnitVOList

            ?.firstWhereOrNull(

                (element) => element.id == curCourseSectionEntity.courseUnitId);

        return curCourseUnitDetail;
      }
      return null;
    }
  

    ///根据courseLessonId查找下一个courseSection

    Future<CourseSectionEntity?> getNextCourseSection(
        int courseLessonId, Emitter<SectionState> emitter) async {

      final curCourseSectionEntity = findCourseSectionById(courseLessonId);
      final curSectionSort = curCourseSectionEntity?.sortOrder ?? 0;

      try {
        ///查找当前unit的下一个section
        CourseSectionEntity? nextCourseSectionEntity =

            curCourseSectionEntity == null
                ? findCourseSectionBySort(curSectionSort + 1)
                : _findNextVisibleCourseSection(curCourseSectionEntity);

        return checkCourseSectionLocked(
            courseLessonId, nextCourseSectionEntity, emitter);

      } catch (e) {
        if (e is ApiException) {
          showToast(e.message.toString());
        }
        return null;
      }
    }
  
    ///检查section是否锁定

    Future<CourseSectionEntity?> checkCourseSectionLocked(
        int courseLessonId,
        CourseSectionEntity? courseSectionEntity,

        Emitter<SectionState> emitter) async {
      if (courseSectionEntity != null) {
        if (courseSectionEntity.lock == false) {
          ///如果section没锁，直接返回
          return courseSectionEntity;
        } else {
          ///如果section锁了，请求当前unit下的section数据,查询解锁状态
          int courseUnitId = courseSectionEntity.courseUnitId;

          CourseSectionEntity? result = await loading(() async {

            List<CourseSectionEntity>? tempSectionEntities =

                await LessonDao.courseSection(courseUnitId: courseUnitId);

            if (tempSectionEntities != null) {

              tempSectionEntities = _filterReviewContent(tempSectionEntities);

              _courseSectionDatasMap[courseUnitId] = tempSectionEntities;
              emitter(LessonDataLoadState());
            }
            courseSectionEntity = tempSectionEntities?.firstWhereOrNull(

                (element) => element.id == courseSectionEntity?.id);

            if (courseSectionEntity?.lock == false) {
              ///刷新后的数据如果解锁了，直接返回
              return courseSectionEntity;
            } else {
              ///请求失败或者锁定状态没变（没变就感觉状态异常了，理论上不应该进入这条分支），返回null
              showToast('下个课程还没解锁哦');
              return null;
            }
          });

          return result;

        }

      } else {

        ///section为空说明当前unit学完了，找下一个unit。（跨unit选section）

        ///先根据courseLessonId找出当前的unit

        final curCourseUnitDetail = findCourseUnitDetailById(courseLessonId);

        if (curCourseUnitDetail != null) {

          ///再根据当前unit的sortOrder找出下一个unit
          CourseUnitDetail? nextCourseUnitDetail =

              _courseUnitEntity.courseUnitVOList?.firstWhereOrNull((element) =>
                  element.sortOrder == (curCourseUnitDetail.sortOrder! + 1));

          if (nextCourseUnitDetail != null) {

            if (nextCourseUnitDetail.lock == true) {
              ///如果下一个unit是锁定状态，请求数据刷新查询解锁状态

              CourseSectionEntity? result = await loading(() async {

                CourseUnitEntity? newCourseUnitEntity =
                    await LessonDao.courseUnit(
                        _courseUnitEntity.nowCourseModuleId);

  
                ///拿到重新获取到的unit后，再次判断是否解锁

                nextCourseUnitDetail = newCourseUnitEntity?.courseUnitVOList
                    ?.firstWhereOrNull(

                        (element) => element.id == nextCourseUnitDetail?.id);
                if (nextCourseUnitDetail?.lock == false) {
                  ///解锁状态从锁定到解锁，覆盖原unit数据并刷新ui
                  _courseUnitEntity = newCourseUnitEntity!;

                  courseUnitEntityChanged = true;

                  emitter(LessonDataLoadState());
  

                  return checkCourseSectionLockedOfNextUnit(
                      courseLessonId, nextCourseUnitDetail!.id!, emitter);

                } else {
                  showToast('下个单元课程还没解锁哦');
  
                  ///如果还是锁定状态，返回null
                  return null;
                }

              });

              return result;

            } else {

              return checkCourseSectionLockedOfNextUnit(
                  courseLessonId, nextCourseUnitDetail.id!, emitter);

            }

          } else {

            showToast("恭喜你，本阶段学到顶啦");

            ///最后一个unit了
            return null;
          }
        } else {
          ///找不到对应的unitDetail，理论上不可能
          return null;
        }
      }

    }
  
    ///检查下一个unit的（第一个）section

    Future<CourseSectionEntity?> checkCourseSectionLockedOfNextUnit(
        int courseLessonId,
        int nextCourseUnitDetailId,

        Emitter<SectionState> emitter) async {

      CourseSectionEntity? firstSectionNextUnit =
          await getFirstSectionByUnitId(nextCourseUnitDetailId, emitter);

      if (firstSectionNextUnit != null) {
        ///下个unit的第一个section如果不为空，再次检查是否锁定

        CourseSectionEntity? courseSectionEntity = await checkCourseSectionLocked(
            courseLessonId, firstSectionNextUnit, emitter);

        if (courseSectionEntity != null) {
          ///只有是下一unit的第一个section并且解锁了，才跳转
          _pageController.nextPage(
            duration: const Duration(milliseconds: 250),
            curve: Curves.ease,
          );
        }
        return courseSectionEntity;
      } else {
        ///下个unit的第一个section如果为空，返回null
        showToast('下个课程暂未找到');
        return null;
      }
    }
  
    ///根据unitId获取当前unit的第一个section
    Future<CourseSectionEntity?> getFirstSectionByUnitId(
        int courseUnitId, Emitter<SectionState> emitter) async {
      List<CourseSectionEntity>? courseSectionEntity =
          _courseSectionDatasMap[courseUnitId];
      if (courseSectionEntity == null) {
        ///如果没下载过，请求数据
        await loading(() async {

          final courseSections =

              await LessonDao.courseSection(courseUnitId: courseUnitId);

          if (courseSections != null) {
            _courseSectionDatasMap[courseUnitId] =
                _filterReviewContent(courseSections);
          }

          emitter(LessonDataLoadState());
        });
      }
      return _courseSectionDatasMap[courseUnitId]?.first;

    }

  }