RDF/XML

// Integration with RdfCore for multi-format support
import 'package:locorda_rdf_core/core.dart';
import 'package:locorda_rdf_xml/xml.dart';

void main() {
  // Register RDF/XML codec with RdfCore
  final rdfCore = RdfCore.withStandardCodecs(
    additionalCodecs: [RdfXmlCodec()],
  );

  final xmlContent = '''
    <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
             xmlns:foaf="http://xmlns.com/foaf/0.1/">
      <foaf:Person rdf:about="http://example.org/alice">
        <foaf:name>Alice</foaf:name>
        <foaf:knows>
          <foaf:Person>
            <foaf:name>Bob</foaf:name>
          </foaf:Person>
        </foaf:knows>
      </foaf:Person>
    </rdf:RDF>
  ''';

  // Decode from RDF/XML
  final graph = rdfCore.decode(
    xmlContent,
    contentType: 'application/rdf+xml',
  );

  print('Decoded ${graph.size} triples');

  // Convert to Turtle format
  final turtle = rdfCore.encode(graph, contentType: 'text/turtle');
  print('\nAs Turtle:\n$turtle');

  // Convert to N-Triples format
  final ntriples = rdfCore.encode(graph, contentType: 'application/n-triples');
  print('\nAs N-Triples:\n$ntriples');
}

// Configuration options for RDF/XML encoding and decoding
import 'package:locorda_rdf_core/core.dart';
import 'package:locorda_rdf_xml/xml.dart';

void main() {
  final graph = RdfGraph.fromTriples([
    Triple(
      const IriTerm('http://example.org/resource'),
      const IriTerm('http://purl.org/dc/elements/1.1/title'),
      LiteralTerm.string('Example Resource'),
    ),
  ]);

  // Readable output with pretty printing
  print('=== READABLE (pretty-printed) ===');
  final readable = RdfXmlCodec.readable().encode(graph);
  print(readable);

  // Compact output for minimal size
  print('\n=== COMPACT (minimal whitespace) ===');
  final compact = RdfXmlCodec.compact().encode(graph);
  print(compact);

  // Custom configuration
  print('\n=== CUSTOM CONFIGURATION ===');
  final custom = RdfXmlCodec(
    encoderOptions: RdfXmlEncoderOptions(
      prettyPrint: true,
      indentSpaces: 2,
      useTypedNodes: true,
      customPrefixes: {
        'dcelems': 'http://purl.org/dc/elements/1.1/',
        'ex': 'http://example.org/',
      },
    ),
  ).encode(graph);
  print(custom);

  // Strict vs lenient parsing
  print('\n=== PARSING MODES ===');
  print('Strict mode: validates strictly against W3C spec');
  print('Lenient mode: tolerates common RDF/XML variations');
  print('Use RdfXmlCodec.strict() or RdfXmlCodec.lenient() to create codecs');
}

// Base URI handling for relative URIs in RDF/XML
import 'package:locorda_rdf_core/core.dart';
import 'package:locorda_rdf_xml/xml.dart';

void main() {
  final graph = RdfGraph.fromTriples([
    Triple(
      const IriTerm('http://example.org/docs/document'),
      const IriTerm('http://purl.org/dc/elements/1.1/title'),
      LiteralTerm.string('My Document'),
    ),
    Triple(
      const IriTerm('http://example.org/docs/images/photo.jpg'),
      const IriTerm('http://purl.org/dc/elements/1.1/title'),
      LiteralTerm.string('Photo'),
    ),
  ]);

  final baseUri = 'http://example.org/docs/';

  // Scenario 1: With base URI - URIs are relativized AND xml:base is included
  // Output: xml:base="http://example.org/docs/" rdf:about="document"
  print('=== SCENARIO 1: With baseUri + xml:base declaration (default) ===');
  final withBase = rdfxml.encode(graph, baseUri: baseUri);
  print(withBase);

  // Scenario 2: With base URI but no declaration - URIs are relativized but xml:base is omitted
  // Output: (no xml:base) rdf:about="document"
  // ⚠️ WARNING: Parsing such documents requires providing documentUrl to resolve relative URIs!
  print('\n=== SCENARIO 2: With baseUri but WITHOUT xml:base declaration ===');
  final withoutBase = RdfXmlCodec(
    encoderOptions: RdfXmlEncoderOptions(
      includeBaseDeclaration: false,
    ),
  ).encode(graph, baseUri: baseUri);
  print(withoutBase);

  // Scenario 3: Without base URI - all URIs remain absolute
  // Output: (no xml:base) rdf:about="http://example.org/docs/document"
  print('\n=== SCENARIO 3: WITHOUT baseUri (absolute URIs) ===');
  final withoutBaseUri = rdfxml.encode(graph); // No baseUri parameter
  print(withoutBaseUri);

  // Parsing with base URI
  print('\n=== PARSING: Relative URIs with xml:base ===');
  final xmlWithRelative = '''
    <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
             xmlns:dc="http://purl.org/dc/elements/1.1/"
             xml:base="http://example.org/docs/">
      <rdf:Description rdf:about="document">
        <dc:title>Relative URI Example</dc:title>
      </rdf:Description>
    </rdf:RDF>
  ''';

  final parsed = rdfxml.decode(xmlWithRelative);
  print('Parsed ${parsed.size} triple(s):');
  for (final triple in parsed.triples) {
    print('  $triple');
  }
}

// XML Entities support in RDF/XML
import 'package:locorda_rdf_xml/xml.dart';

void main() {
  // RDF/XML with DOCTYPE entity declarations
  final xmlWithEntities = '''
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE rdf:RDF [
    <!ENTITY xsd "http://www.w3.org/2001/XMLSchema#" >
    <!ENTITY lcc-cr "https://www.omg.org/spec/LCC/Countries/CountryRepresentation/" >
    <!ENTITY owl "http://www.w3.org/2002/07/owl#" >
    <!ENTITY rdfs "http://www.w3.org/2000/01/rdf-schema#" >
    <!ENTITY skos "http://www.w3.org/2004/02/skos/core#" >
]>
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
         xmlns:owl="&owl;"
         xmlns:rdfs="&rdfs;"
         xmlns:skos="&skos;">
  <owl:ObjectProperty rdf:about="&lcc-cr;classifies">
    <rdfs:label>classifies</rdfs:label>
    <skos:definition rdf:datatype="&xsd;string">arranges in categories according to shared characteristics</skos:definition>
    <rdfs:isDefinedBy rdf:resource="&lcc-cr;" />
  </owl:ObjectProperty>
</rdf:RDF>
  ''';

  print('=== PARSING RDF/XML WITH XML ENTITIES ===\n');

  // Parse the RDF/XML with entities
  final graph = rdfxml.decode(xmlWithEntities);

  print('Parsed ${graph.size} triples:\n');
  for (final triple in graph.triples) {
    print('  $triple');
  }

  print('\n=== ENTITY EXPANSION ===');
  print('Entities like &xsd; and &lcc-cr; are automatically expanded');
  print('to their full URIs during parsing.');
  print('\nExample:');
  print('  &xsd;string → http://www.w3.org/2001/XMLSchema#string');
  print(
      '  &lcc-cr;classifies → https://www.omg.org/spec/LCC/Countries/CountryRepresentation/classifies');

  print('\n⚠️ Note: XML entities are supported for PARSING only.');
  print('When encoding RDF to XML, full URIs are used (no entity references).');
}