#!/usr/bin/env python3
"""Listas de lo que sp instalo desde fuentes, en forma directa (make install).

Cada proyecto deja PREFIX/var/lib/sp/instalados/NOMBRE.json: cada archivo con
su huella (sha256) y los directorios que creo. Con eso se lo desinstala sin
las fuentes ni la carpeta donde se compilo. Pedido del autor, 18/10/2026
(siru/summapack/PAQUETES.md, "Requisito: lo instalado desde fuentes se puede
desinstalar"). Generaliza bin/manifiesto-instalacion (el de summapack, mismo
formato).
Tambien deja PREFIX/var/lib/summapack/desinstalar/fuentes/NOMBRE.sh para
ejecutar directamente la desinstalacion.

  sp-instalados registrar NOMBRE --version V --prefix P [--lista F] [--rutas F]...
      --lista: renglones A:/ruta (archivo) y D:/ruta (directorio), como los
               deja summapack-install (el envoltorio de install) o el
               listado.ls de summapack
      --rutas: una ruta por renglon (install_manifest.txt de cmake,
               .packlist de Perl)
      --json:  una lista .json ya hecha: la de simplot
               (share/simplot/install-manifest.json, rutas relativas a
               PREFIX) o una con "archivos": [{"ruta": ...}]; el .json
               mismo tambien queda anotado
      --incluir-anterior: lo que ya dice NOMBRE.json se suma (summapack:
               su make install escribe su lista y despues se agrega la de
               mem_util)
      Agrega los enlaces simbolicos de la misma carpeta que apuntan a un
      archivo anotado (los que crea libtool con ln -s). Si ya habia una lista
      de NOMBRE (otra version), borra lo que la anterior tenia y la nueva no,
      si sigue intacto.
  sp-instalados listar --prefix P
  sp-instalados desinstalar NOMBRE --prefix P [--forzar]
      Borra los archivos de la lista. Si alguno cambio (otra huella) o es de
      un paquete de dpkg/rpm, no borra nada y lo dice; con --forzar borra
      los intactos y deja los otros.
"""

import argparse
import hashlib
import json
import os
from pathlib import Path
import re
import shlex
import shutil
import subprocess
import sys

FORMATO = 1


def fallar(mensaje):
    raise SystemExit(f"sp-instalados: {mensaje}")


def carpeta(prefix):
    return Path(prefix) / "var/lib/sp/instalados"


def guion_desinstalar(prefix, nombre):
    if not re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9+_.-]*", nombre):
        fallar(f"nombre de proyecto inseguro: {nombre}")
    return Path(prefix) / "var/lib/summapack/desinstalar/fuentes" / f"{nombre}.sh"


def validar_prefix(prefix):
    prefix = prefix.rstrip("/")
    if not prefix.startswith("/") or prefix in ("", "/") or ".." in Path(prefix).parts:
        fallar("PREFIX debe ser absoluto y no puede ser / ni contener ..")
    return prefix


def ruta_valida(valor, prefix):
    valor = os.path.normpath(valor)
    if not valor.startswith("/") or ".." in Path(valor).parts:
        fallar(f"ruta insegura: {valor}")
    if not (valor.startswith(prefix + "/") or valor.startswith("/etc/")):
        fallar(f"ruta fuera de {prefix} y /etc: {valor}")
    return valor


def huella(ruta):
    ruta = Path(ruta)
    if ruta.is_symlink():
        return {"tipo": "enlace", "sha256": hashlib.sha256(os.readlink(ruta).encode()).hexdigest()}
    if ruta.is_file():
        return {"tipo": "archivo", "sha256": hashlib.sha256(ruta.read_bytes()).hexdigest()}
    return None


def de_un_paquete(ruta):
    for orden in (["dpkg-query", "-S", ruta], ["rpm", "-qf", ruta]):
        if shutil.which(orden[0]) and subprocess.run(
                orden, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=False).returncode == 0:
            return True
    return False


def leer(prefix, nombre):
    archivo = carpeta(prefix) / f"{nombre}.json"
    if not archivo.is_file() and nombre == "summapack":
        # la lista que summapack dejaba antes del 18/10/2026
        viejo = Path(prefix) / "share/summapack/install-manifest.json"
        if viejo.is_file():
            archivo = viejo
    if not archivo.is_file() or archivo.is_symlink():
        return None, archivo
    datos = json.loads(archivo.read_text())
    if datos.get("version") != FORMATO or datos.get("prefix") != prefix:
        fallar(f"lista incompatible con {prefix}: {archivo}")
    return datos, archivo


def borrar_directorios(directorios, prefix):
    for d in sorted(set(directorios), key=len, reverse=True):
        if d in (prefix, "/", "/etc"):
            continue
        try:
            Path(d).rmdir()  # solo si quedo vacio
        except OSError:
            pass


def registrar(a):
    prefix = validar_prefix(a.prefix)
    guion = guion_desinstalar(prefix, a.nombre)
    archivos, directorios = set(), set()
    for f in a.lista or []:
        for linea in Path(f).read_text().splitlines():
            if linea.startswith("A:"):
                archivos.add(ruta_valida(linea[2:], prefix))
            elif linea.startswith("D:"):
                d = os.path.normpath(linea[2:])
                if d.startswith(prefix + "/") or d.startswith("/etc/"):
                    directorios.add(d)
    for f in a.json or []:
        datos = json.loads(Path(f).read_text())
        lista = datos.get("archivos", [])
        rutas = [e["ruta"] for e in lista] if isinstance(lista, list) else list(lista)
        for r in rutas:
            archivos.add(ruta_valida(r if r.startswith("/") else prefix + "/" + r, prefix))
        archivos.add(ruta_valida(os.path.abspath(f), prefix))
    for f in a.rutas or []:
        for linea in Path(f).read_text().splitlines():
            linea = linea.strip().split(" ")[0] if linea.strip() else ""
            if linea:
                archivos.add(ruta_valida(linea, prefix))
    anterior, archivo_anterior = leer(prefix, a.nombre)
    destino = carpeta(prefix) / f"{a.nombre}.json"
    if anterior and a.incluir_anterior:
        for e in anterior["archivos"]:
            if Path(e["ruta"]).is_file() or Path(e["ruta"]).is_symlink():
                archivos.add(e["ruta"])
        directorios.update(anterior.get("directorios", []))
        anterior = None
    # lo que no existe (un renglon de mas): afuera; los enlaces de libtool:
    # adentro
    archivos = {r for r in archivos if Path(r).is_file() or Path(r).is_symlink()}
    cambio = True
    while cambio:
        cambio = False
        for d in {str(Path(r).parent) for r in archivos}:
            for e in Path(d).iterdir():
                if e.is_symlink() and str(e) not in archivos:
                    objetivo = os.path.normpath(os.path.join(d, os.readlink(e)))
                    if objetivo in archivos:
                        archivos.add(str(e)); cambio = True
    entradas = []
    for r in sorted(archivos):
        h = huella(r)
        if h:
            entradas.append({"ruta": r, **h})
        padre = Path(r).parent
        while str(padre) not in (prefix, "/", "/etc") and padre != padre.parent:
            directorios.add(str(padre)); padre = padre.parent
    if anterior:
        nuevas = {e["ruta"] for e in entradas}
        for e in anterior["archivos"]:
            if e["ruta"] in nuevas:
                continue
            if huella(e["ruta"]) == {"tipo": e["tipo"], "sha256": e["sha256"]}:
                Path(e["ruta"]).unlink()
                print(f"  sale de la version anterior: {e['ruta']}")
        borrar_directorios([d for d in anterior.get("directorios", []) if d not in directorios], prefix)
        if archivo_anterior != destino:
            archivo_anterior.unlink()
    destino.parent.mkdir(parents=True, exist_ok=True)
    datos = {"version": FORMATO, "nombre": a.nombre, "version_paquete": a.version,
             "prefix": prefix, "archivos": entradas, "directorios": sorted(directorios)}
    temporal = destino.with_suffix(".nuevo")
    temporal.write_text(json.dumps(datos, indent=2, ensure_ascii=False) + "\n")
    temporal.replace(destino)
    guion.parent.mkdir(parents=True, exist_ok=True)
    programa = shlex.quote(str(Path(prefix) / "bin/sp-instalados"))
    nombre = shlex.quote(a.nombre)
    prefijo = shlex.quote(prefix)
    contenido = ("#!/bin/sh\nset -eu\n"
                 f"if [ -x {programa} ]; then exec {programa} desinstalar {nombre} --prefix {prefijo} \"$@\"; fi\n"
                 "if command -v sp-instalados >/dev/null 2>&1; then\n"
                 f"    exec sp-instalados desinstalar {nombre} --prefix {prefijo} \"$@\"\n"
                 "fi\necho 'desinstalar: falta sp-instalados' >&2\nexit 127\n")
    temporal_guion = guion.with_suffix(".nuevo")
    temporal_guion.write_text(contenido)
    temporal_guion.chmod(0o755)
    temporal_guion.replace(guion)
    print(f"sp: {a.nombre} {a.version}: {len(entradas)} archivos anotados en {destino}; desinstalador: {guion}")


def listar(a):
    prefix = validar_prefix(a.prefix)
    for f in sorted(carpeta(prefix).glob("*.json")) if carpeta(prefix).is_dir() else []:
        datos = json.loads(f.read_text())
        print(f"{datos.get('nombre', f.stem)}\t{datos.get('version_paquete', '?')}\t{len(datos['archivos'])} archivos\t{prefix}")
    viejo = Path(prefix) / "share/summapack/install-manifest.json"
    if viejo.is_file() and not (carpeta(prefix) / "summapack.json").exists():
        datos = json.loads(viejo.read_text())
        print(f"summapack\t?\t{len(datos['archivos'])} archivos\t{prefix}")


def desinstalar(a):
    prefix = validar_prefix(a.prefix)
    guion = guion_desinstalar(prefix, a.nombre)
    datos, archivo = leer(prefix, a.nombre)
    if not datos:
        fallar(f"{a.nombre} no esta instalado desde fuentes en {prefix} (falta {archivo})")
    cambiados, de_paquete = [], []
    for e in datos["archivos"]:
        r = ruta_valida(e["ruta"], prefix)
        if huella(r) != {"tipo": e["tipo"], "sha256": e["sha256"]}:
            cambiados.append(r)
        elif de_un_paquete(r):
            de_paquete.append(r)
    if (cambiados or de_paquete) and not a.forzar:
        for r in cambiados:
            print(f"  cambio o falta: {r}", file=sys.stderr)
        for r in de_paquete:
            print(f"  es de un paquete de dpkg/rpm: {r}", file=sys.stderr)
        fallar(f"{a.nombre}: no se borra nada (--forzar borra los intactos y deja estos)")
    borrados = 0
    for e in datos["archivos"]:
        r = e["ruta"]
        if r in cambiados or r in de_paquete:
            print(f"  se deja: {r}")
            continue
        Path(r).unlink(); borrados += 1
    archivo.unlink()
    borrar_directorios(datos.get("directorios", []) + [str(carpeta(prefix)), str(carpeta(prefix).parent)], prefix)
    if guion.is_file() and not guion.is_symlink():
        guion.unlink()
        borrar_directorios([str(guion.parent), str(guion.parent.parent)], prefix)
    print(f"sp: {a.nombre}: desinstalados {borrados} archivos de {prefix}")


def main():
    p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    s = p.add_subparsers(dest="modo")  # required=: Python 3.7; Leap 15.4 trae 3.6
    s.required = True
    r = s.add_parser("registrar"); r.add_argument("nombre"); r.add_argument("--version", required=True)
    r.add_argument("--prefix", required=True); r.add_argument("--lista", action="append")
    r.add_argument("--rutas", action="append"); r.add_argument("--json", action="append")
    r.add_argument("--incluir-anterior", action="store_true")
    l = s.add_parser("listar"); l.add_argument("--prefix", required=True)
    d = s.add_parser("desinstalar"); d.add_argument("nombre"); d.add_argument("--prefix", required=True)
    d.add_argument("--forzar", action="store_true")
    a = p.parse_args()
    {"registrar": registrar, "listar": listar, "desinstalar": desinstalar}[a.modo](a)


if __name__ == "__main__":
    main()
