# standard imports
import typing

# bsie imports
from bsie.matcher import nodes
from bsie.utils import bsfs, ns

# inner-module imports
from .. import base

# exports
__all__: typing.Sequence[str] = (
    'Iptc',
    )


## code ##

class Iptc(base.Extractor):
    """Turn IPTC keywords into tags."""

    CONTENT_READER = 'bsie.reader.exif.Iptc'

    def __init__(self):
        super().__init__(bsfs.schema.from_string(base.SCHEMA_PREAMBLE + '''
            bsn:Tag rdfs:subClassOf bsfs:Node .

            bse:tag rdfs:subClassOf bsfs:Predicate ;
                rdfs:domain bsn:Entity ;
                rdfs:range bsn:Tag .

            <https://schema.bsfs.io/ie/Node/Tag#label> rdfs:subClassOf bsfs:Predicate ;
                rdfs:domain bsn:Tag ;
                rdfs:range xsd:string ;
                bsfs:unique "true"^^xsd:boolean .

            '''))
        self._callmap = {
            self.schema.predicate(ns.bse.tag): self._keywords,
            }

    def extract(
            self,
            subject: nodes.Entity,
            content: dict,
            principals: typing.Iterable[bsfs.schema.Predicate],
            ) -> typing.Iterator[typing.Tuple[nodes.Node, bsfs.schema.Predicate, typing.Any]]:
        for pred in principals:
            # find callback
            clbk = self._callmap.get(pred)
            if clbk is None:
                continue
            # produce triples
            yield from clbk(subject, content)

    def _keywords(
            self,
            subject: nodes.Entity,
            content: dict,
            ) -> typing.Iterator[typing.Tuple[nodes.Node, bsfs.schema.Predicate, typing.Any]]:
        if 'Iptc.Application2.Keywords' not in content:
            return
        for keyword in content['Iptc.Application2.Keywords']:
            tag = nodes.Tag(label=keyword)
            yield subject, self.schema.predicate(ns.bse.tag), tag
            yield tag, self.schema.predicate(ns.bst.label), keyword



## EOF ##