# standard imports
import io
import os
import unittest

# external imports
import PIL.Image

# bsie imports
from bsie.extractor import base
from bsie.utils import bsfs, node as _node, ns
from bsie.reader.preview import Preview as Reader

# objects to test
from bsie.extractor.preview import Preview


## code ##

class TestPreview(unittest.TestCase):
    def test_eq(self):
        # identical instances are equal
        self.assertEqual(Preview([1,2,3]), Preview([1,2,3]))
        self.assertEqual(hash(Preview([1,2,3])), hash(Preview([1,2,3])))
        # comparison respects max_sides
        self.assertNotEqual(Preview([1,2,3]), Preview([1,2]))
        self.assertNotEqual(hash(Preview([1,2,3])), hash(Preview([1,2])))
        self.assertNotEqual(Preview([1,2]), Preview([1,2,3]))
        self.assertNotEqual(hash(Preview([1,2])), hash(Preview([1,2,3])))
        # comparison respects type
        class Foo(): pass
        self.assertNotEqual(Preview([1,2,3]), Foo())
        self.assertNotEqual(hash(Preview([1,2,3])), hash(Foo()))
        self.assertNotEqual(Preview([1,2,3]), 123)
        self.assertNotEqual(hash(Preview([1,2,3])), hash(123))
        self.assertNotEqual(Preview([1,2,3]), None)
        self.assertNotEqual(hash(Preview([1,2,3])), hash(None))

    def test_schema(self):
        self.assertEqual(Preview([1,2,3]).schema,
            bsfs.schema.from_string(base.SCHEMA_PREAMBLE + '''
                bsn:Preview rdfs:subClassOf bsfs:Node .
                bsl:BinaryBlob rdfs:subClassOf bsfs:Literal .
                <https://schema.bsfs.io/ie/Literal/BinaryBlob/JPEG> rdfs:subClassOf bsl:BinaryBlob .

                bse:preview rdfs:subClassOf bsfs:Predicate ;
                    rdfs:domain bsn:Entity ;
                    rdfs:range bsn:Preview ;
                    bsfs:unique "false"^^xsd:boolean .

                bsp:width rdfs:subClassOf bsfs:Predicate ;
                    rdfs:domain bsn:Preview ;
                    rdfs:range xsd:integer ;
                    bsfs:unique "true"^^xsd:boolean .

                bsp:height rdfs:subClassOf bsfs:Predicate ;
                    rdfs:domain bsn:Preview ;
                    rdfs:range xsd:integer ;
                    bsfs:unique "true"^^xsd:boolean .

                bsp:asset rdfs:subClassOf bsfs:Predicate ;
                    rdfs:domain bsn:Preview ;
                    rdfs:range <https://schema.bsfs.io/ie/Literal/BinaryBlob/JPEG> ;
                    bsfs:unique "true"^^xsd:boolean .

                '''))

    def test_extract(self):
        # setup dependents
        rdr = Reader()
        subject = _node.Node(ns.bsn.Entity)
        path = os.path.join(os.path.dirname(__file__), 'testimage.jpg')

        # setup extractor
        ext = Preview(max_sides=[10])
        principals = set(ext.principals)
        self.assertEqual(principals, {ext.schema.predicate(ns.bse.preview)})
        # skip unknown predicates
        gen = rdr(path)
        self.assertSetEqual(set(), set(ext.extract(subject, gen,
            {ext.schema.predicate(ns.bsfs.Predicate).child(ns.bse.unknown)})))
        gen(10) # NOTE: consume some image to avoid resource error warning
        # extract a preview
        triples = set(ext.extract(subject, rdr(path), principals))
        thumbs = {node for node, _, _ in triples if node.node_type == ns.bsn.Preview}
        self.assertEqual(len(thumbs), 1)
        thumb = list(thumbs)[0]
        # test properties
        self.assertTrue(triples.issuperset({
            (subject, ext.schema.predicate(ns.bse.preview), thumb),
            (thumb, ext.schema.predicate(ns.bsp.width), 10),
            (thumb, ext.schema.predicate(ns.bsp.height), 10),
            }))
        # test image data
        rawdata = {val for _, pred, val in triples if pred == ext.schema.predicate(ns.bsp.asset)}
        self.assertEqual(len(rawdata), 1)
        data = io.BytesIO(list(rawdata)[0])
        data.seek(0)
        img = PIL.Image.open(data)
        self.assertEqual(img.size, (10, 10))
        self.assertEqual(sum(band for pix in img.getdata() for band in pix), 0)

        # setup extractor
        ext = Preview(max_sides=[10, 20])
        principals = set(ext.principals)
        self.assertEqual(principals, {ext.schema.predicate(ns.bse.preview)})
        # extract a preview
        triples = set(ext.extract(subject, rdr(path), principals))
        thumbs = {node for node, _, _ in triples if node.node_type == ns.bsn.Preview}
        self.assertEqual(len(thumbs), 2)
        self.assertSetEqual({10, 20}, {
            value for _, pred, value in triples if pred == ext.schema.predicate(ns.bsp.width)})
        self.assertSetEqual({10, 20}, {
            value for _, pred, value in triples if pred == ext.schema.predicate(ns.bsp.height)})


## main ##

if __name__ == '__main__':
    unittest.main()

## EOF ##