Funcions

#!/usr/bin/env python3
"""
Generador de contrasenyes amb opcions de complexitat.

Permet generar contrasenyes aleatòries amb control sobre
els tipus de caràcters inclosos i avaluar-ne la fortalesa.
"""

import random
import string


def generar_contrasenya(longitud=12, majuscules=True, numeros=True, simbols=False):
    """
    Genera una contrasenya aleatòria.
    
    :param longitud: Nombre de caràcters (per defecte 12).
    :param majuscules: Inclou majúscules (per defecte True).
    :param numeros: Inclou números (per defecte True).
    :param simbols: Inclou símbols (per defecte False).
    :return: Contrasenya generada.
    """
    # Construir el conjunt de caràcters disponibles
    caracters = string.ascii_lowercase  # Sempre incloem minúscules
    
    if majuscules:
        caracters += string.ascii_uppercase
    if numeros:
        caracters += string.digits
    if simbols:
        caracters += "!@#$%^&*()-_=+[]{}|;:,.<>?"
    
    # Generar la contrasenya
    contrasenya = ""
    for _ in range(longitud):
        contrasenya += random.choice(caracters)
    
    return contrasenya


def avaluar_fortalesa(contrasenya):
    """
    Avalua la fortalesa d'una contrasenya.
    
    :param contrasenya: Contrasenya a avaluar.
    :return: "feble", "mitjana" o "forta".
    
    Criteris:
    - Feble: menys de 8 caràcters o només un tipus de caràcter.
    - Mitjana: 8-11 caràcters amb almenys 2 tipus de caràcters.
    - Forta: 12+ caràcters amb almenys 3 tipus de caràcters.
    """
    longitud = len(contrasenya)
    
    # Comptar tipus de caràcters presents
    te_minuscules = any(c in string.ascii_lowercase for c in contrasenya)
    te_majuscules = any(c in string.ascii_uppercase for c in contrasenya)
    te_numeros = any(c in string.digits for c in contrasenya)
    te_simbols = any(c in "!@#$%^&*()-_=+[]{}|;:,.<>?" for c in contrasenya)
    
    tipus_caracters = sum([te_minuscules, te_majuscules, te_numeros, te_simbols])
    
    # Avaluar fortalesa
    if longitud < 8 or tipus_caracters < 2:
        return "feble"
    elif longitud >= 12 and tipus_caracters >= 3:
        return "forta"
    else:
        return "mitjana"


def mostrar_contrasenya(contrasenya):
    """Mostra una contrasenya amb la seva avaluació."""
    fortalesa = avaluar_fortalesa(contrasenya)
    
    print(f"  {contrasenya}  ({len(contrasenya)} cars.) és {fortalesa}.")


if __name__ == "__main__":
    print("=== Generador de contrasenyes ===")
    print()
    
    print("Contrasenyes per defecte (12 cars., majúscules i números):")
    for _ in range(3):
        pwd = generar_contrasenya()
        mostrar_contrasenya(pwd)
    
    print()
    print("Contrasenyes curtes (8 cars., només minúscules):")
    for _ in range(3):
        pwd = generar_contrasenya(longitud=8, majuscules=False, numeros=False)
        mostrar_contrasenya(pwd)
    
    print()
    print("Contrasenyes fortes (16 cars., amb símbols):")
    for _ in range(3):
        pwd = generar_contrasenya(longitud=16, simbols=True)
        mostrar_contrasenya(pwd)
    
    print()
    print("Contrasenyes molt llargues (24 cars., tots els caràcters):")
    for _ in range(3):
        pwd = generar_contrasenya(longitud=24, simbols=True)
        mostrar_contrasenya(pwd)

#!/usr/bin/env python3
"""Funcions per validar entrada de l'usuari."""


def llegir_enter(prompt, minim=None, maxim=None, defecte=None):
    """
    Demana un nombre enter a l'usuari amb validació.
    
    :param prompt: Missatge a mostrar.
    :param minim: Valor mínim permès (opcional).
    :param maxim: Valor màxim permès (opcional).
    :param defecte: Valor per defecte si l'usuari no escriu res (opcional).
    :return: El nombre enter validat.
    """
    while True:
        # Construir el prompt amb informació addicional
        prompt_complet = prompt
        if defecte is not None:
            prompt_complet += f" [{defecte}]"
        prompt_complet += ": "
        
        entrada = input(prompt_complet).strip()
        
        # Valor per defecte
        if entrada == "" and defecte is not None:
            return defecte
        
        # Validar que sigui un enter
        if not entrada.lstrip("-").isdigit():
            print("Error: has d'introduir un nombre enter.")
            continue
        
        valor = int(entrada)
        
        # Validar rang
        if minim is not None and valor < minim:
            print(f"Error: el valor ha de ser almenys {minim}.")
            continue
        
        if maxim is not None and valor > maxim:
            print(f"Error: el valor ha de ser com a màxim {maxim}.")
            continue
        
        return valor


def llegir_si_no(prompt, defecte=True):
    """
    Demana una resposta sí/no a l'usuari.
    
    :param prompt: Missatge a mostrar.
    :param defecte: Valor per defecte (True = sí, False = no).
    :return: True o False.
    """
    opcio_defecte = "S/n" if defecte else "s/N"
    
    while True:
        entrada = input(f"{prompt} [{opcio_defecte}]: ").strip().lower()
        
        if entrada == "":
            return defecte
        if entrada in ["s", "sí", "si", "yes", "y"]:
            return True
        if entrada in ["n", "no"]:
            return False
        
        print("Error: respon 's' o 'n'.")


# Exemple d'ús
if __name__ == "__main__":
    print("=== Configuració de connexió ===")
    print()
    
    port = llegir_enter("Port", minim=1, maxim=65535)
    timeout = llegir_enter("Timeout (segons)", minim=1, maxim=300, defecte=30)
    ssl = llegir_si_no("Usar SSL?", defecte=True)
    
    print()
    print("Configuració seleccionada:")
    print(f"  Port:    {port}")
    print(f"  Timeout: {timeout}s")
    print(f"  SSL:     {'Sí' if ssl else 'No'}")

#!/usr/bin/env python3
"""
Calculadora de temps d'execució.

Funcions per convertir, formatar i sumar durades de temps,
útils per analitzar logs i temps d'execució de processos.
"""


def segons_a_hms(segons):
    """
    Converteix segons a hores, minuts i segons.
    
    :param segons: Durada en segons (enter o decimal).
    :return: Tupla (hores, minuts, segons).
    
    Exemple:
        >>> segons_a_hms(3725)
        (1, 2, 5)
    """
    segons = int(segons)
    hores = segons // 3600
    minuts = (segons % 3600) // 60
    secs = segons % 60
    return hores, minuts, secs


def formatar_duracio(segons, format="complet"):
    """
    Formata una durada en segons segons el format especificat.
    
    :param segons: Durada en segons.
    :param format: Tipus de format:
        - "complet": 2h 15m 30s
        - "curt": 02:15:30
        - "paraules": 2 hores, 15 minuts i 30 segons
    :return: Cadena formatada.
    """
    hores, minuts, secs = segons_a_hms(segons)
    
    if format == "complet":
        parts = []
        if hores > 0:
            parts.append(f"{hores}h")
        if minuts > 0:
            parts.append(f"{minuts}m")
        if secs > 0 or not parts:
            parts.append(f"{secs}s")
        return " ".join(parts)
    
    elif format == "curt":
        return f"{hores:02d}:{minuts:02d}:{secs:02d}"
    
    elif format == "paraules":
        parts = []
        if hores > 0:
            parts.append(f"{hores} {'hora' if hores == 1 else 'hores'}")
        if minuts > 0:
            parts.append(f"{minuts} {'minut' if minuts == 1 else 'minuts'}")
        if secs > 0 or not parts:
            parts.append(f"{secs} {'segon' if secs == 1 else 'segons'}")
        
        if len(parts) == 1:
            return parts[0]
        elif len(parts) == 2:
            return f"{parts[0]} i {parts[1]}"
        else:
            return f"{parts[0]}, {parts[1]} i {parts[2]}"
    
    else:
        raise ValueError(f"Format desconegut: {format}")


def sumar_durades(*durades):
    """
    Suma múltiples durades i retorna el total formatat.
    
    :param durades: Durades en segons (nombre variable d'arguments).
    :return: Diccionari amb el total en segons i en diferents formats.
    
    Exemple:
        >>> sumar_durades(120, 3600, 45)
        {'segons': 3765, 'complet': '1h 2m 45s', ...}
    """
    total = sum(durades)
    
    return {
        "segons": total,
        "complet": formatar_duracio(total, "complet"),
        "curt": formatar_duracio(total, "curt"),
        "paraules": formatar_duracio(total, "paraules"),
    }


if __name__ == "__main__":
    print("=== Calculadora de temps d'execució ===")
    print()
    
    # Exemple 1: Conversió bàsica
    print("Conversió de segons a hores:minuts:segons:")
    for segons in [45, 125, 3725, 7384, 86400]:
        h, m, s = segons_a_hms(segons)
        print(f"  {segons:6} segons = {h}h {m}m {s}s")
    
    print()
    
    # Exemple 2: Diferents formats
    print("Diferents formats per a 8145 segons:")
    temps = 8145
    print(f"  Complet:  {formatar_duracio(temps, 'complet')}")
    print(f"  Curt:     {formatar_duracio(temps, 'curt')}")
    print(f"  Paraules: {formatar_duracio(temps, 'paraules')}")
    
    print()
    
    # Exemple 3: Temps d'execució de tasques
    print("Temps d'execució de tasques del sistema:")
    tasques = [
        ("Backup base de dades", 1847),
        ("Compressió de logs", 423),
        ("Sincronització remota", 2156),
        ("Neteja de temporals", 67),
    ]
    
    for nom, segons in tasques:
        print(f"  {nom}: {formatar_duracio(segons, 'complet')}")
    
    print()
    
    # Exemple 4: Suma de durades
    print("Temps total de totes les tasques:")
    durades = [t[1] for t in tasques]
    total = sumar_durades(*durades)
    print(f"  Total: {total['segons']} segons")
    print(f"  Format complet: {total['complet']}")
    print(f"  Format curt: {total['curt']}")
    print(f"  Format paraules: {total['paraules']}")
    
    print()
    
    # Exemple 5: Casos especials
    print("Casos especials:")
    print(f"  0 segons: {formatar_duracio(0, 'paraules')}")
    print(f"  1 segon: {formatar_duracio(1, 'paraules')}")
    print(f"  60 segons: {formatar_duracio(60, 'paraules')}")
    print(f"  3600 segons: {formatar_duracio(3600, 'paraules')}")

#!/usr/bin/env python3
"""
Validador de configuració de xarxa.

Funcions per validar adreces IP, màscares de xarxa,
ports i configuracions completes.
"""


def es_ip_valida(ip):
    """
    Comprova si una adreça IPv4 és vàlida.
    
    :param ip: Adreça IP com a cadena (e.g., "192.168.1.1").
    :return: True si és vàlida, False altrament.
    """
    if not isinstance(ip, str):
        return False
    
    parts = ip.split(".")
    
    if len(parts) != 4:
        return False
    
    for part in parts:
        # Ha de ser un nombre
        if not part.isdigit():
            return False
        
        # Ha d'estar entre 0 i 255
        valor = int(part)
        if valor < 0 or valor > 255:
            return False
        
        # No pot tenir zeros a l'esquerra (excepte "0")
        if len(part) > 1 and part[0] == "0":
            return False
    
    return True


def es_mascara_valida(mascara):
    """
    Comprova si una màscara de xarxa és vàlida.
    
    Una màscara vàlida, en binari, és una seqüència d'uns
    seguida d'una seqüència de zeros.
    
    :param mascara: Màscara com a cadena (e.g., "255.255.255.0").
    :return: True si és vàlida, False altrament.
    """
    # Primer ha de ser una IP vàlida
    if not es_ip_valida(mascara):
        return False
    
    # Convertir a binari (32 bits)
    parts = mascara.split(".")
    binari = ""
    for part in parts:
        binari += format(int(part), "08b")
    
    # Ha de ser uns seguits de zeros (no pot haver-hi 01)
    trobat_zero = False
    for bit in binari:
        if bit == "0":
            trobat_zero = True
        elif trobat_zero:
            # Un "1" després d'un "0" no és vàlid
            return False
    
    return True


def es_port_valid(port, permetre_privilegiats=True):
    """
    Comprova si un port és vàlid.
    
    :param port: Número de port.
    :param permetre_privilegiats: Si permet ports < 1024 (per defecte True).
    :return: True si és vàlid, False altrament.
    """
    # Ha de ser un enter
    if not isinstance(port, int):
        return False
    
    # Ha d'estar en el rang vàlid
    if port < 1 or port > 65535:
        return False
    
    # Comprovar ports privilegiats
    if not permetre_privilegiats and port < 1024:
        return False
    
    return True


def validar_configuracio(**params):
    """
    Valida una configuració de xarxa completa.
    
    :param params: Paràmetres de xarxa (ip, mascara, gateway, dns, port).
    :return: Diccionari amb el resultat de cada validació.
    
    Exemple:
        >>> validar_configuracio(ip="192.168.1.10", port=8080)
        {'ip': {'valor': '192.168.1.10', 'valid': True}, ...}
    """
    resultats = {}
    
    for clau, valor in params.items():
        resultat = {"valor": valor, "valid": False, "error": None}
        
        if clau in ["ip", "gateway", "dns"]:
            if es_ip_valida(valor):
                resultat["valid"] = True
            else:
                resultat["error"] = "Adreça IP no vàlida"
        
        elif clau == "mascara":
            if es_mascara_valida(valor):
                resultat["valid"] = True
            else:
                resultat["error"] = "Màscara de xarxa no vàlida"
        
        elif clau == "port":
            permetre = params.get("permetre_privilegiats", True)
            if es_port_valid(valor, permetre):
                resultat["valid"] = True
            else:
                if valor < 1 or valor > 65535:
                    resultat["error"] = "Port fora de rang (1-65535)"
                else:
                    resultat["error"] = "Port privilegiat no permès"
        
        elif clau == "permetre_privilegiats":
            # Paràmetre auxiliar, no cal validar
            continue
        
        else:
            resultat["error"] = f"Paràmetre desconegut: {clau}"
        
        resultats[clau] = resultat
    
    return resultats


def mostrar_validacio(resultats):
    """Mostra els resultats de validació de manera formatada."""
    print("Resultats de la validació:")
    print("-" * 50)
    
    tot_valid = True
    for clau, info in resultats.items():
        icona = "✓" if info["valid"] else "✗"
        estat = "vàlid" if info["valid"] else info["error"]
        print(f"  {icona} {clau}: {info['valor']} ({estat})")
        if not info["valid"]:
            tot_valid = False
    
    print("-" * 50)
    if tot_valid:
        print("✓ Configuració vàlida")
    else:
        print("✗ Configuració amb errors")


if __name__ == "__main__":
    print("=== Validador de configuració de xarxa ===")
    print()
    
    # Exemple 1: Configuració vàlida
    print("Exemple 1: Configuració vàlida")
    resultats = validar_configuracio(
        ip="192.168.1.100",
        mascara="255.255.255.0",
        gateway="192.168.1.1",
        dns="8.8.8.8",
        port=8080
    )
    mostrar_validacio(resultats)
    
    print()
    
    # Exemple 2: Configuració amb errors
    print("Exemple 2: Configuració amb errors")
    resultats = validar_configuracio(
        ip="192.168.1.300",       # IP invàlida
        mascara="255.255.128.0",  # Màscara vàlida
        gateway="192.168.1",      # Gateway invàlid
        port=80,
        permetre_privilegiats=False  # Port privilegiat no permès
    )
    mostrar_validacio(resultats)
    
    print()
    
    # Exemple 3: Validacions individuals
    print("Exemple 3: Validacions individuals")
    print()
    
    ips_a_validar = [
        "192.168.1.1",
        "10.0.0.1",
        "256.1.2.3",
        "192.168.1",
        "192.168.01.1",
    ]
    
    print("Validació d'IPs:")
    for ip in ips_a_validar:
        resultat = "✓ vàlida" if es_ip_valida(ip) else "✗ invàlida"
        print(f"  {ip:18} {resultat}")
    
    print()
    
    mascares_a_validar = [
        "255.255.255.0",
        "255.255.0.0",
        "255.255.255.128",
        "255.255.128.128",  # Invàlida
        "255.0.255.0",      # Invàlida
    ]
    
    print("Validació de màscares:")
    for mascara in mascares_a_validar:
        resultat = "✓ vàlida" if es_mascara_valida(mascara) else "✗ invàlida"
        print(f"  {mascara:18} {resultat}")
    
    print()
    
    ports_a_validar = [
        (22, True),
        (22, False),
        (8080, True),
        (8080, False),
        (70000, True),
    ]
    
    print("Validació de ports:")
    for port, permetre in ports_a_validar:
        resultat = "✓ vàlid" if es_port_valid(port, permetre) else "✗ invàlid"
        mode = "amb privilegiats" if permetre else "sense privilegiats"
        print(f"  Port {port:5} ({mode:18}) {resultat}")