"""
Qué parte de una dirección se ve en una tabla de un solo sitio.

El producto trabaja contra un sitio, así que las doscientas cuarenta y dos filas
de la tabla de cobertura arrancan con el mismo origen. Mostrarlo entero en cada
una gasta media celda en un dato que ya está en el título de la pantalla y deja
cortado el final de la dirección, que es lo único que las distingue.

Lo que se fija acá es dónde está el límite de ese recorte: **se saca lo que se
repite, nunca lo que diferencia**. Un subdominio distinto no se toca, porque ahí
el host sí distingue y esconderlo dejaría dos direcciones de dos sitios viéndose
iguales.
"""

import pytest

from tests.frontend.harness import call, needs_frontend, resolve

#: Vive en `lib/` y no en la pantalla de cobertura desde que la grilla de
#: páginas canibalizadas la usa también: dos módulos comparten la regla, y una
#: pantalla no importa de otra pantalla.
ADDRESS = '@/lib/address'
SITE = 'ejemplo.test'

pytestmark = needs_frontend

REQUESTS = {
    'with_www': call(ADDRESS, 'splitAddress', 'https://www.ejemplo.test/about', SITE),
    'without_www': call(ADDRESS, 'splitAddress', 'https://ejemplo.test/about', SITE),
    'root': call(ADDRESS, 'splitAddress', 'https://www.ejemplo.test', SITE),
    'root_with_slash': call(ADDRESS, 'splitAddress', 'https://www.ejemplo.test/', SITE),
    'other_subdomain': call(ADDRESS, 'splitAddress', 'https://blog.ejemplo.test/x', SITE),
    'other_site': call(ADDRESS, 'splitAddress', 'https://otro.test/x', SITE),
    'query_and_hash': call(
        ADDRESS, 'splitAddress', 'https://www.ejemplo.test/p?a=1#top', SITE
    ),
    'unparseable': call(ADDRESS, 'splitAddress', 'no-es-una-direccion', SITE),
}


@pytest.fixture(scope='module')
def screen() -> dict:
    return resolve(REQUESTS)


class TestWhatGetsHidden:
    def test_the_repeated_origin_comes_off(self, screen):
        assert screen['with_www'] == {'origin': 'https://www.ejemplo.test', 'rest': '/about'}

    def test_the_site_matches_with_or_without_www(self, screen):
        """
        El hostname del dominio se guarda sin `www` y las direcciones del
        sitemap casi siempre lo llevan. Comparando a secas no coincidiría
        ninguna y el recorte no se aplicaría nunca.
        """
        assert screen['without_www']['rest'] == '/about'
        assert screen['with_www']['rest'] == '/about'

    def test_everything_after_the_origin_stays(self, screen):
        """
        La cadena de consulta y el fragmento son parte de la dirección: dos que
        sólo difieran ahí tienen que poder distinguirse en la tabla.
        """
        assert screen['query_and_hash']['rest'] == '/p?a=1#top'


class TestWhatNeverGetsHidden:
    def test_another_subdomain_keeps_its_host(self, screen):
        """
        Acá el host **sí** distingue. Recortarlo dejaría `blog.` y `www.`
        viéndose iguales en la misma columna.
        """
        assert screen['other_subdomain'] == {'origin': '', 'rest': 'https://blog.ejemplo.test/x'}

    def test_another_site_is_left_whole(self, screen):
        assert screen['other_site']['rest'] == 'https://otro.test/x'

    def test_something_unparseable_is_shown_as_it_came(self, screen):
        """
        Es un dato del sitemap del usuario y no nos toca corregirlo. Lo que no
        puede pasar es que desaparezca de la celda.
        """
        assert screen['unparseable']['rest'] == 'no-es-una-direccion'


class TestTheRootIsNotAnEmptyCell:
    """
    La raíz es la única fila cuyo `rest` sería la cadena vacía, y una celda
    vacía en una tabla se lee como un dato que falta, no como la portada.

    `/` es lo que devuelve la partición, que trabaja sobre la dirección. Cómo se
    **rotula** esa fila es otra decisión y vive en la celda: en una columna de
    rutas, una barra sola sigue leyéndose como un renglón a medio cargar, así
    que se muestra con nombre. Que ese nombre salga del catálogo lo defiende
    `test_i18n.py`.
    """

    def test_the_bare_root_shows_a_slash(self, screen):
        assert screen['root']['rest'] == '/'

    def test_the_root_with_its_slash_shows_the_same(self, screen):
        assert screen['root_with_slash']['rest'] == '/'

    def test_a_path_that_merely_starts_with_a_slash_is_not_the_root(self, screen):
        """
        El rótulo se decide comparando contra `/` exacto. Si se comparara con
        «empieza con barra», toda la tabla se llamaría «Portada».
        """
        assert screen['with_www']['rest'] != '/'