def reduceAsync()

in app/controllers/ApiResult.scala [63:144]
76 lines of code
12 McCabe index (conditional complexity)

      def reduceAsync(reduce: Map[Label, Seq[D]] => Future[JsValue])(implicit
          request: RequestHeader,
          ec: ExecutionContext
      ): Future[Result] = {
        sourceData.map { mapSources =>
          val filter = ResourceFilter.fromRequest
          val filteredSources = mapSources.groupBy { case (label, _) =>
            filter.isMatch(label.origin.filterMap)
          }
          filteredSources
            .get(false)
            .foreach(falseMap =>
              if (falseMap.values.exists(_.isEmpty))
                log.warn(
                  s"The origin filter contract map has been violated: data exists in a discarded source - ${request.uri} from ${request.remoteAddress}"
                )
            )

          val sources: Map[Label, Seq[D]] =
            filteredSources.getOrElse(true, Map.empty)

          val usedLabels = sources.filter { case (_, data) =>
            data.nonEmpty
          }.keys

          val staleLabels = sources.keys.filter { label =>
            label.bestBefore.isStale
          }

          val lastUpdated: DateTime =
            usedLabels.toSeq.filterNot(_.isError).map(_.createdAt) match {
              case dates: Seq[DateTime] if dates.nonEmpty =>
                dates.min((x: DateTime, y: DateTime) => {
                  x.getMillis.compareTo(y.getMillis)
                })
              case _ => new DateTime(0)
            }

          val stale = sources.keys.exists(_.bestBefore.isStale)

          val reduceSources = reduce(sources).map { data =>
            val dataWithMods =
              if (request.getQueryString("_length").isDefined)
                addCountToJson(data)
              else data
            val json = Json.obj(
              "status" -> "success",
              "lastUpdated" -> lastUpdated,
              "stale" -> stale,
              "staleSources" -> staleLabels,
              "data" -> dataWithMods,
              "sources" -> usedLabels
            )
            request.getQueryString("_pretty") match {
              case Some(_) =>
                Results.Ok(Json.prettyPrint(json)).as(ContentTypes.JSON)
              case None => Results.Ok(json)
            }
          }(ec)
          reduceSources
        } recover {
          case ApiCallException(failure, status) =>
            Future.successful(
              Results.Status(status)(
                Json.obj(
                  "status" -> "fail",
                  "data" -> failure
                )
              )
            )
          case e: Exception =>
            Future.successful(
              Results.InternalServerError(
                Json.obj(
                  "status" -> "error",
                  "message" -> e.getMessage,
                  "stacktrace" -> e.getStackTrace.map(_.toString)
                )
              )
            )
        } get
      }