// Construct a SuperUrlParsers, which fetches and parses a given URL, returning metadata.
// By default, this object is configured with all existing parsers.
final parsers = const SuperUrlParsers();

// Constructs a SuperUrlDisplays, which provides a WidgetBuilder for a given metadata.
// By default, this object is configured with all existing displays.
final displays = const SuperUrlDisplays();

// Use only your desired parsers.
final customParsers = SuperUrlParsers([
    YouTubeUrlParser(),
    LoomUrlParser(),
    MediumUrlParser(),
    // etc.
]);

// Add a new parser
customParsers.add(SuperDeclarativeUrlParser());

// Remove a parser
customParsers.removeAt(1);

final customDisplays = SuperUrlDisplays([
    BlogDisplay(),
    YouTubeVideoDisplay(),
    LoomVideoDisplay(),
    // etc.
]);

// Add a new display
customDisplays.addAt(0, SuperDeclarativeBlogDisplay());

// Remove a display
customDisplays.removeAt(1);

// Ask if a given URL can be fetched and parsed.
//
// This query doesn't run a fetch or parse, it only checks if SuperUrlParsers knows
// what to do with this URL. We need to offer this query so that something like
// Super Editor doesn't try to insert a Super Embed widget for a URL that Super Embed
// can't handle.
final isUrlRecognized = urlParsers.recognizesUrl(myUrl);

// This example shows how to coordinate fetching, parsing, and display. The inside implementation
// of the drop-in SuperEmbed widget might look something like this.

try {
  final url = "some url";

  // The URL is parsed to metadata. The metadata might be a YouTubeVideoMetadata,
  // or a MediumBlogMetadata. We don't know exactly what it is.
  final metadata = await urlParsers.fetchAndParse(url);

  // SuperUrlDisplays returns a WidgetBuilder that builds a display with the given metadata.
  //
  // It's possible that we could return a Widget here instead of a WidgetBuilder. I haven't
  // thought through the consequences. But a WidgetBuilder is a safer bet because it
  // provides an opportunity to recreate the actual display widget every time it runs.
  final displayBuilder = urlDisplays.getDisplayBuilder(metadata);
} catch (exception) {
  // This example doesn't enumerate any error conditions because
  // it's focused on the happy path process to fetch, parse, and display.
}

Widget build(BuildContext context) {
  return Center(
    // Run the WidgetBuilder that we got from urlDisplays, or render empty space
    // if we don't have a builder, yet.
    child: displayBuilder?.call(context) ?? const SizedBox(),
  );
}

// When a developer wants to explicitly parse a URL for a known domain, the developer
// can instantiate and run the parser, directly.
final url = "some url";

final parser = YouTubeUrlParser();
assert(parser.recognizesUrl(url));

final metadata = await parser.fetchAndParse();

// When a developer wants to explicitly display pre-created metadata, the developer can
// use the same display widget that SuperEmbed uses.
final youtubeMetadata = YouTubeMetadata(
  // fill with desired properties
);

Widget build(BuildContext context) {
  return YouTubeVideoDisplay(
    metadata: youtubeMetadata,
  );
}

late SuperEmbedController _superEmbedController;

void initState() {
  super.initState();
  _superEmbedController = SuperEmbedController();
}

Future<void> _onUserProvidesUrl(String url) async {
  await  _superEmbedController.fetchAndDisplay(url);
}

// A drop-in widget should be available for quick and easy use of Super Embed.
Widget build(BuildContext context) {
  return Center(
    // This is the drop-in widget for SuperEmbed. Most developers will drop this
    // Widget in at a desired location without customizing parsers or displays.
    child: SuperEmbed(
      controller: _superEmbedController,
    ),
  );
}