import unittest
from renamer import parse_title


class TestParserParts(unittest.TestCase):
    def test_episode_name(self):
        title = "The.Walking.Dead.S04E06.Live.Bait.1080p.WEB-DL.Rus.Eng.HDCLUB"
        res = parse_title(title)
        self.assertEqual(["Live", "Bait"], res.get("episode_name"))
        self.assertEqual(
            res,
            {
                "episode": ["S04E06"],
                "resolution": ["1080p"],
                "quality": ["WEB-DL"],
                "episode_name": ["Live", "Bait"],
                "language": ["Rus", "Eng"],
                "name": ["The", "Walking", "Dead"],
                "unknown": ["HDCLUB"],
            },
        )

    def test_episode_number(self):
        title = "Vikings.S01E01.720p.BluRay.4xRus.Eng.HDCLUB"
        res = parse_title(title)
        self.assertIn("S01E01", res.get("episode", []))
        self.assertEqual(
            res,
            {
                "episode": ["S01E01"],
                "resolution": ["720p"],
                "quality": ["BluRay"],
                "language": ["4xRus", "Eng"],
                "name": ["Vikings"],
                "unknown": ["HDCLUB"],
            },
        )

    def test_subtitles(self):
        title = "Lives.of.Others.Blu-RayRip.720p.RusDTS.GerAC3.EngSub"
        res = parse_title(title)
        self.assertIn("EngSub", res.get("subtitles", []))
        self.assertEqual(
            res,
            {
                "quality": ["Blu-RayRip"],
                "resolution": ["720p"],
                "audio": ["RusDTS", "GerAC3"],
                "subtitles": ["EngSub"],
                "name": ["Lives", "of", "Others"],
            },
        )

    def test_file_extension(self):
        title = "The Guild s04e06 Weird Respawn (by Swich).mkv"
        res = parse_title(title)
        self.assertIn("mkv", res.get("file_extension", []))
        self.assertEqual(
            res,
            {
                "name": ["The", "Guild"],
                "episode": ["s04e06"],
                "episode_name": ["Weird", "Respawn", "by", "Swich"],
                "file_extension": ["mkv"],
            },
        )


class TestCornerCases(unittest.TestCase):
    def test_misc_separators(self):
        title = "V tumane 2012 1080p BluRay DD5.1 x264-EA"
        res = parse_title(title)
        self.assertIn("DD5.1", res.get("audio", []))
        self.assertIn("x264", res.get("codec", []))
        self.assertIn("EA", res.get("unknown", []))
        self.assertEqual(
            res,
            {
                "year": ["2012"],
                "resolution": ["1080p"],
                "quality": ["BluRay"],
                "audio": ["DD5.1"],
                "codec": ["x264"],
                "name": ["V", "tumane"],
                "unknown": ["EA"],
            },
        )

    def test_misc_separators_and_combine(self):
        title = "The.Dawn.Patrol.1938.1080p.WEB-DL.AAC2.0.H.264-alinto"
        res = parse_title(title)
        self.assertIn("H.264", res.get("codec", []))
        self.assertIn("alinto", res.get("unknown", []))
        self.assertEqual(
            res,
            {
                "year": ["1938"],
                "resolution": ["1080p"],
                "quality": ["WEB-DL"],
                "audio": ["AAC2.0"],
                "codec": ["H.264"],
                "name": ["The", "Dawn", "Patrol"],
                "unknown": ["alinto"],
            },
        )

    @unittest.expectedFailure
    def test_russian_char_in_resolution(self):
        title = "Trouble.with.the.Curve.2012.1080р.BluRay.Rus.Eng.HDCLUB"
        res = parse_title(title)
        self.assertIn("1080p", res.get("resolution", []))
        self.assertEqual(
            res,
            {
                "year": ["2012"],
                "quality": ["BluRay"],
                "language": ["Rus", "Eng"],
                "resolution": ["1080p"],
                "name": ["Trouble", "with", "the", "Curve"],
                "unknown": ["HDCLUB"],
            },
        )

    def test_russian_name(self):
        title = "Убийство (1956. The Killing)"
        res = parse_title(title)
        self.assertEqual(
            res,
            {
                "year": ["1956"],
                "name": ["Убийство"],
                "unknown": ["The", "Killing"],
            },
        )

    def test_only_name_goes_to_unknown(self):
        title = "Белое солнце пустыни"
        res = parse_title(title)
        self.assertEqual(res, {"unknown": ["Белое", "солнце", "пустыни"]})

    def test_hyphen_as_separated_chunk(self):
        title = "Miss Pettigrew Lives for a Day. 2007. BDRip (1080p) - ylnian"
        self.assertEqual(
            parse_title(title),
            {
                "year": ["2007"],
                "quality": ["BDRip"],
                "resolution": ["1080p"],
                "name": ["Miss", "Pettigrew", "Lives", "for", "a", "Day"],
                "unknown": ["ylnian"],
            },
        )

    def test_file_extension_does_not_go_to_unknown(self):
        title = "Monsters,Inc.2001.BDRip.1080p.3xRus.Ukr.Eng.HDCLUB.mkv"
        res = parse_title(title)
        self.assertNotIn("mkv", res.get("unknown", []))
        self.assertEqual(
            res,
            {
                "year": ["2001"],
                "quality": ["BDRip"],
                "resolution": ["1080p"],
                "language": ["3xRus", "Ukr", "Eng"],
                "name": ["Monsters", "Inc"],
                "unknown": ["HDCLUB"],
                "file_extension": ["mkv"],
            },
        )

    def test_edition_after_name(self):
        title = "Logan.2017.noir.edition.BDRip.1080p.HEVC"
        res = parse_title(title)
        self.assertIn("noir.edition", res.get("edition", []))
        self.assertIn("Logan", res.get("name", []))
        self.assertEqual(
            res,
            {
                "year": ["2017"],
                "quality": ["BDRip"],
                "resolution": ["1080p"],
                "codec": ["HEVC"],
                "edition": ["noir.edition"],
                "name": ["Logan"],
            },
        )

    def test_chunk_from_three_parts(self):
        title = "Mad.Max.Road.of.Fury.Black.Chrome.edition.BDRip.1080p"
        self.assertEqual(
            parse_title(title),
            {
                "quality": ["BDRip"],
                "resolution": ["1080p"],
                "edition": ["Black.Chrome.edition"],
                "name": ["Mad", "Max", "Road", "of", "Fury"],
            },
        )

    @unittest.expectedFailure
    def test_ampersand_in_title(self):
        title = "Me.Myself.&.Irene.2000.720p.BluRay.4xRus.Ukr.Eng"
        res = parse_title(title)
        self.assertIn("&", res.get("name", []))
        self.assertEqual(
            res,
            {
                "year": ["2000"],
                "resolution": ["720p"],
                "quality": ["BluRay"],
                "language": ["4xRus", "Ukr", "Eng"],
                "name": ["Me", "Myself", "&", "Irene"],
            },
        )

    def test_brackets_and_parenthesis(self):
        title = "Leon.(1994).BDRip.1080p.(DVD9).[NoLimits-Team]"
        res = parse_title(title)
        self.assertEqual(
            res,
            {
                "year": ["1994"],
                "quality": ["BDRip", "DVD9"],
                "resolution": ["1080p"],
                "name": ["Leon"],
                "unknown": ["NoLimits-Team"],
            },
        )

    def test_multiple_languages(self):
        title = "The.Theory.of.Everything.2014.720p.BluRay.2xRus.2xEng.HDCLUB"
        res = parse_title(title)
        self.assertIn("2xRus", res.get("language", []))
        self.assertIn("2xEng", res.get("language", []))
        self.assertEqual(
            res,
            {
                "year": ["2014"],
                "resolution": ["720p"],
                "quality": ["BluRay"],
                "language": ["2xRus", "2xEng"],
                "name": ["The", "Theory", "of", "Everything"],
                "unknown": ["HDCLUB"],
            },
        )

    def test_strange_dot_in_name(self):
        title = "WALL·E.2008.1080p.BluRay.3xRus.Ukr.Eng.HDCLUB-Skazhutin"
        res = parse_title(title)
        self.assertIn("WALL·E", res.get("name", []))
        self.assertEqual(
            res,
            {
                "year": ["2008"],
                "resolution": ["1080p"],
                "quality": ["BluRay"],
                "language": ["3xRus", "Ukr", "Eng"],
                "name": ["WALL·E"],
                "unknown": ["HDCLUB-Skazhutin"],
            },
        )

    def test_splitted_by_hyphens_chunk_ends_with_empty_part(self):
        title = "The.IT.Crowd.S01E04.The.Red.Door.HR.DVDRip.HQ.Edition.x264-N-(Rus.Eng)"
        res = parse_title(title)
        self.assertEqual(
            res,
            {
                "name": ["The", "IT", "Crowd"],
                "episode": ["S01E04"],
                "episode_name": ["The", "Red", "Door", "HR"],
                "quality": ["DVDRip"],
                "edition": ["HQ.Edition"],
                "codec": ["x264"],
                "unknown": ["N"],
                "language": ["Rus", "Eng"],
            },
        )

    def test_year_before_episode_number_and_name(self):
        title = "The.Big.Bang.Theory.2019.S12E20.The.Decision.Reverberation.1080p.AMZN.WEB-DL.DD5.1.x264-NTb_EniaHD.mkv"
        res = parse_title(title)
        self.assertEqual(
            res,
            {
                "name": ["The", "Big", "Bang", "Theory"],
                "year": ["2019"],
                "episode": ["S12E20"],
                "episode_name": ["The", "Decision", "Reverberation"],
                "unknown": ["NTb", "EniaHD"],
                "resolution": ["1080p"],
                "quality": ["AMZN", "WEB-DL"],
                "audio": ["DD5.1"],
                "codec": ["x264"],
                "file_extension": ["mkv"],
            },
        )

    def test_unknown_stripped_from_hyphens(self):
        title = "The.Big.Bang.Theory.S04E06.720p.WEB-DL.eng.rus.[Kuraj-Bambey.Ru]-jhonny2.mkv"
        res = parse_title(title)
        self.assertIn("jhonny2", res.get("unknown", []))
        self.assertEqual(
            res,
            {
                "name": ["The", "Big", "Bang", "Theory"],
                "episode": ["S04E06"],
                "resolution": ["720p"],
                "quality": ["WEB-DL"],
                "language": ["eng", "rus"],
                "unknown": ["Kuraj-Bambey", "Ru", "jhonny2"],
                "file_extension": ["mkv"],
            },
        )

    def test_episode_name_without_series_name(self):
        title = "S27E01.Every Man's Dream.mkv"
        res = parse_title(title)
        self.assertEqual(
            res,
            {
                "episode": ["S27E01"],
                "episode_name": ["Every", "Man's", "Dream"],
                "file_extension": ["mkv"],
            },
        )