"""PIN de 6 dígitos con hash y sesión firmada (D8).

El PIN nunca se guarda en claro. El hash vive en la variable de entorno
`CAPILLA_PIN_HASH` o, si no está, en el archivo local `pin.hash` del proyecto.
Si no hay ninguno se usa un PIN por defecto documentado y la pantalla de acceso
lo advierte.

Cambiar el PIN cuando se quiera (no hace falta tocar código ni reiniciar):

    python -m capilla_web.seguridad definir 681173

También se puede generar el hash para ponerlo en la variable de entorno:

    python -m capilla_web.seguridad hash 681173
"""
import hashlib
import hmac
import os
import sys

from . import config

ITERACIONES = 200_000
PIN_POR_DEFECTO = "000000"
SAL_POR_DEFECTO = b"capilla-pin-por-defecto"
CLAVE_SESION = "pin_ok"


def hash_pin(pin, sal=None, iteraciones=ITERACIONES):
    """Hash almacenable del PIN (con sal aleatoria si no se indica una)."""
    sal = sal or os.urandom(16)
    derivado = hashlib.pbkdf2_hmac("sha256", str(pin).encode("utf-8"), sal, iteraciones)
    return f"pbkdf2_sha256${iteraciones}${sal.hex()}${derivado.hex()}"


def verificar_pin(pin, almacenado):
    """True si el PIN corresponde al hash almacenado."""
    try:
        algoritmo, iteraciones, sal_hex, esperado = almacenado.split("$")
        if algoritmo != "pbkdf2_sha256":
            return False
        derivado = hashlib.pbkdf2_hmac(
            "sha256", str(pin).encode("utf-8"), bytes.fromhex(sal_hex), int(iteraciones)
        )
        return hmac.compare_digest(derivado.hex(), esperado)
    except (AttributeError, ValueError):
        return False


def hash_almacenado():
    """Hash configurado: variable de entorno o archivo local. Cadena vacía si no hay."""
    del_entorno = str(config.PIN_HASH or "").strip()
    if del_entorno:
        return del_entorno
    try:
        with open(config.ARCHIVO_PIN, encoding="utf-8") as archivo:
            return archivo.read().strip()
    except OSError:
        return ""


def hash_efectivo():
    """Hash que se usa para validar: el configurado o el del PIN por defecto."""
    return hash_almacenado() or hash_pin(PIN_POR_DEFECTO, sal=SAL_POR_DEFECTO)


def usando_pin_por_defecto():
    return not hash_almacenado()


def pin_valido(pin):
    """El PIN debe ser de 6 dígitos y coincidir con el hash configurado."""
    texto = str(pin or "")
    if len(texto) != 6 or not texto.isdigit():
        return False
    return verificar_pin(texto, hash_efectivo())


def definir_pin(pin):
    """Guarda el hash del PIN en el archivo local. Devuelve la ruta."""
    texto = str(pin or "")
    if len(texto) != 6 or not texto.isdigit():
        raise ValueError("El PIN debe tener exactamente 6 dígitos")
    with open(config.ARCHIVO_PIN, "w", encoding="utf-8") as archivo:
        archivo.write(hash_pin(texto) + "\n")
    return config.ARCHIVO_PIN


def main():
    """CLI: `definir <pin>` guarda el PIN; `hash <pin>` solo imprime el hash."""
    if len(sys.argv) != 3 or sys.argv[1] not in ("definir", "hash"):
        print(__doc__)
        sys.exit(1)
    pin = sys.argv[2]
    try:
        if sys.argv[1] == "definir":
            print(f"PIN guardado en {definir_pin(pin)}")
        else:
            print(hash_pin(pin))
    except ValueError as e:
        print(e)
        sys.exit(1)


if __name__ == "__main__":
    main()
