mymuseum-visitapp/lib/Services/downloadConfiguration.dart

import 'dart:convert';

import 'package:manager_api/api.dart';
import 'package:mymuseum_visitapp/Helpers/DatabaseHelper.dart';
import 'package:mymuseum_visitapp/Helpers/modelsHelper.dart';
import 'package:mymuseum_visitapp/Models/resourceModel.dart';
import 'package:mymuseum_visitapp/Models/visitContext.dart';
import 'package:mymuseum_visitapp/Services/apiService.dart';
import 'package:mymuseum_visitapp/app_context.dart';

class DownloadConfiguration {
  static Future<bool> download(AppContext appContext, ConfigurationDTO configuration) async {

    print("COUCOUCOU IIIIINNNN");
    ExportConfigurationDTO? exportConfigurationDTO = await ApiService.exportConfiguration(appContext.clientAPI, configuration.id!, (appContext.getContext() as VisitAppContext).language!);

    if(exportConfigurationDTO != null) {
      // Delete all from local DB ref to this configurationId then add it all

      await DatabaseHelper.instance.insert(DatabaseTableType.configurations, ModelsHelper.configurationToMap(configuration));
      List<String> usedImageOrAudioIds = [];

      var currentLanguage = (appContext.getContext() as VisitAppContext).language;

      if(configuration.imageId != null) {
        usedImageOrAudioIds.add(configuration.imageId!);

        var imageData = exportConfigurationDTO.resources!.where((element) => element.id == configuration.imageId);
        if(imageData.isNotEmpty) {
          ResourceModel resourceModel = ResourceModel(id: imageData.first.id, source: configuration.imageSource, data: imageData.first.data, type: imageData.first.type);
          try {
            await DatabaseHelper.instance.insert(DatabaseTableType.resources, resourceModel.toMap());
          } catch (e) {
            print("We got an issue inserting image data ${imageData.first.id}");
          }
        }
      }

      List<SectionDTO>? sections = exportConfigurationDTO.sections;

      if(sections!.isNotEmpty) {

        List<SectionDTO> sectionsInDB = await DatabaseHelper.instance.queryWithConfigurationId(DatabaseTableType.sections, configuration.id!);
        List<SectionDTO> sectionsToKeep = sections.where((s) => s.type == SectionType.Article || s.type == SectionType.Quizz).toList(); // TODO handle other type of section (for now, Article and Quizz)

        sectionsToKeep.sort((a,b) => a.order!.compareTo(b.order!));
        int newOrder = 0;
        // Update local DB - Sections
        for(var section in sectionsToKeep) {
          section.order = newOrder;
          try {
            await DatabaseHelper.instance.insert(DatabaseTableType.sections, ModelsHelper.sectionToMap(section));
          } catch (e) {
            print("We got an issue inserting section data ${section.id}");
          }

          // Download section image
          if(section.imageId != null) {
            usedImageOrAudioIds.add(section.imageId!);
            var imageData = exportConfigurationDTO.resources!.where((element) => element.id == section.imageId);
            if(imageData.isNotEmpty) {
              ResourceModel resourceModel = ResourceModel(id: imageData.first.id, source: section.imageSource, data: imageData.first.data, type: imageData.first.type);
              try {
                await DatabaseHelper.instance.insert(DatabaseTableType.resources, resourceModel.toMap());
              } catch (e) {
                print("We got an issue inserting image data ${imageData.first.id}");
              }
            }
          }

          // Download all images..
          ArticleDTO? articleDTO = ArticleDTO.fromJson(jsonDecode(section.data!));

          if(articleDTO != null) {
            for(var image in articleDTO.images!) {
              usedImageOrAudioIds.add(image.resourceId!);
              var imageData = exportConfigurationDTO.resources!.where((element) => element.id == image.resourceId);
              if(imageData.isNotEmpty) {
                ResourceModel resourceModel = ResourceModel(id: imageData.first.id, source: image.source_, data: imageData.first.data, type: imageData.first.type);
                try {
                  await DatabaseHelper.instance.insert(DatabaseTableType.resources, resourceModel.toMap());
                } catch (e) {
                  print("We got an issue inserting image data ${imageData.first.id}");
                }
              }
            }

            var audioIdArticle = articleDTO.audioIds!.where((audioId) => audioId.language == currentLanguage);
            if(audioIdArticle.isNotEmpty && audioIdArticle.first.value != null)
            {
              usedImageOrAudioIds.add(audioIdArticle.first.value!);
              var audioData = exportConfigurationDTO.resources!.where((element) => element.id == audioIdArticle.first.value);
              if(audioData.isNotEmpty) {
                ResourceModel resourceModel = ResourceModel(id: audioData.first.id, source: "", data: audioData.first.data, type: audioData.first.type);
                try {
                  await DatabaseHelper.instance.insert(DatabaseTableType.resources, resourceModel.toMap());
                } catch (e) {
                  print("We got an issue inserting audio data ${audioData.first.id}");

                  // Update context with not working audios
                  VisitAppContext visitAppContext = appContext.getContext() as VisitAppContext;
                  visitAppContext.audiosNotWorking.add(resourceModel);
                  visitAppContext.audiosNotWorking = visitAppContext.audiosNotWorking.toSet().toList(); // Remove duplicates
                  appContext.setContext(visitAppContext);
                }
              }
            }
          }
          newOrder = newOrder + 1;
        }

        List<String?> sectionIdsToRemove = sectionsInDB.map((s) => s.id).where((sectionId) => !sectionsToKeep.map((sk) => sk.id).contains(sectionId)).toList();

        for(var sectionIdToRemove in sectionIdsToRemove) {
          print("section with id removed");
          print(sectionIdToRemove);
          try {
            await DatabaseHelper.instance.delete(sectionIdToRemove!, DatabaseTableType.sections);
          } catch (e) {
            print("We got an issue deleting section id: ${sectionIdToRemove}");
          }
        }

        cleanLocalResources(usedImageOrAudioIds, configuration);
      }
    }
    return true;
  }
}

void cleanLocalResources(List<String> usedImageIds, ConfigurationDTO configuration) async {

  List<Map<String, dynamic>> resourcesInDB = await DatabaseHelper.instance.queryAllRows(DatabaseTableType.resources);
  List<ResourceModel> resourcesModel = [];

  for(var resource in resourcesInDB) {
    resourcesModel.add(DatabaseHelper.instance.getResourceFromDB(resource));
  }

  List<String?> resourceIdsToRemove = resourcesModel.map((r) => r.id).where((resourceId) => !usedImageIds.contains(resourceId)).toList();

  for(var resourceIdToRemove in resourceIdsToRemove) {
    print("resource with id removed ________________ !!!!!");
    print(resourceIdToRemove);
    try {
      await DatabaseHelper.instance.delete(resourceIdToRemove!, DatabaseTableType.resources);
    } catch (e) {
      print("We got an issue deleting resource id: ${resourceIdToRemove}");
    }
  }

}