import 'dart:io';
import 'package:file_picker/file_picker.dart';
import 'package:flutter/material.dart';
import 'package:manager_app/Components/loading_common.dart';
import 'package:manager_app/Components/message_notification.dart';
import 'package:manager_app/Models/managerContext.dart';
import 'package:manager_app/Screens/Resources/new_resource_popup.dart';
import 'package:manager_app/Screens/Resources/resource_body_grid.dart';
import 'package:manager_app/Screens/Resources/show_resource_popup.dart';
import 'package:manager_app/app_context.dart';
import 'package:manager_app/constants.dart';
import 'package:managerapi/api.dart';
import 'package:provider/provider.dart';
import 'package:http/http.dart' as http;
import 'package:flutter/foundation.dart' show kIsWeb;

class ResourcesScreen extends StatefulWidget {
  final Function onGetResult; //return ResourceDTO
  final bool isImage;
  final bool isAddButton;
  final bool isFilter;
  final List<ResourceType> resourceTypes;
  const ResourcesScreen({
    Key key,
    this.isImage = false,
    this.onGetResult,
    this.isAddButton = true,
    this.resourceTypes,
    this.isFilter = true
  }) : super(key: key);

  @override
  _ResourcesScreenState createState() => _ResourcesScreenState();
}

class _ResourcesScreenState extends State<ResourcesScreen> {
  String filter;
  bool isLoading;

  @override
  Widget build(BuildContext context) {
    final appContext = Provider.of<AppContext>(context);
    Size size = MediaQuery.of(context).size;

    return FutureBuilder(
        future: getResources(widget.onGetResult, widget.isImage, appContext, widget.resourceTypes),
        builder: (context, AsyncSnapshot<dynamic> snapshot) {
          if (snapshot.connectionState == ConnectionState.done) {
            if(snapshot.data != null) {
              var tempOutput = new List<ResourceDTO>.from(snapshot.data);
              // tempOutput.add(ResourceDTO(id: null));
              return ResourceBodyGrid(
                resources: tempOutput,
                resourceTypesIn: widget.isImage ? resource_types.where((rt) => rt.type == ResourceType.image || rt.type == ResourceType.imageUrl).map((rt) => rt.type).toList() : widget.resourceTypes,
                isAddButton: widget.isAddButton,
                onSelect: (value) async {
                  if (widget.onGetResult == null) {
                    // Main screen
                    if (value.id == null) {
                      var result = await showNewResource(appContext, context);
                      if (result != null)
                      {
                        await create(result[0], result[1], result[2], appContext, context);
                        setState(() {}); // For refresh
                      }
                    } else {
                      showResource(value, appContext, context, size);
                    }
                  } else {
                    // Result for select modal
                    widget.onGetResult(value);
                  }
                });//bodyGrid(tempOutput, size, appContext);
            } else {
              return Text("No data");
            }
          } else if (snapshot.connectionState == ConnectionState.none) {
            return Text("No data");
          } else {
            return Center(
                child: Container(
                    height: size.height * 0.2,
                    child: LoadingCommon()
                )
            );
          }
        }
    );
  }
}

Future<void> getResources(Function onGetResult, bool isImage, AppContext appContext, List<ResourceType> types) async {
  types = types != null ? types : [];
  List<ResourceDTO> resources = await (appContext.getContext() as ManagerAppContext).clientAPI.resourceApi.resourceGet(instanceId: (appContext.getContext() as ManagerAppContext).instanceId, types: types);
  if (onGetResult != null && isImage) {
    resources = resources.where((element) => element.type == ResourceType.image || element.type == ResourceType.imageUrl || element.type == ResourceType.audio).toList();
  }
  return resources;
}

Future<ResourceDTO> create(ResourceDTO resourceDTO, List<File> files, List<PlatformFile> filesWeb, AppContext appContext, context) async {
  switch(resourceDTO.type) {
    case ResourceType.audio:
    case ResourceType.image:
    case ResourceType.video:

        var request = http.MultipartRequest('POST', Uri.parse(appContext.getContext().clientAPI.resourceApi.apiClient.basePath+"/api/Resource/upload"));

        if (kIsWeb) {
          for (PlatformFile file in filesWeb) {
            request.files.add(
                await http.MultipartFile.fromBytes(
                    'picture',
                    file.bytes,
                    filename: file.name
                )
            );
          }
        } else {
          for (File file in files) {
            request.files.add(
                await http.MultipartFile(
                    'picture',
                    file.readAsBytes().asStream(),
                    file.lengthSync(),
                    filename: file.path.toString().split("/").last
                )
            );
          }
        }

        ManagerAppContext managerAppContext = appContext.getContext();
        request.headers["authorization"]="Bearer ${managerAppContext.token.accessToken}";
        request.fields['label'] = resourceDTO.label;
        request.fields['type'] = resourceDTO.type.toString();
        request.fields['instanceId'] = managerAppContext.instanceId;

        var res = await request.send();
        await res.stream.bytesToString();

        if (res.statusCode == 200) {
          showNotification(Colors.green, kWhite, 'La ressource a été créée avec succès', context, null);
          return null;
        } else {
          showNotification(kPrimaryColor, kWhite, 'Erreur, attention, la taille de la ressource doit être inférieure à 2Mb', context, null);
        }
      break;
    case ResourceType.imageUrl:
    case ResourceType.videoUrl:
      if (resourceDTO.data != null) {
        // test if Correct url
        bool _validURL = Uri.parse(resourceDTO.data).isAbsolute;
        if(_validURL) {
          resourceDTO.instanceId = (appContext.getContext() as ManagerAppContext).instanceId;
          ResourceDTO newResource = await (appContext.getContext() as ManagerAppContext).clientAPI.resourceApi.resourceCreate(resourceDTO);
          showNotification(Colors.green, kWhite, 'La ressource a été créée avec succès', context, null);

          return newResource;
        } else {
          showNotification(Colors.orange, kWhite, 'L\'url est invalide', context, null);
        }
      } else {
        showNotification(Colors.orange, kWhite, 'Veuillez remplir le champ URL', context, null);
      }
      break;
  }
}