"""
Funções utilitárias para normalização e formatação de dados
"""
import unicodedata
import re


def normalize_name(name):
    """
    Normaliza nomes removendo acentos e substituindo espaços por underscores
    
    Args:
        name: Nome a ser normalizado
        
    Returns:
        str: Nome normalizado (lowercase, sem acentos, underscores no lugar de espaços)
        
    Exemplos:
        "Capacetes" -> "capacetes"
        "Antigas Wands e Rods" -> "antigas_wands_rods"
        "Calças" -> "calcas"
    """
    if not name:
        return ""
    
    # Remove acentos
    nfd = unicodedata.normalize('NFD', name)
    name_no_accent = ''.join(c for c in nfd if unicodedata.category(c) != 'Mn')
    
    # Converte para lowercase e substitui espaços por underscores
    normalized = re.sub(r'[^a-z0-9]+', '_', name_no_accent.lower())
    
    # Remove underscores do início e fim
    return normalized.strip('_')


def parse_int(text):
    """
    Extrai um inteiro de um texto, removendo caracteres não numéricos
    
    Args:
        text: Texto que pode conter números
        
    Returns:
        int ou None: Número extraído ou None se não encontrar
    """
    if not text:
        return None
    
    # Remove tudo que não for dígito
    numbers = re.sub(r'\D', '', str(text))
    
    return int(numbers) if numbers else None


def parse_float(text):
    """
    Extrai um float de um texto
    
    Args:
        text: Texto que pode conter números decimais
        
    Returns:
        float ou None: Número extraído ou None se não encontrar
    """
    if not text:
        return None
    
    # Remove tudo exceto dígitos, ponto e vírgula
    clean_text = re.sub(r'[^\d.,]', '', str(text))
    
    # Substitui vírgula por ponto
    clean_text = clean_text.replace(',', '.')
    
    try:
        return float(clean_text)
    except ValueError:
        return None


def clean_text(text):
    """
    Limpa texto removendo espaços extras e quebras de linha
    
    Args:
        text: Texto a ser limpo
        
    Returns:
        str: Texto limpo
    """
    if not text:
        return ""
    
    # Remove espaços extras e quebras de linha
    cleaned = re.sub(r'\s+', ' ', str(text)).strip()
    
    return cleaned


def normalize_column_name(column_name):
    """
    Normaliza nome de coluna para identificador SQL válido
    
    Args:
        column_name: Nome da coluna original
        
    Returns:
        str: Nome normalizado (lowercase, sem acentos, underscores, válido para SQL)
        
    Exemplos:
        "Lvl" -> "lvl"
        "Dano Elemental" -> "dano_elemental"
        "Mod. de Defesa" -> "mod_de_defesa"
        "Dropa de" -> "dropa_de"
    """
    if not column_name:
        return ""
    
    # Remove acentos
    nfd = unicodedata.normalize('NFD', column_name)
    name_no_accent = ''.join(c for c in nfd if unicodedata.category(c) != 'Mn')
    
    # Converte para lowercase
    normalized = name_no_accent.lower()
    
    # Substitui caracteres não alfanuméricos por underscore
    normalized = re.sub(r'[^a-z0-9]+', '_', normalized)
    
    # Remove underscores do início e fim
    normalized = normalized.strip('_')
    
    # Garante que não começa com número
    if normalized and normalized[0].isdigit():
        normalized = 'col_' + normalized
    
    # Se ficou vazio, retorna um nome padrão
    if not normalized:
        return "coluna_sem_nome"
    
    return normalized