"""
Pruebas del programa de escritorio: dónde guarda los datos, cómo se cambian de
sitio la primera vez y la copia que hace al abrir. Se simula el instalable
(sys.frozen) con carpetas temporales; no se toca nada del equipo.

  python3 -m unittest discover -s pruebas -v
"""

from __future__ import annotations

import os
import sys
import tarfile
import tempfile
import unittest
from pathlib import Path
from unittest import mock

sys.path.insert(0, str(Path(__file__).resolve().parent.parent))

from cartera import instalacion, servidor  # noqa: E402
from cartera.operaciones import Cartera, ErrorOperacion  # noqa: E402


class ComoInstalable(unittest.TestCase):
    def setUp(self):
        self._tmp = tempfile.TemporaryDirectory()
        self.addCleanup(self._tmp.cleanup)
        raiz = Path(self._tmp.name)
        self.programa = raiz / "descargas"
        self.programa.mkdir()
        self.personal = raiz / "casa" / "caudal"
        for parche in (mock.patch.object(sys, "frozen", True, create=True),
                       mock.patch.object(sys, "executable", str(self.programa / "caudal")),
                       mock.patch.dict(os.environ, {"XDG_DATA_HOME": str(raiz / "casa")}),
                       mock.patch.object(sys, "platform", "linux")):
            parche.start()
            self.addCleanup(parche.stop)
        os.environ.pop("APPIMAGE", None)

    def abrir(self):
        base, _ = instalacion.base_actual()
        app = servidor.App(Cartera(base / "datos"))
        self.addCleanup(lambda: app.cartera.cerrar())
        return app


class TestDondeVivenLosDatos(ComoInstalable):
    def test_sin_nada_van_a_la_carpeta_del_usuario(self):
        self.assertEqual(instalacion.base_actual(), (self.personal, "personal"))

    def test_con_carpeta_junto_al_programa_se_usa_esa(self):
        (self.programa / "caudal-datos").mkdir()
        self.assertEqual(instalacion.base_actual(), (self.programa / "caudal-datos", "portatil"))

    def test_una_appimage_mira_junto_a_su_fichero_no_donde_se_monta(self):
        otra = Path(self._tmp.name) / "usb"
        (otra / "caudal-datos").mkdir(parents=True)
        with mock.patch.dict(os.environ, {"APPIMAGE": str(otra / "Caudal.AppImage")}):
            self.assertEqual(instalacion.base_actual(), (otra / "caudal-datos", "portatil"))

    def test_desde_el_codigo_no_hay_nada_que_elegir(self):
        with mock.patch.object(sys, "frozen", False, create=True):
            with tempfile.TemporaryDirectory() as t:
                app = servidor.App(Cartera(Path(t) / "datos"))
                self.addCleanup(app.cartera.cerrar)
                self.assertIsNone(app.estado()["instalacion"])


class TestElegirLaPrimeraVez(ComoInstalable):
    def test_se_puede_llevar_junto_al_programa_y_volver(self):
        app = self.abrir()
        ins = app.estado()["instalacion"]
        self.assertEqual((ins["modo"], ins["elegible"], ins["portatil_posible"]), ("personal", True, True))
        ins = app.instalacion_mover("portatil")
        self.assertEqual((ins["modo"], ins["carpeta"]), ("portatil", str(self.programa / "caudal-datos")))
        self.assertFalse(self.personal.exists())                    # no quedan dos copias
        app.cartera.guardar_activo({"nombre": "Un fondo", "tipo": "Fondo", "codigo": "IE00B03HCZ61"})
        self.assertTrue((self.programa / "caudal-datos" / "datos" / "activos.jsonl").is_file())

    def test_con_algo_apuntado_ya_no_se_mueve(self):
        app = self.abrir()
        app.cartera.guardar_activo({"nombre": "Un fondo", "tipo": "Fondo", "codigo": "IE00B03HCZ61"})
        self.assertFalse(app.estado()["instalacion"]["elegible"])
        with self.assertRaises(ErrorOperacion):
            app.instalacion_mover("portatil")
        self.assertTrue((self.personal / "datos" / "activos.jsonl").is_file())

    def test_no_pisa_datos_que_ya_hubiera_en_el_destino(self):
        app = self.abrir()
        ajena = self.programa / "caudal-datos"
        with mock.patch.object(instalacion, "base_actual", return_value=(self.personal, "personal")):
            (ajena / "datos").mkdir(parents=True)
            (ajena / "datos" / "activos.jsonl").write_text("{}\n")
            with self.assertRaises(ValueError):
                instalacion.mover("portatil")
        self.assertEqual((ajena / "datos" / "activos.jsonl").read_text(), "{}\n")
        app.cartera.cerrar()

    def test_si_la_carpeta_del_programa_no_deja_escribir_se_dice(self):
        app = self.abrir()
        with mock.patch.object(instalacion, "se_puede_escribir_junto_al_programa", return_value=False):
            self.assertFalse(app.estado()["instalacion"]["portatil_posible"])


class TestEnElMenuDeAplicaciones(ComoInstalable):
    def setUp(self):
        super().setUp()
        self.lanzador = self.personal.parent / "applications" / "caudal.desktop"
        self.icono = self.personal.parent / "icons" / "hicolor" / "scalable" / "apps" / "caudal.svg"

    def test_se_anade_y_se_quita_desde_el_programa(self):
        app = self.abrir()
        self.assertEqual(app.estado()["instalacion"]["lanzador"], {"puesto": False})
        self.assertEqual(app.instalacion_lanzador(True)["lanzador"], {"puesto": True})
        lineas = self.lanzador.read_text(encoding="utf-8").splitlines()
        self.assertEqual(lineas[0], "[Desktop Entry]")
        self.assertIn(f'Exec="{self.programa / "caudal"}"', lineas)
        self.assertIn(f"Icon={self.icono}", lineas)
        self.assertIn("Terminal=false", lineas)
        self.assertIn("<svg", self.icono.read_text(encoding="utf-8"))
        self.assertEqual(app.instalacion_lanzador(False)["lanzador"], {"puesto": False})
        self.assertFalse(self.lanzador.exists() or self.icono.exists())

    def test_la_ruta_del_programa_va_con_sus_escapes(self):
        rara = self.programa / "mis $cosas 100%" / "caudal"
        with mock.patch.object(sys, "executable", str(rara)):
            instalacion.poner_lanzador(servidor.WEB / "icono.svg")
            self.assertIn('Exec="' + str(self.programa) + '/mis \\\\$cosas 100%%/caudal"',
                          self.lanzador.read_text(encoding="utf-8").splitlines())
            self.assertEqual(instalacion.programa_del_lanzador(), rara)

    def test_si_el_programa_se_movio_se_corrige_al_arrancar(self):
        icono = servidor.WEB / "icono.svg"
        instalacion.poner_lanzador(icono)                    # apunta a un fichero que no existe
        nuevo = self.programa / "otra" / "caudal"
        with mock.patch.object(sys, "executable", str(nuevo)):
            instalacion.repasar_lanzador(icono)
        self.assertEqual(instalacion.programa_del_lanzador(), nuevo)

    def test_si_la_otra_copia_sigue_ahi_no_se_le_quita_el_lanzador(self):
        icono = servidor.WEB / "icono.svg"
        (self.programa / "caudal").write_text("")
        instalacion.poner_lanzador(icono)
        with mock.patch.object(sys, "executable", str(self.programa / "otra" / "caudal")):
            instalacion.repasar_lanzador(icono)
        self.assertEqual(instalacion.programa_del_lanzador(), self.programa / "caudal")

    def test_un_lanzador_ajeno_con_ese_nombre_no_se_borra(self):
        self.lanzador.parent.mkdir(parents=True)
        self.lanzador.write_text("[Desktop Entry]\nName=Otro\n", encoding="utf-8")
        self.assertEqual(instalacion.lanzador(), {"puesto": False})
        instalacion.quitar_lanzador()
        self.assertTrue(self.lanzador.exists())

    def test_fuera_de_linux_o_desde_el_codigo_no_se_ofrece(self):
        app = self.abrir()
        with mock.patch.object(sys, "platform", "win32"):
            self.assertIsNone(instalacion.lanzador())
            with self.assertRaises(ErrorOperacion):
                app.instalacion_lanzador(True)
        with mock.patch.object(sys, "frozen", False, create=True):
            self.assertIsNone(instalacion.lanzador())
        self.assertFalse(self.lanzador.exists())


class TestCopiaAlAbrir(ComoInstalable):
    def test_sin_datos_no_hace_copia(self):
        self.assertIsNone(instalacion.copia_al_abrir(self.personal))

    def test_guarda_datos_y_ajustes_y_conserva_las_ultimas(self):
        app = self.abrir()
        app.cartera.guardar_activo({"nombre": "Un fondo", "tipo": "Fondo", "codigo": "IE00B03HCZ61"})
        (self.personal / "bitcoin.json").write_text("{}")
        (self.personal / "datos" / "adjuntos").mkdir()
        (self.personal / "datos" / "adjuntos" / "grande.pdf").write_text("x")
        copia = instalacion.copia_al_abrir(self.personal)
        with tarfile.open(copia) as tar:
            nombres = set(tar.getnames())
        self.assertIn("./activos.jsonl", nombres)
        self.assertIn("bitcoin.json", nombres)
        self.assertFalse(any("adjuntos" in n or "cerrojo" in n for n in nombres))
        with mock.patch.object(instalacion, "COPIAS", 2):
            for n in range(4):
                (self.personal / "backups" / f"datos-2020010{n}-000000.tar.gz").write_text("vieja")
            instalacion.copia_al_abrir(self.personal)
        self.assertLessEqual(len(list((self.personal / "backups").glob("datos-*.tar.gz"))), 2)


class TestYaEstaAbierto(ComoInstalable):
    def test_la_marca_solo_vale_mientras_alguien_contesta(self):
        import socket
        self.personal.mkdir(parents=True)
        self.assertIsNone(instalacion.en_marcha(self.personal))
        with socket.socket() as s:
            s.bind(("127.0.0.1", 0))
            s.listen(1)
            url = f"http://127.0.0.1:{s.getsockname()[1]}/?t=abc"
            instalacion.anotar_en_marcha(self.personal, url)
            self.assertEqual((self.personal / instalacion.MARCA).stat().st_mode & 0o777, 0o600)
            self.assertEqual(instalacion.en_marcha(self.personal), url)
        self.assertIsNone(instalacion.en_marcha(self.personal))       # se cerró sin borrar la marca
        instalacion.anotar_en_marcha(self.personal, None)
        self.assertFalse((self.personal / instalacion.MARCA).exists())


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