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/Services/apiService.dart';
import 'package:mymuseum_visitapp/app_context.dart';

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

    // Update local DB - Configuration
    await DatabaseHelper.instance.insert(DatabaseTableType.configurations, ModelsHelper.configurationToMap(configuration));
    List<String> usedImageOrAudioIds = [];

    if(configuration.imageId != null) {
      ImageDTO image = ImageDTO(resourceId: configuration.imageId, source_: configuration.imageSource);
      usedImageOrAudioIds.add(configuration.imageId!);
      await ApiService.getAndDownloadImage(appContext.clientAPI, image);
    }

    List<SectionDTO>? sections = await ApiService.getAllSections(appContext.clientAPI, configuration.id!);

    if(sections!.isNotEmpty) {

      List<SectionDTO> sectionsInDB = await DatabaseHelper.instance.queryWithConfigurationId(DatabaseTableType.sections, configuration.id!);

      List<SectionDTO> sectionsToKeep = sections.where((s) => s.type == SectionType.Article).toList(); // TODO handle other type of section

      sectionsToKeep.sort((a,b) => a.order!.compareTo(b.order!));
      int newOrder = 0;
      // Update local DB - Sections
      for(var section in sectionsToKeep) {
        section.order = newOrder;
        await DatabaseHelper.instance.insert(DatabaseTableType.sections, ModelsHelper.sectionToMap(section));

        // Download section image
        if(section.imageId != null) {
          usedImageOrAudioIds.add(section.imageId!);
          await ApiService.getAndDownloadImage(appContext.clientAPI, ImageDTO(source_: section.imageSource, resourceId: section.imageId));
        }

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

        if(articleDTO != null) {
          for(var image in articleDTO.images!) {
            usedImageOrAudioIds.add(image.resourceId!);
            await ApiService.getAndDownloadImage(appContext.clientAPI, image);
          }
          if(articleDTO.audioId != null) {
            usedImageOrAudioIds.add(articleDTO.audioId!);
            await ApiService.getAndDownloadAudio(appContext.clientAPI, articleDTO.audioId!);
          }
        }
        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);
        await DatabaseHelper.instance.delete(sectionIdToRemove!, DatabaseTableType.sections);
      }

      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);
    await DatabaseHelper.instance.delete(resourceIdToRemove!, DatabaseTableType.resources);
  }

}