import pytest

from bot.db import DEFAULT_CAPTION, DEFAULT_FORMAT, DEFAULT_SETTINGS, MAX_FORMATS, Database
from bot.errors import FormatError
from bot.formats import (
    NAME_MAX, FormatSettings, apply_format, default_auto_format, default_metadata_changes, has_default_metadata,
    has_metadata, other_kind, validate_name,
)
from bot.parser import DEFAULT_TEMPLATE
from bot.settings_ops import apply_setting

U, V = 111, 222


@pytest.fixture
async def db(tmp_path):
    database = Database(f"sqlite+aiosqlite:///{tmp_path}/f.db")
    await database.init()
    yield database
    await database.close()


# ---------------------------------------------------------------------------
# storage
# ---------------------------------------------------------------------------


async def test_a_new_format_has_defaults_and_shows_up_in_the_list(db):
    fmt = await db.create_format(U, "One Piece")
    assert fmt["name"] == "One Piece" and fmt["id"] > 0 and fmt["has_thumb"] is False
    assert {k: fmt[k] for k in DEFAULT_FORMAT} == DEFAULT_FORMAT
    await db.create_format(U, "Dragon Ball", template="DB - E{episode}")
    listed = await db.list_formats(U)
    assert [f["name"] for f in listed] == ["One Piece", "Dragon Ball"]  # creation order
    assert listed[1]["template"] == "DB - E{episode}"
    assert await db.count_formats(U) == 2 and await db.count_formats(V) == 0
    assert (await db.get_format(U, fmt["id"]))["name"] == "One Piece"


async def test_names_are_unique_per_user_ignoring_case(db):
    await db.create_format(U, "One Piece")
    with pytest.raises(FormatError) as exc:
        await db.create_format(U, "one piece")
    assert exc.value.code == "taken"
    await db.create_format(V, "One Piece")  # someone else may use the same name


async def test_a_user_can_save_twelve_formats_and_no_more(db):
    for i in range(MAX_FORMATS):
        await db.create_format(U, f"Format {i}")
    with pytest.raises(FormatError) as exc:
        await db.create_format(U, "One too many")
    assert exc.value.code == "limit"
    first = (await db.list_formats(U))[0]
    assert await db.delete_format(U, first["id"])
    await db.create_format(U, "One too many")  # a slot is free again
    assert await db.count_formats(U) == MAX_FORMATS


async def test_update_changes_fields_and_merges_meta(db):
    fmt = await db.create_format(U, "One Piece")
    out = await db.update_format(U, fmt["id"], template="One Piece - E{episode}", keep_audio=["japanese", "english"])
    assert out["template"] == "One Piece - E{episode}" and out["keep_audio"] == ["japanese", "english"]
    await db.update_format(U, fmt["id"], meta={"title": "One Piece"})
    out = await db.update_format(U, fmt["id"], meta={"author": "@Me"}, keep_subtitle=["english"])
    assert out["meta"]["title"] == "One Piece" and out["meta"]["author"] == "@Me" and out["meta"]["artist"] == ""
    assert out["keep_subtitle"] == ["english"]
    with pytest.raises(KeyError):
        await db.update_format(U, fmt["id"], bogus=1)


async def test_formats_persist_across_database_instances(db):
    fmt = await db.create_format(U, "One Piece", template="X {title}")
    await db.update_format(U, fmt["id"], meta={"video": "V"}, keep_audio=["2", "1"])
    await db.set_format_thumb(U, fmt["id"], b"jpegbytes")
    other = Database(db.url)
    got = await other.get_format(U, fmt["id"])
    assert got["template"] == "X {title}" and got["meta"]["video"] == "V" and got["keep_audio"] == ["2", "1"] and got["has_thumb"]
    assert await other.get_format_thumb(U, fmt["id"]) == b"jpegbytes"
    await other.close()


async def test_renaming_a_format_checks_the_other_names_only(db):
    a = await db.create_format(U, "One Piece")
    await db.create_format(U, "Dragon Ball")
    assert (await db.update_format(U, a["id"], name="ONE PIECE"))["name"] == "ONE PIECE"  # its own name, new case
    with pytest.raises(FormatError):
        await db.update_format(U, a["id"], name="dragon ball")
    assert (await db.get_format(U, a["id"]))["name"] == "ONE PIECE"


async def test_thumbnails_belong_to_one_format(db):
    a = await db.create_format(U, "A")
    b = await db.create_format(U, "B")
    assert await db.get_format_thumb(U, a["id"]) is None
    assert await db.set_format_thumb(U, a["id"], b"A-thumb")
    assert [f["has_thumb"] for f in await db.list_formats(U)] == [True, False]
    assert await db.get_format_thumb(U, b["id"]) is None
    assert await db.set_format_thumb(U, a["id"], None)
    assert (await db.get_format(U, a["id"]))["has_thumb"] is False


async def test_nobody_can_touch_another_users_format(db):
    fmt = await db.create_format(U, "Mine")
    assert await db.get_format(V, fmt["id"]) is None
    assert await db.update_format(V, fmt["id"], template="x") is None
    assert await db.set_format_thumb(V, fmt["id"], b"x") is False
    assert await db.get_format_thumb(V, fmt["id"]) is None
    assert await db.delete_format(V, fmt["id"]) is False
    assert (await db.get_format(U, fmt["id"]))["name"] == "Mine"


async def test_delete_and_missing_ids(db):
    fmt = await db.create_format(U, "Gone")
    assert await db.delete_format(U, fmt["id"]) is True
    assert await db.delete_format(U, fmt["id"]) is False
    assert await db.get_format(U, fmt["id"]) is None and await db.update_format(U, fmt["id"], template="x") is None


# ---------------------------------------------------------------------------
# helpers
# ---------------------------------------------------------------------------


def test_validate_name():
    assert validate_name("  One   Piece  ") == (True, "One Piece")
    assert validate_name("")[0] is False and validate_name("   ")[0] is False and validate_name(None)[0] is False
    ok, msg = validate_name("x" * (NAME_MAX + 1))
    assert not ok and str(NAME_MAX) in msg
    assert validate_name("x" * NAME_MAX)[0] is True
    assert validate_name("one\npiece") == (True, "one piece")


def fmt_with(**kw):
    base = {"id": 1, "name": "F", "kind": "manual", "has_thumb": False, "template": "T {title}", "caption": DEFAULT_FORMAT["caption"],
            "meta": dict(DEFAULT_FORMAT["meta"]), "keep_audio": [], "keep_subtitle": []}
    base.update(kw)
    return base


def test_apply_format_lays_the_format_over_the_settings_without_mutating_them():
    settings = dict(DEFAULT_SETTINGS, mode="caption", caption="<i>{original}</i>", file_type="document", remove_words=["x"],
                    target_channel=-100123, metadata_on=False, keep_audio=["french"])
    settings["meta"] = dict(DEFAULT_SETTINGS["meta"], title="DEFAULT TITLE")
    fmt = fmt_with(template="One Piece - E{episode}", meta=dict(DEFAULT_FORMAT["meta"], author="@Me"), keep_subtitle=["english"])
    out = apply_format(settings, fmt)
    assert out["template"] == "One Piece - E{episode}"
    assert out["meta"]["author"] == "@Me" and out["meta"]["title"] == ""  # the format's own metadata, not the default metadata
    assert out["keep_audio"] == [] and out["keep_subtitle"] == ["english"]
    assert out["metadata_on"] is True
    assert out["caption"] == "<b>{filename}</b>"  # the format's own, not the user's <i>{original}</i>
    # everything else is still the user's
    assert (out["mode"], out["file_type"], out["remove_words"], out["target_channel"]) == ("caption", "document", ["x"], -100123)
    assert "template" not in settings and settings["meta"]["title"] == "DEFAULT TITLE"
    assert settings["caption"] == "<i>{original}</i>"


def test_a_format_brings_its_own_caption_and_never_borrows_the_users():
    mine = dict(DEFAULT_SETTINGS, caption="<i>{original}</i> by me")
    assert apply_format(mine, fmt_with(caption="<b>{title}</b> · {size}"))["caption"] == "<b>{title}</b> · {size}"
    assert apply_format(mine, fmt_with())["caption"] == "<b>{filename}</b>"  # none of its own: the new file name in bold
    odd = fmt_with()
    del odd["caption"]  # a snapshot without the field
    assert apply_format(mine, odd)["caption"] == "<b>{filename}</b>"
    assert apply_format(mine, fmt_with(caption=""))["caption"] == "<b>{filename}</b>"
    assert mine["caption"] == "<i>{original}</i> by me"


def test_a_format_without_metadata_leaves_the_file_alone():
    assert not has_metadata(fmt_with())
    settings = dict(DEFAULT_SETTINGS, metadata_on=True)  # default metadata on, but the format sets nothing
    assert apply_format(settings, fmt_with())["metadata_on"] is False
    assert has_metadata(fmt_with(keep_audio=["1"])) and has_metadata(fmt_with(meta=dict(DEFAULT_FORMAT["meta"], video="v")))


# ---------------------------------------------------------------------------
# editing a format through the shared validation
# ---------------------------------------------------------------------------


async def test_settings_ops_edit_a_format_with_the_same_rules_as_the_users_own_settings(db):
    fmt = await db.create_format(U, "One Piece")
    store = FormatSettings(db, fmt["id"])

    ok, msg = await apply_setting(store, U, "template", "One Piece - E{episode}")
    assert ok and "Template saved" in msg and "One Piece - E" in msg
    ok, msg = await apply_setting(store, U, "mt_title", "One Piece")
    assert ok and "Metadata is Off" not in msg
    ok, _ = await apply_setting(store, U, "mt_audio", "{lang} Audio")
    assert ok
    ok, msg = await apply_setting(store, U, "keep_audio", "Japanese English")
    assert ok and "turned it On" not in msg
    ok, _ = await apply_setting(store, U, "keep_subtitle", "2 1")
    assert ok

    got = await db.get_format(U, fmt["id"])
    assert got["template"] == "One Piece - E{episode}"
    assert got["meta"]["title"] == "One Piece" and got["meta"]["audio"] == "{lang} Audio"
    assert got["keep_audio"] == ["japanese", "english"] and got["keep_subtitle"] == ["2", "1"]
    # the user's own settings were not touched
    assert await db.get_settings(U) == DEFAULT_SETTINGS

    ok, msg = await apply_setting(store, U, "keep_audio", "off")
    assert ok and "cleared" in msg and (await db.get_format(U, fmt["id"]))["keep_audio"] == []
    ok, msg = await apply_setting(store, U, "mt_title", "off")
    assert ok and (await db.get_format(U, fmt["id"]))["meta"]["title"] == ""
    ok, msg = await apply_setting(store, U, "keep_audio", "bad!word")
    assert not ok and "❌" in msg


async def test_editing_a_deleted_format_raises_lookup_error(db):
    fmt = await db.create_format(U, "Gone")
    store = FormatSettings(db, fmt["id"])
    await db.delete_format(U, fmt["id"])
    with pytest.raises(LookupError):
        await apply_setting(store, U, "template", "x {title}")
    with pytest.raises(LookupError):
        await store.get_settings(U)


# ---------------------------------------------------------------------------
# a format's own caption
# ---------------------------------------------------------------------------


async def test_a_format_starts_with_the_file_name_in_bold_and_keeps_a_caption_of_its_own(db):
    fmt = await db.create_format(U, "One Piece")
    assert fmt["caption"] == "<b>{filename}</b>" == DEFAULT_CAPTION
    out = await db.update_format(U, fmt["id"], caption="<i>{filename}</i> · {size}")
    assert out["caption"] == "<i>{filename}</i> · {size}"
    await db.update_format(U, fmt["id"], template="X {title}", meta={"title": "T"})  # other edits leave it alone
    other = Database(db.url)
    assert (await other.get_format(U, fmt["id"]))["caption"] == "<i>{filename}</i> · {size}"
    await other.close()
    assert (await db.list_formats(U))[0]["caption"] == "<i>{filename}</i> · {size}"
    assert await db.get_settings(U) == DEFAULT_SETTINGS  # formats never touch the user's own settings


async def test_formats_saved_before_captions_existed_get_the_default_one(db):
    import json

    from bot.db import Format

    async with db._sessions() as session:
        session.add(Format(user_id=U, name="Old", data=json.dumps({"template": "Old - {title}", "keep_audio": ["english"]})))
        session.add(Format(user_id=U, name="Broken", data=json.dumps({"caption": 7})))
        session.add(Format(user_id=U, name="Blank", data=json.dumps({"caption": "   "})))
        await session.commit()
    old, broken, blank = await db.list_formats(U)
    assert old["template"] == "Old - {title}" and old["keep_audio"] == ["english"] and old["caption"] == "<b>{filename}</b>"
    assert broken["caption"] == "<b>{filename}</b>" and blank["caption"] == "<b>{filename}</b>"


async def test_a_copy_of_a_format_has_its_caption(db):
    fmt = await db.create_format(U, "One Piece")
    await db.update_format(U, fmt["id"], caption="<code>{filename}</code>")
    copy = await db.copy_format(V, U, fmt["id"])
    assert copy["caption"] == "<code>{filename}</code>"
    await db.update_format(V, copy["id"], caption="<b>{title}</b>")
    assert (await db.get_format(U, fmt["id"]))["caption"] == "<code>{filename}</code>"


async def test_settings_ops_edit_a_formats_caption_with_the_checks_of_the_auto_format_caption(db):
    fmt = await db.create_format(U, "One Piece")
    store = FormatSettings(db, fmt["id"])
    ok, msg = await apply_setting(store, U, "caption", "<b>{filename}</b> · {size} · {duration}")
    assert ok and "Caption template saved" in msg and "Unknown" not in msg
    assert (await db.get_format(U, fmt["id"]))["caption"] == "<b>{filename}</b> · {size} · {duration}"
    ok, msg = await apply_setting(store, U, "caption", "<i>{nonsense}</i>")
    assert ok and "Unknown variables" in msg and "{nonsense}" in msg  # kept as plain text, as for the auto format's caption
    ok, msg = await apply_setting(store, U, "caption", "x" * 801)
    assert not ok and "too long" in msg and (await db.get_format(U, fmt["id"]))["caption"] == "<i>{nonsense}</i>"
    ok, msg = await apply_setting(store, U, "caption", "")
    assert not ok and "can't be empty" in msg
    for word in ("reset", "off", "none", "clear"):
        await apply_setting(store, U, "caption", "<u>{filename}</u>")
        ok, _ = await apply_setting(store, U, "caption", word)
        assert ok and (await db.get_format(U, fmt["id"]))["caption"] == "<b>{filename}</b>", word  # the file name in bold again
    assert (await store.get_settings(U))["caption"] == "<b>{filename}</b>"
    assert await db.get_settings(U) == DEFAULT_SETTINGS


# ---------------------------------------------------------------------------
# two kinds: 12 auto formats and 12 manual ones
# ---------------------------------------------------------------------------


async def test_a_format_is_manual_unless_it_is_made_as_an_auto_one(db):
    assert (await db.create_format(U, "A"))["kind"] == "manual"
    assert (await db.create_format(U, "B", kind="manual"))["kind"] == "manual"
    auto = await db.create_format(U, "C", kind="auto")
    assert auto["kind"] == "auto" and (await db.get_format(U, auto["id"]))["kind"] == "auto"
    with pytest.raises(KeyError):
        await db.create_format(U, "D", kind="both")
    assert other_kind("auto") == "manual" and other_kind("manual") == "auto"


async def test_each_kind_lists_and_counts_its_own_formats(db):
    a1, m1, a2 = await db.create_format(U, "A1", kind="auto"), await db.create_format(U, "M1"), await db.create_format(U, "A2", kind="auto")
    await db.create_format(V, "Theirs", kind="auto")
    assert [f["id"] for f in await db.list_formats(U)] == [a1["id"], m1["id"], a2["id"]]  # no kind: all of them, oldest first
    assert [f["id"] for f in await db.list_formats(U, "auto")] == [a1["id"], a2["id"]]
    assert [f["id"] for f in await db.list_formats(U, "manual")] == [m1["id"]]
    assert (await db.count_formats(U), await db.count_formats(U, "auto"), await db.count_formats(U, "manual")) == (3, 2, 1)
    assert await db.count_formats(V, "manual") == 0 and await db.count_formats(V, "auto") == 1


async def test_a_user_can_save_twelve_formats_of_each_kind_and_no_more(db):
    for kind in ("auto", "manual"):
        for i in range(MAX_FORMATS):
            await db.create_format(U, f"{kind} {i}", kind=kind)
        with pytest.raises(FormatError) as exc:
            await db.create_format(U, "One too many", kind=kind)
        assert exc.value.code == "limit"
    assert await db.count_formats(U) == 2 * MAX_FORMATS
    first = (await db.list_formats(U, "auto"))[0]
    assert await db.delete_format(U, first["id"])
    await db.create_format(U, "One too many", kind="auto")  # a slot of that kind is free again
    with pytest.raises(FormatError):
        await db.create_format(U, "Still too many", kind="manual")  # the manual ones are still full


async def test_a_name_only_has_to_be_free_within_its_kind(db):
    auto = await db.create_format(U, "One Piece", kind="auto")
    manual = await db.create_format(U, "ONE PIECE")  # the same name, the other kind
    with pytest.raises(FormatError) as exc:
        await db.create_format(U, "one piece", kind="auto")
    assert exc.value.code == "taken"
    other = await db.create_format(U, "Dragon Ball", kind="auto")
    with pytest.raises(FormatError):
        await db.update_format(U, other["id"], name="one piece")  # taken by an auto format
    await db.update_format(U, other["id"], name="Dragon Ball Z")
    await db.update_format(U, manual["id"], name="Dragon Ball Z")  # but free among the manual ones
    assert (await db.get_format(U, auto["id"]))["name"] == "One Piece"


async def test_formats_stored_before_there_were_kinds_are_manual(db):
    import json

    from bot.db import Format

    async with db._sessions() as session:
        session.add(Format(user_id=U, name="Old", data=json.dumps({"template": "Old - {title}"})))
        session.add(Format(user_id=U, name="Odd", data=json.dumps({"kind": "sideways"})))
        session.add(Format(user_id=U, name="Auto", data=json.dumps({"kind": "auto"})))
        await session.commit()
    assert [(f["name"], f["kind"]) for f in await db.list_formats(U)] == [("Old", "manual"), ("Odd", "manual"), ("Auto", "auto")]
    old = (await db.list_formats(U, "manual"))[0]
    out = await db.update_format(U, old["id"], template="New - {title}")  # editing a format keeps its kind
    assert out["kind"] == "manual" and (await db.get_format(U, old["id"]))["template"] == "New - {title}"
    auto = (await db.list_formats(U, "auto"))[0]
    assert (await db.update_format(U, auto["id"], meta={"title": "T"}))["kind"] == "auto"


async def test_copy_format_to_the_other_kind(db):
    src = await db.create_format(U, "One Piece", "E{episode}", kind="auto")
    await db.update_format(U, src["id"], meta={"title": "OP"}, keep_audio=["japanese"], caption="<i>{filename}</i>")
    await db.set_format_thumb(U, src["id"], b"\xff\xd8thumb")

    same = await db.copy_format(V, U, src["id"])  # sharing: the copy keeps the kind
    assert same["kind"] == "auto"
    mine = await db.copy_format(U, U, src["id"], kind="manual")
    assert mine["kind"] == "manual" and mine["name"] == "One Piece" and mine["id"] != src["id"]  # free in the manual names
    assert mine["template"] == "E{episode}" and mine["meta"]["title"] == "OP" and mine["keep_audio"] == ["japanese"]
    assert mine["caption"] == "<i>{filename}</i>" and mine["has_thumb"] and await db.get_format_thumb(U, mine["id"]) == b"\xff\xd8thumb"
    assert [(await db.copy_format(U, U, src["id"], kind="manual"))["name"] for _ in range(2)] == ["One Piece (2)", "One Piece (3)"]
    back = await db.copy_format(U, U, mine["id"], kind="auto")  # and the other way round: "One Piece" is taken among the auto ones
    assert back["kind"] == "auto" and back["name"] == "One Piece (2)"
    await db.update_format(U, mine["id"], template="Changed")  # the copy is independent
    assert (await db.get_format(U, src["id"]))["template"] == "E{episode}"
    with pytest.raises(KeyError):
        await db.copy_format(U, U, src["id"], kind="both")


async def test_copying_to_the_other_kind_stops_at_the_limit_of_that_kind(db):
    src = await db.create_format(U, "One Piece", kind="auto")
    for i in range(MAX_FORMATS):
        await db.create_format(U, f"M{i}")
    with pytest.raises(FormatError) as exc:
        await db.copy_format(U, U, src["id"], kind="manual")
    assert exc.value.code == "limit" and await db.count_formats(U, "manual") == MAX_FORMATS
    assert (await db.copy_format(U, U, src["id"]))["kind"] == "auto"  # the auto ones have room


# ---------------------------------------------------------------------------
# the auto format in use
# ---------------------------------------------------------------------------


async def test_without_auto_formats_there_is_none_in_use(db):
    assert await db.get_auto_format(U) is None
    await db.create_format(U, "Manual only")  # a manual format never renames files by itself
    assert await db.get_auto_format(U) is None and (await db.get_settings(U))["auto_format"] == 0


async def test_the_first_auto_format_is_in_use_and_it_is_remembered(db):
    first = await db.create_format(U, "First", kind="auto")
    await db.create_format(U, "Second", kind="auto")
    assert (await db.get_auto_format(U))["id"] == first["id"]
    assert (await db.get_settings(U))["auto_format"] == first["id"]
    assert (await db.get_auto_format(V)) is None  # per user


async def test_selecting_an_auto_format(db):
    a, b = await db.create_format(U, "A", kind="auto"), await db.create_format(U, "B", kind="auto")
    manual = await db.create_format(U, "M")
    theirs = await db.create_format(V, "Theirs", kind="auto")
    assert (await db.select_auto_format(U, b["id"]))["id"] == b["id"]
    assert (await db.get_auto_format(U))["id"] == b["id"] and (await db.get_settings(U))["auto_format"] == b["id"]
    for fid in (manual["id"], theirs["id"], 99999):  # not an auto format of theirs
        assert await db.select_auto_format(U, fid) is None
    assert (await db.get_auto_format(U))["id"] == b["id"]  # unchanged by the refusals
    await db.select_auto_format(U, a["id"])
    assert (await db.get_auto_format(U))["id"] == a["id"]


async def test_deleting_the_auto_format_in_use_hands_over_to_another(db):
    a = await db.create_format(U, "A", kind="auto")
    b = await db.create_format(U, "B", kind="auto")
    c = await db.create_format(U, "C", kind="auto")
    await db.select_auto_format(U, b["id"])
    await db.delete_format(U, b["id"])
    assert (await db.get_auto_format(U))["id"] == a["id"]  # the oldest left takes over
    assert (await db.get_settings(U))["auto_format"] == a["id"]
    await db.delete_format(U, c["id"])  # deleting one that is not in use changes nothing
    assert (await db.get_auto_format(U))["id"] == a["id"]
    await db.delete_format(U, a["id"])
    assert await db.get_auto_format(U) is None and (await db.get_settings(U))["auto_format"] == 0


# ---------------------------------------------------------------------------
# a format over the user's settings, and the default metadata
# ---------------------------------------------------------------------------


def with_default_metadata(**over):
    settings = dict(DEFAULT_SETTINGS, **over)
    settings["meta"] = dict(DEFAULT_SETTINGS["meta"], title="DEFAULT TITLE", audio="{lang} Audio")
    return settings


def test_an_auto_format_without_metadata_leaves_the_default_metadata_in_charge():
    mine = with_default_metadata(metadata_on=True, keep_audio=["english"])
    out = apply_format(mine, fmt_with(kind="auto"))
    assert out["template"] == "T {title}" and out["metadata_on"] is True  # its switch decides, as it always did
    assert out["meta"]["title"] == "DEFAULT TITLE" and out["keep_audio"] == ["english"]
    off = apply_format(with_default_metadata(metadata_on=False), fmt_with(kind="auto"))
    assert off["metadata_on"] is False and off["meta"]["title"] == "DEFAULT TITLE"  # off: nothing is written


def test_an_auto_format_with_metadata_of_its_own_ignores_the_default_metadata():
    fmt = fmt_with(kind="auto", meta=dict(DEFAULT_FORMAT["meta"], author="@Me"))
    out = apply_format(with_default_metadata(metadata_on=False), fmt)
    assert out["metadata_on"] is True and out["meta"]["author"] == "@Me" and out["meta"]["title"] == "" and out["keep_audio"] == []
    assert apply_format(with_default_metadata(metadata_on=True), fmt)["meta"]["title"] == ""


def test_a_manual_format_never_uses_the_default_metadata():
    out = apply_format(with_default_metadata(metadata_on=True, keep_audio=["english"]), fmt_with(kind="manual"))
    assert out["metadata_on"] is False and out["meta"]["title"] == "" and out["keep_audio"] == []


def test_no_auto_format_means_the_built_in_defaults_and_the_default_metadata():
    built_in = default_auto_format()
    assert built_in["kind"] == "auto" and built_in["template"] == DEFAULT_TEMPLATE and built_in["caption"] == DEFAULT_CAPTION
    assert not built_in["has_thumb"] and not has_metadata(built_in)
    mine = with_default_metadata(metadata_on=True, template="ignored")
    out = apply_format(mine, None)
    assert out["template"] == DEFAULT_TEMPLATE and out["caption"] == DEFAULT_CAPTION
    assert out["metadata_on"] is True and out["meta"]["title"] == "DEFAULT TITLE"
    assert built_in is not default_auto_format() and default_auto_format()["meta"] == DEFAULT_FORMAT["meta"]  # a fresh copy each time


def test_default_metadata_is_what_the_user_set_in_the_metadata_menu():
    assert not has_default_metadata(DEFAULT_SETTINGS)
    assert not has_default_metadata(dict(DEFAULT_SETTINGS, metadata_on=True))  # the switch alone is not metadata
    assert has_default_metadata(with_default_metadata())
    assert has_default_metadata(dict(DEFAULT_SETTINGS, keep_audio=["1"])) and has_default_metadata(dict(DEFAULT_SETTINGS, keep_subtitle=["english"]))
    changes = default_metadata_changes(with_default_metadata(keep_audio=["2", "1"], keep_subtitle=["english"]))
    assert set(changes) == {"meta", "keep_audio", "keep_subtitle"}
    assert changes["meta"]["title"] == "DEFAULT TITLE" and changes["keep_audio"] == ["2", "1"] and changes["keep_subtitle"] == ["english"]
    source = with_default_metadata(keep_audio=["2"])
    changes = default_metadata_changes(source)
    changes["keep_audio"].append("3")
    changes["meta"]["title"] = "other"
    assert source["keep_audio"] == ["2"] and source["meta"]["title"] == "DEFAULT TITLE"  # copies, not the user's own lists


async def test_default_metadata_can_be_copied_into_a_format_of_either_kind(db):
    settings = with_default_metadata(keep_audio=["japanese"], keep_subtitle=["english"])
    for kind in ("auto", "manual"):
        fmt = await db.create_format(U, f"{kind} one", kind=kind)
        await db.update_format(U, fmt["id"], meta={"video": "OLD"}, keep_audio=["french", "2"])
        got = await db.update_format(U, fmt["id"], **default_metadata_changes(settings))
        assert got["meta"]["title"] == "DEFAULT TITLE" and got["meta"]["audio"] == "{lang} Audio"
        assert got["keep_audio"] == ["japanese"] and got["keep_subtitle"] == ["english"] and got["kind"] == kind
        assert got["meta"]["video"] == "" and got["meta"]["author"] == ""  # all six fields are sent: it replaces what the format had