import os
import shutil
import tempfile
import unittest

import pkg_resources

from medacy.data.annotations import Annotations
from medacy.data.dataset import Dataset
from medacy.tests.sample_data import test_dir


class TestAnnotation(unittest.TestCase):
    """Tests for medacy.data.annotations.Annotations"""

    @classmethod
    def setUpClass(cls):
        """Loads sample dataset and sets up a temporary directory for IO tests"""
        cls.test_dir = tempfile.mkdtemp()  # set up temp directory
        cls.sample_data_dir = os.path.join(test_dir, 'sample_dataset_1')
        cls.dataset = Dataset(cls.sample_data_dir)
        cls.entities = cls.dataset.get_labels(as_list=True)

        with open(os.path.join(cls.test_dir, "broken_ann_file.ann"), 'w') as f:
            f.write("This is clearly not a valid ann file")

        cls.ann_path_1 = cls.dataset.data_files[0].ann_path
        cls.ann_path_2 = cls.dataset.data_files[1].ann_path

    @classmethod
    def tearDownClass(cls):
        """Removes test temp directory and deletes all files"""
        pkg_resources.cleanup_resources()
        shutil.rmtree(cls.test_dir)

    def _test_is_sorted(self, ann):
        expected = sorted([e[1] for e in ann])
        actual = [e[1] for e in ann]
        self.assertListEqual(actual, expected)

    def test_init_from_ann_file(self):
        """Tests initialization from valid ann file"""
        ann = Annotations(self.ann_path_1)
        self._test_is_sorted(ann)

    def test_init_from_invalid_ann(self):
        """Tests initialization from invalid annotation file"""
        with self.assertRaises(FileNotFoundError):
            Annotations("not_a_file_path")

    def test_init_tuples(self):
        """Tests the creation of individual annotation tuples, including ones with non-contiguous spans"""
        temp_path = os.path.join(self.test_dir, 'tuples.ann')

        samples = [
            ("T1\tObject 66 77\tthis is some text\n", ('Object', 66, 77, 'this is some text')),
            ("T2\tEntity 44 55;66 77\tI love NER\n", ('Entity', 44, 77, 'I love NER')),
            ("T3\tThingy 66 77;88 99;100 188\tthis is some sample text\n", ('Thingy', 66, 188, 'this is some sample text'))
        ]

        for string, expected in samples:
            with open(temp_path, 'w') as f:
                f.write(string)

            resulting_ann = Annotations(temp_path)
            actual = resulting_ann.annotations[0]
            self.assertTupleEqual(actual, expected)

    def test_ann_conversions(self):
        """Tests converting and un-converting a valid Annotations object to an ANN file."""
        self.maxDiff = None
        annotations = Annotations(self.ann_path_1)
        temp_path = os.path.join(self.test_dir, "intermediary.ann")
        annotations.to_ann(write_location=temp_path)
        annotations2 = Annotations(temp_path)
        self.assertListEqual(annotations.annotations, annotations2.annotations)

    def test_difference(self):
        """Tests that when a given Annotations object uses the diff() method with another Annotations object created
        from the same source file, that it returns an empty list."""
        ann = Annotations(self.ann_path_1)
        result = ann.difference(ann)
        self.assertFalse(result)

    def test_different_file_diff(self):
        """Tests that when two different files are used in the difference method, the output is a list with more than
        one value."""
        ann_1 = Annotations(self.ann_path_1)
        ann_2 = Annotations(self.ann_path_2)
        result = ann_1.difference(ann_2)
        self.assertGreater(len(result), 0)

    def test_compute_ambiguity(self):
        ann_1 = Annotations(self.ann_path_1)
        ann_1_copy = Annotations(self.ann_path_1)
        ambiguity = ann_1.compute_ambiguity(ann_1_copy)
        # The number of overlapping spans for the selected ann file is known to be 25
        self.assertEqual(25, len(ambiguity))
        # Manually introduce ambiguity by changing the name of an entity in the copy
        first_tuple = ann_1_copy.annotations[0]
        ann_1_copy.annotations[0] = ('different_name', first_tuple[1], first_tuple[2], first_tuple[3])
        ambiguity = ann_1.compute_ambiguity(ann_1_copy)
        # See if this increased the ambiguity score by one
        self.assertEqual(26, len(ambiguity))

    def test_confusion_matrix(self):
        ann_1 = Annotations(self.ann_path_1)
        ann_2 = Annotations(self.ann_path_2)
        ann_1.add_entity(*ann_2.annotations[0])
        self.assertEqual(len(ann_1.compute_confusion_matrix(ann_2, self.entities)[0]), len(self.entities))
        self.assertEqual(len(ann_1.compute_confusion_matrix(ann_2, self.entities)), len(self.entities))

    def test_intersection(self):
        ann_1 = Annotations(self.ann_path_1)
        ann_2 = Annotations(self.ann_path_2)
        ann_1.add_entity(*ann_2.annotations[0])
        ann_1.add_entity(*ann_2.annotations[1])
        expected = {ann_2.annotations[0], ann_2.annotations[1]}
        actual = ann_1.intersection(ann_2)
        self.assertSetEqual(actual, expected)

    def test_compute_counts(self):
        ann_1 = Annotations(self.ann_path_1)
        self.assertIsInstance(ann_1.compute_counts(), dict)

    def test_or(self):
        """
        Tests that the pipe operator correctly merges two Annotations and retains the source text path of
        the left operand
        """
        tup_1 = ('Object', 66, 77, 'this is some text')
        tup_2 = ('Entity', 44, 77, 'I love NER')
        tup_3 = ('Thingy', 66, 188, 'this is some sample text')
        file_name = 'some_file'

        ann_1 = Annotations([tup_1, tup_2], source_text_path=file_name)
        ann_2 = Annotations([tup_3])

        for a in [ann_1, ann_2]:
            self._test_is_sorted(a)

        # Test __or__
        result = ann_1 | ann_2
        expected = {tup_1, tup_2, tup_3}
        actual = set(result)
        self.assertSetEqual(actual, expected)
        self.assertEqual(file_name, result.source_text_path)
        self._test_is_sorted(result)

        # Test __ior__
        ann_1 |= ann_2
        actual = set(ann_1)
        self.assertSetEqual(actual, expected)
        self._test_is_sorted(ann_1)


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