# -*- coding: utf-8 -*-
"""Ajustes de la clínica por instancia (white-label).

Vive en `skeen.clinic.settings` (JSON) y no tiene modelo propio. Antes estos
datos solo existían en el localStorage del navegador de cada equipo; ahora son
compartidos por toda la instancia y los consumen el frontend, la impresión de
tickets y las URLs de pago.

El nombre por defecto es el del brand (`skeen.clinic.brand` -> 'nombre') para no
cambiar lo que ya se ve en producción cuando el parámetro no está guardado.
"""

import json
from urllib.parse import urlparse

SETTINGS_KEY = 'skeen.clinic.settings'
BRAND_KEY = 'skeen.clinic.brand'
BRAND_NOMBRE_DEFAULT = 'SKEEN Derma Experts'

HORA_APERTURA_DEFAULT = '08:00'
HORA_CIERRE_DEFAULT = '19:00'
ZONA_HORARIA_DEFAULT = 'America/Tijuana'
MONEDA_DEFAULT = 'MXN'

# Campos del contrato del endpoint.
CAMPOS = (
    'nombre', 'telefono', 'email', 'direccion', 'web', 'rfc',
    'horario_apertura', 'horario_cierre', 'zona_horaria', 'url_publica',
    'moneda_base', 'nota_ticket',
)

# ---------------------------------------------------------------------------
# Impuestos (bloque anidado dentro del mismo JSON de ajustes).
#
# El impuesto es propio y simple: `account`/`l10n_mx` están desinstalados, así
# que no hay motor fiscal de Odoo. Con `activo=False` TODO el sistema se
# comporta como antes (sin cálculo, sin desglose, sin renglón en tickets); esa
# es la regla de oro y por eso los defaults son apagados y en cero.
#
#   activo:                     enciende el cálculo en POS, tickets y reportes
#   nombre:                     etiqueta del impuesto (p. ej. 'IVA')
#   tasa_default:               % que se aplica cuando el catálogo no fija una
#   precios_incluyen_impuesto:  el precio capturado YA trae impuesto; el
#                               subtotal se desglosa hacia atrás
#   tasa_opciones:              tasas ofrecidas en los formularios (%)
# ---------------------------------------------------------------------------
IMPUESTOS_DEFAULT = {
    'activo': False,
    'nombre': 'IVA',
    'tasa_default': 0.0,
    'precios_incluyen_impuesto': False,
    'tasa_opciones': [0, 8, 16],
}


def _num(valor, por_defecto=0.0):
    """Número finito de un valor JSON, sin explotar con None/texto."""
    try:
        n = float(valor)
    except (TypeError, ValueError):
        return por_defecto
    if n != n or n in (float('inf'), float('-inf')):  # NaN / infinitos
        return por_defecto
    return n


def _bool(valor, por_defecto=False):
    if isinstance(valor, bool):
        return valor
    if valor in ('1', 'true', 'True', 'si', 'sí', 1):
        return True
    if valor in ('0', 'false', 'False', 'no', 0):
        return False
    return por_defecto


def normalizar_impuestos(raw):
    """Bloque `impuestos` completo, con defaults, a partir de lo guardado.

    Tolerante: nunca lanza. Lo inválido cae al default (una instancia sin
    configurar debe verse EXACTAMENTE como hoy).
    """
    out = dict(IMPUESTOS_DEFAULT)
    if not isinstance(raw, dict):
        return out
    out['activo'] = _bool(raw.get('activo'), IMPUESTOS_DEFAULT['activo'])
    out['precios_incluyen_impuesto'] = _bool(
        raw.get('precios_incluyen_impuesto'),
        IMPUESTOS_DEFAULT['precios_incluyen_impuesto'])
    nombre = str(raw.get('nombre') or '').strip()
    out['nombre'] = (nombre or IMPUESTOS_DEFAULT['nombre'])[:40]
    out['tasa_default'] = min(max(_num(raw.get('tasa_default')), 0.0), 100.0)
    opciones = raw.get('tasa_opciones')
    if isinstance(opciones, list):
        limpias = []
        for o in opciones:
            n = _num(o, None)
            if n is None:
                continue
            n = min(max(n, 0.0), 100.0)
            if n not in limpias:
                limpias.append(n)
        if limpias:
            out['tasa_opciones'] = sorted(limpias)
    return out


def validar_impuestos(raw):
    """Valida el bloque `impuestos` de un PUT. Lanza ValueError si algo no
    cuadra (se traduce a 400 en el controlador).

    Devuelve SOLO las claves presentes (ya normalizadas) para que el merge no
    reinicie lo que el PUT no tocó."""
    if raw is None:
        return None
    if not isinstance(raw, dict):
        raise ValueError('El bloque de impuestos debe ser un objeto')
    out = {}
    if 'activo' in raw:
        if not isinstance(raw['activo'], bool):
            raise ValueError('El campo activo de impuestos debe ser verdadero o falso')
        out['activo'] = raw['activo']
    if 'precios_incluyen_impuesto' in raw:
        if not isinstance(raw['precios_incluyen_impuesto'], bool):
            raise ValueError('precios_incluyen_impuesto debe ser verdadero o falso')
        out['precios_incluyen_impuesto'] = raw['precios_incluyen_impuesto']
    if 'nombre' in raw:
        if not isinstance(raw['nombre'], str) or not raw['nombre'].strip():
            raise ValueError('El nombre del impuesto no puede estar vacío')
        if len(raw['nombre'].strip()) > 40:
            raise ValueError('El nombre del impuesto es demasiado largo (máx. 40)')
        out['nombre'] = raw['nombre'].strip()[:40]
    if 'tasa_default' in raw:
        n = _num(raw['tasa_default'], None)
        if n is None:
            raise ValueError('La tasa por defecto debe ser un número')
        if not (0 <= n <= 100):
            raise ValueError('La tasa por defecto debe estar entre 0 y 100')
        out['tasa_default'] = n
    if 'tasa_opciones' in raw:
        opciones = raw['tasa_opciones']
        if not isinstance(opciones, list) or not opciones:
            raise ValueError('tasa_opciones debe ser una lista de números')
        limpias = []
        for o in opciones:
            n = _num(o, None)
            if n is None:
                raise ValueError('Cada opción de tasa debe ser un número')
            if not (0 <= n <= 100):
                raise ValueError('Las opciones de tasa deben estar entre 0 y 100')
            if n not in limpias:
                limpias.append(n)
        out['tasa_opciones'] = sorted(limpias)
    return out


def get_impuestos(env):
    """Bloque de impuestos vigente (copia). Fuente única para modelos y API."""
    return normalizar_impuestos(get_settings(env).get('impuestos'))

# ---------------------------------------------------------------------------
# Reservas en línea (portal público de auto-agendado).
#
# Bloque anidado del mismo JSON de ajustes, igual que `impuestos`. La regla de
# oro: con `activo=False` NADA cambia en la instancia (el portal público
# responde 404 y el frontend no muestra enlaces). Por eso el default es apagado.
# ---------------------------------------------------------------------------
RESERVAS_ONLINE_DEFAULT = {
    'activo': False,
    'titulo': 'Reserva tu cita en línea',
    'descripcion': '',
    'requiere_confirmacion': True,
    'permitir_eleccion_doctor': True,
    'permitir_sucursal': False,
    'max_dias_futuro': 60,
    'min_horas_anticipacion': 2,
    'permitir_cancelar': True,
    'cancelar_hasta_horas': 24,
    'mensaje_confirmacion': '',
    'telefono_contacto': '',
}

# Rangos razonables de validación del PUT (días / horas).
RESERVAS_MAX_DIAS_MIN, RESERVAS_MAX_DIAS_MAX = 1, 365
RESERVAS_MIN_ANTICIPACION_MAX = 168   # 1 semana
RESERVAS_CANCELAR_HASTA_MAX = 168     # 1 semana


def _int(valor, por_defecto=0):
    try:
        return int(valor)
    except (TypeError, ValueError):
        return por_defecto


def normalizar_reservas_online(raw):
    """Bloque `reservas_online` completo, con defaults. Tolerante: nunca lanza."""
    out = dict(RESERVAS_ONLINE_DEFAULT)
    if not isinstance(raw, dict):
        return out
    for k in ('activo', 'requiere_confirmacion', 'permitir_eleccion_doctor',
              'permitir_sucursal', 'permitir_cancelar'):
        out[k] = _bool(raw.get(k), RESERVAS_ONLINE_DEFAULT[k])
    out['titulo'] = (str(raw.get('titulo') or '').strip()
                     or RESERVAS_ONLINE_DEFAULT['titulo'])[:120]
    out['descripcion'] = str(raw.get('descripcion') or '')[:500]
    out['mensaje_confirmacion'] = str(raw.get('mensaje_confirmacion') or '')[:500]
    out['telefono_contacto'] = str(raw.get('telefono_contacto') or '').strip()[:40]
    out['max_dias_futuro'] = min(max(_int(raw.get('max_dias_futuro'),
                                          RESERVAS_ONLINE_DEFAULT['max_dias_futuro']),
                                    RESERVAS_MAX_DIAS_MIN), RESERVAS_MAX_DIAS_MAX)
    out['min_horas_anticipacion'] = min(max(_int(raw.get('min_horas_anticipacion'),
                                                  RESERVAS_ONLINE_DEFAULT['min_horas_anticipacion']),
                                            0), RESERVAS_MIN_ANTICIPACION_MAX)
    out['cancelar_hasta_horas'] = min(max(_int(raw.get('cancelar_hasta_horas'),
                                               RESERVAS_ONLINE_DEFAULT['cancelar_hasta_horas']),
                                          0), RESERVAS_CANCELAR_HASTA_MAX)
    return out


def validar_reservas_online(raw):
    """Valida el bloque `reservas_online` de un PUT. Lanza ValueError si algo no
    cuadra (se traduce a 400). Devuelve SOLO las claves presentes y normalizadas
    para que el merge no reinicie lo que el PUT no tocó."""
    if raw is None:
        return None
    if not isinstance(raw, dict):
        raise ValueError('El bloque de reservas en línea debe ser un objeto')
    out = {}
    for k in ('activo', 'requiere_confirmacion', 'permitir_eleccion_doctor',
              'permitir_sucursal', 'permitir_cancelar'):
        if k in raw:
            if not isinstance(raw[k], bool):
                raise ValueError('El campo %s debe ser verdadero o falso' % k)
            out[k] = raw[k]
    for k, limite in (('titulo', 120), ('descripcion', 500),
                      ('mensaje_confirmacion', 500), ('telefono_contacto', 40)):
        if k in raw:
            if not isinstance(raw[k], str):
                raise ValueError('El campo %s debe ser texto' % k)
            if len(raw[k].strip()) > limite:
                raise ValueError('El campo %s es demasiado largo (máx. %d)' % (k, limite))
            out[k] = raw[k].strip()
    if 'titulo' in raw and not raw['titulo'].strip():
        raise ValueError('El título no puede estar vacío')
    rangos = (
        ('max_dias_futuro', RESERVAS_MAX_DIAS_MIN, RESERVAS_MAX_DIAS_MAX),
        ('min_horas_anticipacion', 0, RESERVAS_MIN_ANTICIPACION_MAX),
        ('cancelar_hasta_horas', 0, RESERVAS_CANCELAR_HASTA_MAX),
    )
    for k, lo, hi in rangos:
        if k in raw:
            if isinstance(raw[k], bool) or not isinstance(raw[k], int):
                raise ValueError('El campo %s debe ser un número entero' % k)
            if not (lo <= raw[k] <= hi):
                raise ValueError('El campo %s debe estar entre %d y %d' % (k, lo, hi))
            out[k] = raw[k]
    return out


def get_reservas_online(env):
    """Bloque de reservas en línea vigente (copia). Fuente única para la API."""
    return normalizar_reservas_online(get_settings(env).get('reservas_online'))

# Horas de agenda de respaldo: el comportamiento de siempre (8:00-19:00).
AGENDA_START_DEFAULT = 8.0
AGENDA_END_DEFAULT = 19.0


def brand_dict(env):
    """Brand vigente (subconjunto suficiente), sin defaults de logos."""
    raw = env['ir.config_parameter'].sudo().get_param(BRAND_KEY)
    if raw:
        try:
            guardado = json.loads(raw)
        except (ValueError, TypeError):
            guardado = None
        if isinstance(guardado, dict):
            return guardado
    return {}


def brand_nombre(env):
    nombre = brand_dict(env).get('nombre')
    nombre = str(nombre).strip() if nombre is not None else ''
    return nombre or BRAND_NOMBRE_DEFAULT


def get_settings(env):
    """Objeto completo de ajustes, con defaults si no hay nada guardado."""
    out = {
        'nombre': brand_nombre(env),
        'telefono': '',
        'email': '',
        'direccion': '',
        'web': '',
        'rfc': '',
        'horario_apertura': HORA_APERTURA_DEFAULT,
        'horario_cierre': HORA_CIERRE_DEFAULT,
        'zona_horaria': ZONA_HORARIA_DEFAULT,
        'url_publica': '',
        'moneda_base': MONEDA_DEFAULT,
        'nota_ticket': '',
        'impuestos': dict(IMPUESTOS_DEFAULT),
        'reservas_online': dict(RESERVAS_ONLINE_DEFAULT),
    }
    raw = env['ir.config_parameter'].sudo().get_param(SETTINGS_KEY)
    if raw:
        try:
            guardado = json.loads(raw)
        except (ValueError, TypeError):
            guardado = None
        if isinstance(guardado, dict):
            for k in CAMPOS:
                if k in guardado and guardado[k] is not None:
                    out[k] = str(guardado[k])
            out['impuestos'] = normalizar_impuestos(guardado.get('impuestos'))
            out['reservas_online'] = normalizar_reservas_online(guardado.get('reservas_online'))
    return out


def set_settings(env, vals):
    """Guarda mergeando sobre lo actual. Devuelve el objeto resultante."""
    if not isinstance(vals, dict):
        raise ValueError('Los ajustes deben ser un objeto')
    actual = get_settings(env)
    for k in CAMPOS:
        if k in vals and vals[k] is not None:
            actual[k] = str(vals[k]).strip()
    if 'impuestos' in vals:
        bloque = validar_impuestos(vals['impuestos'])
        if bloque is not None:
            # Merge anidado: un PUT parcial (p. ej. solo activo) no borra el resto.
            actual['impuestos'] = {**actual['impuestos'], **bloque}
    if 'reservas_online' in vals:
        bloque = validar_reservas_online(vals['reservas_online'])
        if bloque is not None:
            actual['reservas_online'] = {**actual['reservas_online'], **bloque}
    env['ir.config_parameter'].sudo().set_param(
        SETTINGS_KEY, json.dumps(actual, ensure_ascii=False))
    return get_settings(env)


def _hhmm_to_float(valor):
    """'08:00' -> 8.0. None si el formato no es válido."""
    try:
        partes = str(valor).strip().split(':')
        h = int(partes[0])
        m = int(partes[1]) if len(partes) > 1 else 0
        if not (0 <= h <= 24 and 0 <= m <= 59):
            return None
        return h + m / 60.0
    except (ValueError, TypeError, IndexError):
        return None


def agenda_bounds(env):
    """(inicio, fin) de la agenda en horas float.

    Lee horario_apertura/horario_cierre de los ajustes; si faltan o son
    incoherentes usa el horario de siempre (8:00-19:00), de modo que una
    instancia sin configurar se comporta igual que hoy.
    """
    s = get_settings(env)
    inicio = _hhmm_to_float(s.get('horario_apertura'))
    fin = _hhmm_to_float(s.get('horario_cierre'))
    if inicio is None:
        inicio = AGENDA_START_DEFAULT
    if fin is None:
        fin = AGENDA_END_DEFAULT
    if fin <= inicio:
        return AGENDA_START_DEFAULT, AGENDA_END_DEFAULT
    return inicio, fin


def _es_url_privada(url):
    """True si el host es local/privado (no sirve para URLs de pago públicas)."""
    try:
        host = (urlparse(url).hostname or '').lower()
    except ValueError:
        return True
    if not host or host in ('localhost', '127.0.0.1', '::1'):
        return True
    if host.startswith('10.') or host.startswith('192.168.'):
        return True
    if host.startswith('172.'):
        try:
            segundo = int(host.split('.')[1])
        except (IndexError, ValueError):
            return True
        if 16 <= segundo <= 31:
            return True
    return False


def url_publica(env, fallback=''):
    """URL pública base de la instancia, sin barra final.

    Orden: ajustes de la clínica -> brand -> `web.base.url` (solo si es público)
    -> `fallback` (el valor que usaba el código antes). El último escalón
    preserva el comportamiento actual en instancias sin configurar.
    """
    url = (get_settings(env).get('url_publica') or '').strip()
    if not url:
        url = str(brand_dict(env).get('url_publica') or '').strip()
    if not url:
        base = env['ir.config_parameter'].sudo().get_param('web.base.url') or ''
        if base and not _es_url_privada(base):
            url = base
    if not url:
        url = fallback
    return (url or '').rstrip('/')