<xsl:stylesheet version="2.0" 
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
    xmlns:xs="http://www.w3.org/2001/XMLSchema"
    xmlns:rdfxslt="http://www.wsmo.org/TR/d24/d24.2/v0.1/tmp/rdfxslt"
    exclude-result-prefixes="#all"
    >


<!-- A user template can use the following (commented) root matching
     template to do a one-step XSLT processing of RDF. After this, all other
     user templates will be applied to the RDFXSLT-flattened RDF/XML input.
     The user templates should not override this '/' template here, 
     instead a template to handle the root can go for '/*'.
-->

<!--
<xsl:template match="/">
  <xsl:variable name="rdfxslt">
    <xsl:apply-templates select="/" mode="RDFXSLT"/>
  </xsl:variable>

  <xsl:apply-templates select="$rdfxslt"/>
</xsl:template>
-->


<xsl:template match="/" mode="#default RDFXSLT">
  <xsl:variable name="qualified">
    <xsl:apply-templates mode="RDFXSLT_qualify_root"/>
  </xsl:variable>
  <xsl:variable name="flattened">
    <xsl:apply-templates select="$qualified" mode="RDFXSLT_flatten_root"/>
  </xsl:variable>
  <xsl:variable name="reified">
    <xsl:apply-templates select="$flattened" mode="RDFXSLT_reify_root"/>
  </xsl:variable>
  <xsl:apply-templates select="$reified" mode="RDFXSLT_group_root"/>
</xsl:template>


<!-- TEMPLATE: qualify - putting unqualified RDF attributes into RDF namespace -->
<!-- ID, about, resource, parseType, type attributes don't need RDF prefix -->

<xsl:template match="attribute()[namespace-uri() = '' and local-name() = ('ID', 'about', 'resource', 'type', 'parseType')]" 
    mode="RDFXSLT_qualify_root">
  <xsl:attribute name="rdf:{local-name()}" select="."/>
</xsl:template>
  

<xsl:template match="@*|node()" mode="RDFXSLT_qualify_root">
  <xsl:copy>
    <xsl:apply-templates select="@*|node()" mode="#current"/>
  </xsl:copy>
</xsl:template>


<!-- TEMPLATE: flatten - put the RDF in a flat structure: rdf:RDF/rdf:Description/properties -->

<xsl:template match="/*" mode="RDFXSLT_flatten_root">
  <rdf:RDF>
    <!-- copy RDF attributes because they are likely useful on the root -->
    <xsl:if test="@xml:lang">
      <xsl:copy-of select="@xml:lang"/>
    </xsl:if>
    <xsl:if test="@xml:space">
      <xsl:copy-of select="@xml:space"/>
    </xsl:if>
    <xsl:if test="@xml:base">
      <xsl:copy-of select="@xml:base"/>
    </xsl:if>

    <xsl:for-each select="namespace::node()">
      <xsl:copy/>
    </xsl:for-each>
    <xsl:choose>
      <xsl:when test="self::rdf:RDF">
        <xsl:apply-templates select='*' mode="RDFXSLT_node_element"/>
      </xsl:when>
      <xsl:otherwise>
        <xsl:apply-templates select='.' mode="RDFXSLT_node_element"/>
      </xsl:otherwise>
    </xsl:choose>
  </rdf:RDF>
</xsl:template>


<xsl:template match="*" mode="RDFXSLT_node_element">
  <xsl:param name="property_and_node_element" as="xs:boolean" select="false()" required="no"/>

  <rdf:Description>
    <!-- copy XML attributes that should be kept -->
    <xsl:if test="string((ancestor-or-self::*/@xml:space)[last()]) != string(/*/@xml:space)">
      <xsl:copy-of select="(ancestor-or-self::*/@xml:space)[last()]"/>
    </xsl:if>
    <xsl:if test="string((ancestor-or-self::*/@xml:lang)[last()]) != string(/*/@xml:lang)">
      <xsl:copy-of select="(ancestor-or-self::*/@xml:lang)[last()]"/>
    </xsl:if>
    <xsl:if test="base-uri(.) != base-uri(/*)">
      <xsl:attribute name="xml:base" select="base-uri(.)"/>
    </xsl:if>

    <!-- set the resource or node id -->
    <xsl:choose>
      <xsl:when test="not($property_and_node_element) and @rdf:ID">
        <xsl:attribute name="rdf:about" select="resolve-uri(concat('#', @rdf:ID), base-uri())"/>
      </xsl:when>
      <xsl:when test="$property_and_node_element and @rdf:resource">
        <xsl:attribute name="rdf:about" select="resolve-uri(@rdf:resource, base-uri())"/>
      </xsl:when>
      <xsl:when test="@rdf:about">
        <xsl:attribute name="rdf:about" select="resolve-uri(@rdf:about, base-uri())"/>
      </xsl:when>
      <xsl:when test="@rdf:nodeID">
        <xsl:copy-of select="@rdf:nodeID"/>
      </xsl:when>
      <xsl:otherwise>
        <xsl:attribute name="rdf:nodeID" select="generate-id(.)"/>
      </xsl:otherwise>
    </xsl:choose>

    <!-- add type membership for <ex:Class> typed node elements -->
    <xsl:if test="not($property_and_node_element) and (node-name(.) != xs:QName('rdf:Description'))">
      <rdf:type rdf:resource="{concat(namespace-uri(.), local-name(.))}"/>
    </xsl:if>

    <!-- move property attributes to property elements -->
    <xsl:for-each select="./@*[not(rdfxslt:reserved_rdf_property_attribute_name(.)) and node-name(.) ne xs:QName('rdf:type')]">
      <xsl:element name="{node-name(.)}" namespace="{namespace-uri(.)}">
        <xsl:value-of select="."/>
      </xsl:element>
    </xsl:for-each>

    <xsl:if test="@rdf:type">
      <rdf:type rdf:resource="{resolve-uri(@rdf:type, base-uri())}"/>
    </xsl:if>

    <xsl:apply-templates select="*" mode="RDFXSLT_property_element_in_rdfdescription"/>
  </rdf:Description>
    
  <!-- add rdf:Description for type of <ex:Class> typed node elements -->
  <xsl:if test="not($property_and_node_element) and (node-name(.) != xs:QName('rdf:Description'))">
    <rdf:Description rdf:about="{concat(namespace-uri(.), local-name(.))}"/>
  </xsl:if>

  <xsl:apply-templates select="*" mode="RDFXSLT_property_element_move_value_outside_rdfdescription"/>
</xsl:template>


<xsl:template match="*" mode="RDFXSLT_property_element_in_rdfdescription">
<!-- warning not necessary, todo documentation must mention this 
  <xsl:if test="namespace-uri() eq 'http://www.w3.org/1999/02/22-rdf-syntax-ns#' and local-name() eq 'li' or starts-with(local-name(), '_')">
    <xsl:message>WARNING: properties rdf:li change to rdf:_n, but rdfxslt:value also finds them as rdf:li.</xsl:message>
  </xsl:if>
-->

  <xsl:choose>
    <xsl:when test="@rdf:parseType eq 'Literal' or (@rdf:parseType ne 'Resource' and @rdf:parseType ne 'Collection') or (not(@rdf:parseType) and not(*) and normalize-space(./text()))">
      <xsl:copy-of select="."/>
    </xsl:when>
    <xsl:when test="@rdf:nodeID">
      <xsl:copy>
        <xsl:copy-of select="@rdf:nodeID"/>
        <xsl:copy-of select="@rdf:ID"/>
        <xsl:if test="base-uri(.) != base-uri(..)">
          <xsl:attribute name="xml:base" select="base-uri(.)"/>
        </xsl:if>
      </xsl:copy>
    </xsl:when>
    <xsl:when test="@rdf:resource">
      <xsl:copy>
        <xsl:attribute name="rdf:resource" select="resolve-uri(@rdf:resource, base-uri())"/>
        <xsl:copy-of select="@rdf:ID"/>
        <xsl:if test="base-uri(.) != base-uri(..)">
          <xsl:attribute name="xml:base" select="base-uri(.)"/>
        </xsl:if>
      </xsl:copy>
    </xsl:when>
    <xsl:when test="@rdf:parseType eq 'Resource' or @rdf:parseType eq 'Collection' and *">
      <xsl:copy>
        <xsl:attribute name="rdf:nodeID" select="generate-id(.)"/>
        <xsl:copy-of select="@rdf:ID"/>
        <xsl:if test="base-uri(.) != base-uri(..)">
          <xsl:attribute name="xml:base" select="base-uri(.)"/>
        </xsl:if>
      </xsl:copy>
    </xsl:when>
    <xsl:when test="@rdf:parseType eq 'Collection'">
      <xsl:copy>
        <xsl:attribute name="rdf:resource" select="'http://www.w3.org/1999/02/22-rdf-syntax-ns#nil'"/>
        <xsl:copy-of select="@rdf:ID"/>
        <xsl:if test="base-uri(.) != base-uri(..)">
          <xsl:attribute name="xml:base" select="base-uri(.)"/>
        </xsl:if>
      </xsl:copy>
    </xsl:when>
    <xsl:when test="@*[not(rdfxslt:reserved_rdf_property_attribute_name(.))]">
      <xsl:copy>
        <xsl:attribute name="rdf:nodeID" select="generate-id(.)"/>
        <xsl:copy-of select="@rdf:ID"/>
        <xsl:if test="base-uri(.) != base-uri(..)">
          <xsl:attribute name="xml:base" select="base-uri(.)"/>
        </xsl:if>
      </xsl:copy>
    </xsl:when>
    <xsl:when test="not(*)">
      <xsl:copy-of select="."/>
    </xsl:when>
    <xsl:when test="count(*) gt 1">
      <xsl:message terminate="yes">ERROR: element <xsl:value-of select="node-name(.)"/> should not have multiple children!</xsl:message>
    </xsl:when>
    <xsl:otherwise>
      <xsl:copy>
        <xsl:for-each select="*">
          <xsl:choose>
            <xsl:when test="@rdf:about">
              <xsl:attribute name="rdf:resource" select="resolve-uri(@rdf:about, base-uri())"/>
            </xsl:when>
            <xsl:when test="@rdf:ID">
              <xsl:attribute name="rdf:resource" select="resolve-uri(concat('#', @rdf:ID), base-uri())"/>
            </xsl:when>
            <xsl:when test="@rdf:nodeID">
              <xsl:attribute name="rdf:nodeID" select="@rdf:nodeID"/>
            </xsl:when>
            <xsl:otherwise>
              <xsl:attribute name="rdf:nodeID" select="generate-id(.)"/>
            </xsl:otherwise>
          </xsl:choose>
        </xsl:for-each>
        <xsl:copy-of select="@rdf:ID"/>
        <xsl:if test="base-uri(.) != base-uri(..)">
          <xsl:attribute name="xml:base" select="base-uri(.)"/>
        </xsl:if>
      </xsl:copy>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>


<xsl:template match="*" mode="RDFXSLT_property_element_move_value_outside_rdfdescription">
  <xsl:choose>
    <xsl:when test="@rdf:parseType eq 'Literal' or (@rdf:parseType ne 'Resource' and @rdf:parseType ne 'Collection') or (not(@rdf:parseType) and not(*) and normalize-space(./text()))">
      <!-- do nothing here -->
    </xsl:when>
    <xsl:when test="@rdf:parseType eq 'Collection' and *">
      <xsl:apply-templates select="." mode="RDFXSLT_property_collection_element"/>
    </xsl:when>
    <xsl:when test="@rdf:parseType eq 'Resource' or 
                    @*[not(rdfxslt:reserved_rdf_property_attribute_name(.))]">
      <xsl:apply-templates select="." mode="RDFXSLT_node_element">
        <xsl:with-param name="property_and_node_element" select="true()"/>
      </xsl:apply-templates>
    </xsl:when>
    <xsl:when test="*">
      <xsl:apply-templates select="*" mode="RDFXSLT_node_element"/>
    </xsl:when>
    <xsl:when test="@rdf:nodeID">
      <rdf:Description rdf:nodeID="{@rdf:nodeID}"/>
    </xsl:when>
    <xsl:when test="@rdf:resource">
      <rdf:Description rdf:about="{resolve-uri(@rdf:resource, base-uri())}"/>
    </xsl:when>
  </xsl:choose>
</xsl:template>


<xsl:template match="*" mode="RDFXSLT_property_collection_element">
  <rdf:Description rdf:nodeID="{generate-id(.)}">
    <rdf:first>
      <xsl:for-each select="*[1]">
        <xsl:choose>
          <xsl:when test="@rdf:ID">
            <xsl:attribute name="rdf:resource" select="resolve-uri(concat('#', @rdf:ID), base-uri())"/>
          </xsl:when>
          <xsl:when test="@rdf:about">
            <xsl:attribute name="rdf:resource" select="resolve-uri(@rdf:about, base-uri())"/>
          </xsl:when>
          <xsl:when test="@rdf:nodeID">
            <xsl:copy-of select="@rdf:nodeID"/>
          </xsl:when>
          <xsl:otherwise>
            <xsl:attribute name="rdf:nodeID" select="generate-id(.)"/>
          </xsl:otherwise>
        </xsl:choose>
      </xsl:for-each>
    </rdf:first>
    <rdf:rest>
      <xsl:choose>
        <xsl:when test="*[2]">
          <xsl:attribute name="rdf:nodeID" select="concat(generate-id(.), '_', generate-id(*[2]))"/>
        </xsl:when>
        <xsl:otherwise>
          <xsl:attribute name="rdf:resource" select="'http://www.w3.org/1999/02/22-rdf-syntax-ns#nil'"/>
        </xsl:otherwise>
      </xsl:choose>
    </rdf:rest>
  </rdf:Description>
  <xsl:apply-templates select="*[1]" mode="RDFXSLT_node_element"/>
  <xsl:call-template name="RDFXSLT_create_list_rest">
    <xsl:with-param name="parent_el" select="."/>
    <xsl:with-param name="node_el" select="*[2]"/>
  </xsl:call-template>
</xsl:template>


<xsl:template name="RDFXSLT_create_list_rest">
  <xsl:param name="parent_el" required="yes"/>
  <xsl:param name="node_el" required="yes"/>

  <rdf:Description rdf:nodeID="{generate-id($parent_el)}_{generate-id($node_el)}">
    <rdf:first>
      <xsl:for-each select="$node_el">
        <xsl:choose>
          <xsl:when test="@rdf:ID">
            <xsl:attribute name="rdf:resource" select="resolve-uri(concat('#', @rdf:ID), base-uri())"/>
          </xsl:when>
          <xsl:when test="@rdf:about">
            <xsl:attribute name="rdf:resource" select="resolve-uri(@rdf:about, base-uri())"/>
          </xsl:when>
          <xsl:when test="@rdf:nodeID">
            <xsl:copy-of select="@rdf:nodeID"/>
          </xsl:when>
          <xsl:otherwise>
            <xsl:attribute name="rdf:nodeID" select="generate-id(.)"/>
          </xsl:otherwise>
        </xsl:choose>
      </xsl:for-each>
    </rdf:first>
    <rdf:rest>
      <xsl:choose>
        <xsl:when test="$node_el/following-sibling::*">
          <xsl:attribute name="rdf:nodeID" select="concat(generate-id($parent_el), '_', generate-id($node_el/following-sibling::*[1]))"/>
        </xsl:when>
        <xsl:otherwise>
          <xsl:attribute name="rdf:resource" select="'http://www.w3.org/1999/02/22-rdf-syntax-ns#nil'"/>
        </xsl:otherwise>
      </xsl:choose>
    </rdf:rest>
  </rdf:Description>
  <xsl:apply-templates select="$node_el" mode="RDFXSLT_node_element"/>
  <xsl:if test="$node_el/following-sibling::*">
    <xsl:call-template name="RDFXSLT_create_list_rest">
      <xsl:with-param name="parent_el" select="$parent_el"/>
      <xsl:with-param name="node_el" select="$node_el/following-sibling::*[1]"/>
    </xsl:call-template>
  </xsl:if>
</xsl:template>


<xsl:function name="rdfxslt:reserved_rdf_name" as="xs:boolean">
  <xsl:param name="node" />

  <xsl:choose>
    <xsl:when test="namespace-uri($node) eq 'http://www.w3.org/XML/1998/namespace'">
      <xsl:value-of select="true()"/>
    </xsl:when>
    <xsl:when test="namespace-uri($node) ne 'http://www.w3.org/1999/02/22-rdf-syntax-ns#'">
      <xsl:value-of select="false()"/>
    </xsl:when>
    <xsl:when test="local-name($node) = ('RDF', 'ID', 'about', 'resource', 'nodeID', 'parseType', 'datatype', 'aboutEach', 'aboutEachPrefix', 'bagID')">
      <xsl:value-of select="true()"/>
    </xsl:when>
  </xsl:choose>
</xsl:function>

<xsl:function name="rdfxslt:reserved_rdf_node_element_name" as="xs:boolean">
  <xsl:param name="node" />

  <xsl:value-of select="rdfxslt:reserved_rdf_name($node) or 
                    namespace-uri($node) eq 'http://www.w3.org/1999/02/22-rdf-syntax-ns#' and
                    local-name($node) = 'li'"/>
</xsl:function>

<xsl:function name="rdfxslt:reserved_rdf_property_element_name" as="xs:boolean">
  <xsl:param name="node" />

  <xsl:value-of select="rdfxslt:reserved_rdf_name($node) or 
                    namespace-uri($node) eq 'http://www.w3.org/1999/02/22-rdf-syntax-ns#' and
                    local-name($node) = 'Description'"/>
</xsl:function>

<xsl:function name="rdfxslt:reserved_rdf_property_attribute_name" as="xs:boolean">
  <xsl:param name="node" />

  <xsl:value-of select="rdfxslt:reserved_rdf_name($node) or 
                    namespace-uri($node) eq 'http://www.w3.org/1999/02/22-rdf-syntax-ns#' and
                    local-name($node) = ('Description', 'li')"/>
</xsl:function>


<!-- TEMPLATE: reify - add triples for reified statements (property nodes with rdf:ID), drop the rdf:IDs -->

<xsl:template match="/*" mode="RDFXSLT_reify_root">
  <xsl:copy>
    <xsl:copy-of select="attribute::*"/>
    <xsl:apply-templates select="*" mode="RDFXSLT_reify_identity"/>
    <xsl:for-each select="rdf:Description/*[@rdf:ID]">
      <rdf:Description rdf:about="{resolve-uri(concat('#', @rdf:ID), base-uri())}">
        <rdf:type rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#Statement"/>
        <rdf:subject>
          <xsl:choose>
            <xsl:when test="../@rdf:about">
              <xsl:attribute name="rdf:resource" select="../@rdf:about"/>
            </xsl:when>
            <xsl:otherwise>
              <xsl:copy-of select="../@rdf:nodeID"/>
            </xsl:otherwise>
          </xsl:choose>
        </rdf:subject>
        <rdf:predicate>
          <xsl:choose>
            <xsl:when test="self::rdf:li">
              <xsl:attribute name="rdf:resource" select="concat(namespace-uri(), '_', count(preceding-sibling::rdf:li)+1)"/>
            </xsl:when>
            <xsl:otherwise>
              <xsl:attribute name="rdf:resource" select="concat(namespace-uri(), local-name())"/>
            </xsl:otherwise>
          </xsl:choose>
        </rdf:predicate>
        <rdf:object>
          <xsl:copy-of select="namespace::*, attribute::*[node-name(.) ne xs:QName('rdf:ID')]"/>
          <xsl:copy-of select="node()"/>
        </rdf:object>
      </rdf:Description>
    </xsl:for-each>
  </xsl:copy>
</xsl:template>

<xsl:template match="rdf:Description/*/@rdf:ID" mode="RDFXSLT_reify_identity">
  <!-- drop these, no longer necessary -->
</xsl:template>

<xsl:template match="@*|node()" mode="RDFXSLT_reify_identity">
  <xsl:copy>
    <xsl:apply-templates select="@*|node()" mode="#current"/>
  </xsl:copy>
</xsl:template>


<!-- TEMPLATE: group - group statements by subject, merging their rdf:Description elements 
                     - this also changes all rdf:li to rdf:_n, and sorts them
-->

<xsl:template match="/*" mode="RDFXSLT_group_root">
  <xsl:copy>
    <xsl:copy-of select="attribute::*"/>
    <xsl:for-each-group select="rdf:Description" group-by="@rdf:about, @rdf:nodeID">
      <rdf:Description>
        <xsl:copy-of select="namespace::*, attribute::*"/>

        <xsl:perform-sort>
          <xsl:sort stable="yes" data-type="number" 
                    select="if (namespace-uri() = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#' and 
                                starts-with(local-name(), '_')) 
                            then (substring(local-name(), 2))
                            else ('INF')"/>

          <xsl:for-each select="current-group()/*">
            <xsl:choose>
              <xsl:when test="self::rdf:li">
                <xsl:element name="rdf:{concat('_', count(preceding-sibling::rdf:li)+1)}">
                  <xsl:copy-of select="namespace::*|@*"/>
                  <xsl:call-template name="RDFXSLT_add_xml_attributes"/>
                  <xsl:copy-of select="node()"/>
                </xsl:element>
              </xsl:when>
              <xsl:otherwise>
                <xsl:copy>
                  <xsl:copy-of select="namespace::*|@*"/>
                  <xsl:call-template name="RDFXSLT_add_xml_attributes"/>
                  <xsl:copy-of select="node()"/>
                </xsl:copy>
              </xsl:otherwise>
            </xsl:choose>
          </xsl:for-each>
        </xsl:perform-sort>
      </rdf:Description>
    </xsl:for-each-group>
  </xsl:copy>
</xsl:template>

<!-- deal with things that these kids can have different from their parent rdf:Descriptions -->
<xsl:template name="RDFXSLT_add_xml_attributes">
  <xsl:choose>
    <xsl:when test="ancestor-or-self::*/@xml:space and string((ancestor-or-self::*/@xml:space)[last()]) != string((current-group()[1]/ancestor-or-self::*/@xml:space)[last()])">
      <xsl:copy-of select="(ancestor-or-self::*/@xml:space)[last()]"/>
    </xsl:when>
    <xsl:when test="not(ancestor-or-self::*/@xml:space) and string((ancestor-or-self::*/@xml:space)[last()]) != string((current-group()[1]/ancestor-or-self::*/@xml:space)[last()])">
      <xsl:attribute name="xml:space" select="'default'"/>
    </xsl:when>
    <xsl:when test="ancestor-or-self::*/@xml:lang and string((ancestor-or-self::*/@xml:lang)[last()]) != string((current-group()[1]/ancestor-or-self::*/@xml:lang)[last()])">
      <xsl:copy-of select="(ancestor-or-self::*/@xml:lang)[last()]"/>
    </xsl:when>
    <xsl:when test="not(ancestor-or-self::*/@xml:lang) and string((ancestor-or-self::*/@xml:lang)[last()]) != string((current-group()[1]/ancestor-or-self::*/@xml:lang)[last()])">
      <xsl:attribute name="xml:lang" select="''"/>
    </xsl:when>
  </xsl:choose>
</xsl:template>


</xsl:stylesheet>

<!-- vim:tw=0:sts=2:sw=2:indentexpr=:
-->