from datetime import date

import pytest

import hircine.enums as enums
from hircine.api.types import ScrapedComic
from hircine.scraper import ScrapeWarning
from hircine.scraper.types import (
    Artist,
    Category,
    Character,
    Circle,
    Date,
    Language,
    OriginalTitle,
    Rating,
    Tag,
    Title,
    World,
)


@pytest.mark.parametrize(
    "input,options,want",
    [
        ("foo", {}, Tag(namespace="none", tag="foo")),
        ("foo:bar", {}, Tag(namespace="foo", tag="bar")),
        ("foo:bar:baz", {}, Tag(namespace="foo", tag="bar:baz")),
        ("foo/bar", {"delimiter": "/"}, Tag(namespace="foo", tag="bar")),
    ],
    ids=[
        "tag only",
        "tag and namespace",
        "tag with delimiter",
        "custom delimiter",
    ],
)
def test_tag_from_string(input, options, want):
    assert Tag.from_string(input, **options) == want


@pytest.mark.parametrize(
    "input,want",
    [
        ("1998-02-07", Date(value=date(1998, 2, 7))),
        ("2018-07-18T19:15", Date(value=date(2018, 7, 18))),
        (
            "2003-12-30T10:37Z",
            Date(value=date(2003, 12, 30)),
        ),
    ],
)
def test_date_from_iso(input, want):
    assert Date.from_iso(input) == want


@pytest.mark.parametrize(
    "input",
    [
        ("text"),
        ("1997 02 07"),
        ("1997/02/07"),
    ],
)
def test_date_from_iso_fails(input):
    with pytest.raises(ScrapeWarning, match="Could not parse date:"):
        Date.from_iso(input)


@pytest.mark.parametrize(
    "input,want",
    [
        ("886806000", Date(value=date(1998, 2, 7))),
        (886806000, Date(value=date(1998, 2, 7))),
    ],
)
def test_date_from_timestamp(input, want):
    assert Date.from_timestamp(input) == want


@pytest.mark.parametrize(
    "input",
    [
        ("text"),
    ],
)
def test_date_from_timestamp_fails(input):
    with pytest.raises(ScrapeWarning, match="Could not parse date:"):
        Date.from_timestamp(input)


@pytest.mark.parametrize(
    "item,attr,empty",
    [
        (Title(""), "title", None),
        (OriginalTitle(""), "original_title", None),
        (Language(None), "language", None),
        (Date(None), "date", None),
        (Rating(None), "rating", None),
        (Category(None), "category", None),
        (Tag("", ""), "tags", []),
        (Tag(namespace="", tag=""), "tags", []),
        (Tag(namespace=None, tag=""), "tags", []),
        (Tag(namespace="foo", tag=""), "tags", []),
        (Artist(""), "artists", []),
        (Character(""), "characters", []),
        (Circle(""), "circles", []),
        (World(""), "worlds", []),
    ],
    ids=[
        "title",
        "original title",
        "language",
        "date",
        "rating",
        "category",
        "tag (both empty, positional)",
        "tag (both empty)",
        "tag (namespace None, tag empty)",
        "tag (tag empty)",
        "artist",
        "character",
        "circle",
        "world",
    ],
)
def test_scraped_comic_silently_ignores_empty(item, attr, empty):
    def gen():
        yield item

    comic = ScrapedComic.from_generator(gen())

    assert getattr(comic, attr) == empty


@pytest.mark.parametrize(
    "input,want",
    [
        ("EN", Language(value=enums.Language.EN)),
        ("de", Language(value=enums.Language.DE)),
    ],
)
def test_language_from_iso_639_3(input, want):
    assert Language.from_iso_639_3(input) == want


def test_language_from_iso_639_3_fails():
    with pytest.raises(ScrapeWarning, match="Could not parse language code:"):
        Language.from_iso_639_3("ENG")


@pytest.mark.parametrize(
    "input,want",
    [
        ("English", Language(value=enums.Language.EN)),
        ("german", Language(value=enums.Language.DE)),
    ],
)
def test_language_from_name(input, want):
    assert Language.from_name(input) == want


def test_language_from_name_fails():
    with pytest.raises(ScrapeWarning, match="Could not parse language name:"):
        Language.from_name("nonexistent")