class RequestExtension extends Extension<RequestOptions> {
  final Logger logger;

  RequestExtension({RequestOptions defaultOptions = const RequestOptions(), this.logger})
      : super(defaultOptions: defaultOptions);

  Future<BaseRequest> _resolve(
      BaseRequest original, RequestOptions options) async {
    if (original is ExtensionRequest) {
      return ExtensionRequest(
          request: await _resolve(original.request, options),
          options: original.options);
    }

    if (original.url.hasScheme) {
      return original;
    }

    if (options.queryParameters == null) {
      return original;
    }

    if (options.queryParameters.isNotEmpty) {
      final url = original.url.replace(queryParameters: options.queryParameters);

      logger?.fine('Appended Query Parameters');

      if (original is Request) {
        var result = Request(original.method, url);
        if (original.headers != null) result.headers.addAll(original.headers);
        if (original.encoding != null) result.encoding = original.encoding;
        if (original.bodyBytes != null) result.bodyBytes = original.bodyBytes;

        return result;
      }

      if (original is StreamedRequest) {
        var result = Request(original.method, url);
        if (original.headers != null) result.headers.addAll(original.headers);
        result.bodyBytes = await original.finalize().toBytes();

        return result;
      }

      throw ArgumentError(
          "Failed to resolve request of type ${original.runtimeType}");
    } else {
      return original;
    }
  }

  @override
  Future<StreamedResponse> sendWithOptions(
      BaseRequest request, RequestOptions options) async {
    request = await _resolve(request, options);
    return await super.sendWithOptions(request, options);
  }
}

class RequestOptions {
  final Map<String, String> queryParameters;

  const RequestOptions({this.queryParameters});
}

Future main() async {
  final client = ExtendedClient(
    inner: Client(),
    extensions: [
      RequestExtension(),
    ],
  );

  var response = await client.getWithOptions('my-url-string', 
    options: [RequestOptions(queryParameters: {'option1': 'value1'}]);
}

extension ExtendedClientX on ExtendedClient {
  Future<http.Response> formWithOptions(
    String url, {
    @required Map<String, dynamic> data,
    Map<String, io.File> files,
    Map<String, String> headers,
    List<dynamic> options,
  }) async {
    assert(data != null);
    final request = http.MultipartRequest("POST", Uri.parse(url));

    request.fields..addAll(_encodeFormBody(data));

    if (files != null) {
      for (final item in files.entries) {
        request.files.add(
          await http.MultipartFile.fromPath(item.key, item.value.path),
        );
      }
    }

    return sendWithOptions(
      request,
      <dynamic>[
        ...options,
        JsonRequestOptions({...headers, io.HttpHeaders.contentTypeHeader: "application/x-www-form-urlencoded"})
      ],
    ).then(http.Response.fromStream);
  }

  String encodeBody(dynamic value) => json.encode(value);

  Map<String, String> _encodeFormBody(Map<String, dynamic> data) {
    return data.map((key, dynamic value) => MapEntry(key, _isPrimitiveValue(value) ? value : encodeBody(value)));
  }

  bool _isPrimitiveValue(dynamic value) {
    return [int, double, bool, String].contains(value.runtimeType);
  }
}

class JsonRequestOptions {
  const JsonRequestOptions([this.headers = const {}]);

  final Map<String, String> headers;
}

class JsonRequestExtension extends Extension<JsonRequestOptions> {
  JsonRequestExtension([
    JsonRequestOptions defaultOptions = const JsonRequestOptions(
      {io.HttpHeaders.acceptHeader: mime, io.HttpHeaders.contentTypeHeader: mime},
    ),
  ]) : super(defaultOptions: defaultOptions);

  static const mime = "application/json";

  @override
  Future<http.StreamedResponse> sendWithOptions(http.BaseRequest request, JsonRequestOptions options) {
    final headers = Map<String, String>.from(defaultOptions.headers);
    if (options.headers != null && options.headers.isNotEmpty) {
      headers.addAll(options.headers);
    }
    if (headers.isNotEmpty) {
      request.headers.addAll(headers);
    }
    return super.sendWithOptions(request, options);
  }
}