# Copyright 2023 (c) Anna Schumaker.
"""Tests our Gdk.Texture cache."""
import emmental.texture
import os
import pathlib
import tempfile
import tests.util
import unittest
from gi.repository import Gdk


class TestTextureCache(unittest.TestCase):
    """Test our custom cache dictionary."""

    def setUpClass():
        """Clear the existing cache before testing."""
        emmental.texture.CACHE.clear()

    def setUp(self):
        """Set up common variables."""
        cover = tests.util.COVER_JPG.absolute().relative_to("/")
        self.target = emmental.texture.CACHE_PATH / cover
        self.target2 = self.target.with_name("cover2.jpg")
        self.cache = emmental.texture._TextureCache()

    def tearDown(self):
        """Clean up."""
        self.target2.unlink(missing_ok=True)
        (path := self.target).unlink(missing_ok=True)
        while (path := path.parent) != emmental.texture.CACHE_PATH:
            if path.is_dir():
                path.rmdir()

    def test_path(self):
        """Test the on-disk path of the texture cache."""
        self.assertIsInstance(emmental.texture.TEMP_DIR,
                              tempfile.TemporaryDirectory)
        self.assertEqual(emmental.texture.CACHE_PATH,
                         pathlib.Path(emmental.texture.TEMP_DIR.name))
        self.assertTrue(emmental.texture.CACHE_PATH.is_dir())

    def test_init(self):
        """Test that the cache dict is initialized properly."""
        self.assertIsInstance(emmental.texture.CACHE,
                              emmental.texture._TextureCache)
        self.assertDictEqual(emmental.texture.CACHE, {})

        self.assertIsInstance(self.cache, dict)
        self.assertDictEqual(self.cache, {})

    def test_drop(self):
        """Test dropping items from the cache."""
        self.cache[tests.util.COVER_JPG]
        self.cache.drop(tests.util.COVER_JPG)
        self.assertDictEqual(self.cache, {})
        self.assertFalse(self.target.exists())

        self.cache[tests.util.COVER_JPG]
        self.cache.clear()
        self.cache.drop(tests.util.COVER_JPG)
        self.assertFalse(self.target.exists())

    def test_getitem(self):
        """Test getting and creating items in the cache dict."""
        self.assertIsNone(self.cache[None])
        self.assertIsNone(self.cache[pathlib.Path("/no/such/path")])
        self.assertDictEqual(self.cache, {})
        self.assertListEqual(list(emmental.texture.CACHE_PATH.iterdir()), [])

        texture = self.cache[tests.util.COVER_JPG]
        self.assertIsInstance(texture, Gdk.Texture)
        self.assertDictEqual(self.cache, {tests.util.COVER_JPG: texture})
        self.assertEqual(self.cache[tests.util.COVER_JPG], texture)
        self.assertTrue(self.target.is_file())

        self.cache.clear()
        self.assertIsInstance(self.cache[tests.util.COVER_JPG], Gdk.Texture)

    def test_getitem_cache_only(self):
        """Test getting a cached item with deleted source path."""
        cover2 = tests.util.COVER_JPG.with_name("cover2.jpg")
        texture = self.cache[tests.util.COVER_JPG]
        self.cache[cover2] = texture
        del self.cache[tests.util.COVER_JPG]

        self.assertEqual(self.cache[cover2], texture)

        self.cache.clear()
        self.target.rename(self.target2)
        self.assertIsInstance(self.cache[cover2], Gdk.Texture)

    def test_mtime_update(self):
        """Test updating an item in the cache."""
        texture = self.cache[tests.util.COVER_JPG]
        os.utime(self.target, (123456789, 123456789))

        new = self.cache[tests.util.COVER_JPG]
        self.assertIsInstance(new, Gdk.Texture)
        self.assertNotEqual(new, texture)