# -*- coding: utf-8 -*-
"""
Proxy/caché entre WACRM (Supabase) y Odoo.
Expone endpoints REST para el frontend SKEEN.
"""

from odoo import http, fields
from odoo.http import request
from .frontend import json_response, _parse_json_body
from .auth import require_role, require_perm
import os
import logging
import requests
import re
import time
import uuid
from datetime import datetime, timedelta

_logger = logging.getLogger(__name__)


def _get_supabase_config():
    """Lee configuración de Supabase desde variables de entorno o ir.config_parameter."""
    get_param = request.env['ir.config_parameter'].sudo().get_param
    url = os.environ.get('SUPABASE_URL') or get_param('skeen.supabase.url')
    key = os.environ.get('SUPABASE_SERVICE_ROLE_KEY') or get_param('skeen.supabase.service_role_key')
    if not url or not key:
        raise Exception('Falta configuración SUPABASE_URL o SUPABASE_SERVICE_ROLE_KEY')
    return url.rstrip('/'), key


def _supabase_request(method, table, params=None, json=None, headers_extra=None):
    url, key = _get_supabase_config()
    headers = {
        'apikey': key,
        'Authorization': f'Bearer {key}',
        'Content-Type': 'application/json',
        'Accept': 'application/json',
    }
    if headers_extra:
        headers.update(headers_extra)
    response = requests.request(method, f"{url}/rest/v1/{table}", headers=headers, params=params or {}, json=json, timeout=30)
    response.raise_for_status()
    return response.json() if response.text else {}


def _get_wacrm_config():
    """Lee configuración de WACRM API desde variables de entorno o ir.config_parameter."""
    get_param = request.env['ir.config_parameter'].sudo().get_param
    url = os.environ.get('WACRM_API_URL') or get_param('skeen.wacrm.api_url') or 'http://localhost:3000'
    key = os.environ.get('WACRM_API_KEY') or get_param('skeen.wacrm.api_key')
    if not url or not key:
        raise Exception('Falta configuración WACRM_API_URL o WACRM_API_KEY')
    return url.rstrip('/'), key


def _wacrm_request(method, path, json=None, params=None):
    url, key = _get_wacrm_config()
    headers = {
        'Authorization': f'Bearer {key}',
        'Content-Type': 'application/json',
        'Accept': 'application/json',
    }
    response = requests.request(method, f"{url}/api/v1{path}", headers=headers, json=json, params=params or {}, timeout=30)
    response.raise_for_status()
    return response.json()


def _get_hermes_bridge_config():
    """Lee configuración del bridge de Hermes."""
    get_param = request.env['ir.config_parameter'].sudo().get_param
    url = os.environ.get('HERMES_BRIDGE_URL') or get_param('skeen.hermes.bridge_url') or 'http://localhost:8090'
    return url.rstrip('/')


def _hermes_bridge_request(path, json=None):
    url = _get_hermes_bridge_config()
    headers = {
        'Content-Type': 'application/json',
        'Accept': 'application/json',
    }
    response = requests.request('POST', f"{url}{path}", headers=headers, json=json or {}, timeout=30)
    response.raise_for_status()
    return response.json()


def _supabase_request_paginated(table, params=None, page_size=1000):
    """Itera sobre todas las páginas de resultados de PostgREST.

    PostgREST limita `limit` al máximo configurado (por defecto 1000).
    Usamos offset para traer todos los registros en lotes.
    """
    all_data = []
    offset = 0
    params = dict(params or {})
    params['limit'] = page_size
    params['order'] = params.get('order', 'id.asc')
    while True:
        params['offset'] = offset
        page = _supabase_request('GET', table, params)
        if not page:
            break
        all_data.extend(page)
        if len(page) < page_size:
            break
        offset += page_size
    return all_data


def _parse_datetime(value):
    if not value:
        return None
    try:
        from datetime import timezone
        dt = datetime.fromisoformat(value.replace('Z', '+00:00'))
        if dt.tzinfo:
            dt = dt.astimezone(timezone.utc).replace(tzinfo=None)
        return dt
    except Exception:
        return None


class SkeenWacrmProxyController(http.Controller):
    """Endpoints proxy WACRM para el frontend."""

    # ============================================================
    # Sincronización
    # ============================================================
    @http.route('/skeen/frontend/v1/wacrm/sync', type='http', auth='none', methods=['POST', 'OPTIONS'], csrf=False)
    def sync_wacrm(self, **kw):
        """Sincroniza contactos, conversaciones, mensajes, pipelines y deals desde Supabase hacia Odoo.

        El frontend tiene auto-sync cada 15 s y un botón manual: si ambos
        coinciden, dos transacciones escriben las mismas filas del caché y
        Postgres aborta una con "could not serialize access" (500). Se
        reintenta con la transacción limpia, que es lo que hace Odoo en sus
        propios reintentos.
        """
        # Un solo sync a la vez: el frontend auto-sincroniza cada 15 s y tiene
        # botón manual; dos syncs simultáneos chocan en las mismas filas del
        # caché y Postgres aborta uno. El lock de transacción se libera solo.
        try:
            request.env.cr.execute(
                "SELECT pg_try_advisory_xact_lock(hashtext('skeen_wacrm_sync'))")
            libre = request.env.cr.fetchone()[0]
        except Exception:
            libre = True
        if not libre:
            return json_response({
                'status': 'busy',
                'message': 'Ya hay una sincronización en curso; se actualizará en unos segundos',
            })
        ultimo = None
        for intento in range(3):
            try:
                result = self._do_sync()
                return json_response({'status': 'success', 'result': result})
            except Exception as e:
                ultimo = e
                if 'could not serialize' not in str(e).lower():
                    break
                request.env.cr.rollback()
                _logger.warning('Sync WACRM en conflicto (intento %s/3), reintentando', intento + 1)
                time.sleep(0.8 * (intento + 1))
        _logger.exception('Error sincronizando WACRM')
        return json_response({'status': 'error', 'message': str(ultimo)}, 500)

    def _do_sync(self):
        account_id = None

        # 1. Contacts (paginado por si PostgREST limita a 1000 filas)
        contacts_data = _supabase_request_paginated('contacts', {'select': '*'})
        contacts_map = {}
        for item in contacts_data:
            if not account_id and item.get('account_id'):
                account_id = item['account_id']
            vals = {
                'external_id': item['id'],
                'account_id': item.get('account_id'),
                'phone': item.get('phone'),
                'name': item.get('name') or item.get('phone'),
                'email': item.get('email'),
                'company': item.get('company'),
                'avatar_url': item.get('avatar_url'),
                'created_at': _parse_datetime(item.get('created_at')),
                'updated_at': _parse_datetime(item.get('updated_at')),
            }
            existing = request.env['skeen.wacrm.contact'].sudo().search([('external_id', '=', item['id'])], limit=1)
            if existing:
                existing.write(vals)
                contacts_map[item['id']] = existing
            else:
                contacts_map[item['id']] = request.env['skeen.wacrm.contact'].sudo().create(vals)

        # 2. Conversations
        #    Además del upsert, se REFLEJAN ELIMINACIONES: lo que ya no exista
        #    en Supabase se borra del caché local (antes el caché acumulaba
        #    conversaciones borradas y la bandeja de SKEEN mostraba chats muertos).
        conversations_data = _supabase_request_paginated('conversations', {'select': '*'})
        conversations_map = {}
        for item in conversations_data:
            vals = {
                'external_id': item['id'],
                'contact_id': contacts_map.get(item.get('contact_id'), request.env['skeen.wacrm.contact']).id if contacts_map.get(item.get('contact_id')) else False,
                'status': item.get('status', 'open'),
                'assigned_agent_id': item.get('assigned_agent_id') or None,
                'assigned_agent': str(item.get('assigned_agent_id')) if item.get('assigned_agent_id') else None,
                'last_message_text': item.get('last_message_text'),
                'last_message_at': _parse_datetime(item.get('last_message_at')),
                'unread_count': item.get('unread_count', 0),
                'created_at': _parse_datetime(item.get('created_at')),
                'updated_at': _parse_datetime(item.get('updated_at')),
            }
            existing = request.env['skeen.wacrm.conversation'].sudo().search([('external_id', '=', item['id'])], limit=1)
            if existing:
                existing.write(vals)
                conversations_map[item['id']] = existing
            else:
                conversations_map[item['id']] = request.env['skeen.wacrm.conversation'].sudo().create(vals)

        remote_conv_ids = set(conversations_map.keys())
        stale_convs = request.env['skeen.wacrm.conversation'].sudo().search([
            ('external_id', 'not in', list(remote_conv_ids))]) if remote_conv_ids else \
            request.env['skeen.wacrm.conversation'].sudo().search([])
        if stale_convs:
            stale_convs.unlink()
            conversations_map = {k: v for k, v in conversations_map.items()}

        # 3. Messages (todos los del origen, sin recorte)
        messages_data = _supabase_request_paginated(
            'messages',
            {'select': '*', 'order': 'created_at.desc'},
            page_size=1000
        )
        remote_msg_ids = {item['id'] for item in messages_data}
        stale_msgs = request.env['skeen.wacrm.message'].sudo().search([
            ('external_id', 'not in', list(remote_msg_ids))]) if remote_msg_ids else \
            request.env['skeen.wacrm.message'].sudo().search([])
        stale_msgs.unlink()
        for item in messages_data:
            conversation = conversations_map.get(item.get('conversation_id'))
            if not conversation:
                continue
            vals = {
                'external_id': item['id'],
                'conversation_id': conversation.id,
                'sender_type': {'contact': 'customer', 'user': 'agent'}.get(item.get('sender_type', 'customer'), item.get('sender_type', 'customer')),
                'content_type': item.get('content_type', 'text'),
                'content_text': item.get('content_text') or item.get('content'),
                'media_url': item.get('media_url'),
                'template_name': item.get('template_name'),
                'status': item.get('status', 'sent'),
                'created_at': _parse_datetime(item.get('created_at')),
            }
            existing = request.env['skeen.wacrm.message'].sudo().search([('external_id', '=', item['id'])], limit=1)
            if existing:
                existing.write(vals)
            else:
                request.env['skeen.wacrm.message'].sudo().create(vals)

        # 4. Pipelines & Stages
        pipelines_data = _supabase_request_paginated('pipelines', {'select': '*'})
        pipelines_map = {}
        stages_map = {}
        for item in pipelines_data:
            vals = {
                'external_id': item['id'],
                'name': item.get('name'),
                'created_at': _parse_datetime(item.get('created_at')),
            }
            existing = request.env['skeen.wacrm.pipeline'].sudo().search([('external_id', '=', item['id'])], limit=1)
            if existing:
                existing.write(vals)
                pipelines_map[item['id']] = existing
            else:
                pipelines_map[item['id']] = request.env['skeen.wacrm.pipeline'].sudo().create(vals)

        stages_data = _supabase_request_paginated('pipeline_stages', {'select': '*'})
        for item in stages_data:
            vals = {
                'external_id': item['id'],
                'pipeline_id': pipelines_map.get(item.get('pipeline_id'), request.env['skeen.wacrm.pipeline']).id if pipelines_map.get(item.get('pipeline_id')) else False,
                'name': item.get('name'),
                'position': item.get('position', 0),
                'color': item.get('color', '#3b82f6'),
            }
            existing = request.env['skeen.wacrm.stage'].sudo().search([('external_id', '=', item['id'])], limit=1)
            if existing:
                existing.write(vals)
                stages_map[item['id']] = existing
            else:
                stages_map[item['id']] = request.env['skeen.wacrm.stage'].sudo().create(vals)

        # 5. Deals
        # Mapa profiles.id → user_id (Supabase guarda assigned_to como profiles.id;
        # localmente usamos user_id, consistente con conversations.assigned_agent_id)
        profiles_usermap = {}
        try:
            for p in _supabase_request('GET', 'profiles', params={'select': 'id,user_id'}):
                profiles_usermap[p['id']] = p['user_id']
        except Exception:
            pass
        deals_data = _supabase_request_paginated('deals', {'select': '*'})
        for item in deals_data:
            vals = {
                'external_id': item['id'],
                'title': item.get('title') or 'Sin título',
                'contact_id': contacts_map.get(item.get('contact_id'), request.env['skeen.wacrm.contact']).id if contacts_map.get(item.get('contact_id')) else False,
                'conversation_id': item.get('conversation_id'),
                'pipeline_id': pipelines_map.get(item.get('pipeline_id'), request.env['skeen.wacrm.pipeline']).id if pipelines_map.get(item.get('pipeline_id')) else False,
                'stage_id': stages_map.get(item.get('stage_id'), request.env['skeen.wacrm.stage']).id if stages_map.get(item.get('stage_id')) else False,
                'value': float(item.get('value', 0) or 0),
                'currency': item.get('currency', 'USD'),
                'status': item.get('status', 'open'),
                'expected_close_date': item.get('expected_close_date'),
                'notes': item.get('notes'),
                'assigned_to': profiles_usermap.get(item.get('assigned_to')) if item.get('assigned_to') else None,
                'created_at': _parse_datetime(item.get('created_at')),
                'updated_at': _parse_datetime(item.get('updated_at')),
            }
            existing = request.env['skeen.wacrm.deal'].sudo().search([('external_id', '=', item['id'])], limit=1)
            if existing:
                existing.write(vals)
            else:
                request.env['skeen.wacrm.deal'].sudo().create(vals)

        # 6. Auto-crear deals: contactos con conversación sin deal abierto.
        # Se crean EN SUPABASE (la app WACRM nativa los ve) y se espejan local.
        # Idempotente: un deal abierto por contacto.
        deals_created = 0
        try:
            if conversations_map and pipelines_map and account_id:
                pipeline = sorted(pipelines_map.values(), key=lambda p: p.name or '')[0]
                stage = request.env['skeen.wacrm.stage'].sudo().search(
                    [('pipeline_id', '=', pipeline.id)], order='position asc', limit=1)
                # user_id requerido por Supabase: el primer profile (owner de la cuenta)
                owner = _supabase_request('GET', 'profiles', params={
                    'select': 'user_id', 'order': 'created_at.asc', 'limit': 1})
                owner_id = owner[0]['user_id'] if owner else None
                if stage and owner_id:
                    Deal = request.env['skeen.wacrm.deal'].sudo()
                    # Un deal por contacto: no crear si ya tiene cualquier deal (open o ganado)
                    contacts_with_deals = {str(d.get('contact_id')) for d in deals_data if d.get('contact_id')}
                    for conv in conversations_map.values():
                        contact = conv.contact_id
                        if not contact:
                            continue
                        if contact.external_id in contacts_with_deals:
                            continue
                        if Deal.search([('contact_id', '=', contact.id)], limit=1):
                            continue
                        new_id = str(uuid.uuid4())
                        try:
                            _supabase_request('POST', 'deals', json={
                                'id': new_id,
                                'user_id': owner_id,
                                'account_id': account_id,
                                'pipeline_id': pipeline.external_id,
                                'stage_id': stage.external_id,
                                'contact_id': contact.external_id,
                                'conversation_id': conv.external_id,
                                'title': contact.name or contact.phone or 'Lead WhatsApp',
                                'value': 0,
                                'currency': 'MXN',
                                'status': 'open',
                            }, headers_extra={'Prefer': 'return=minimal'})
                            Deal.create({
                                'external_id': new_id,
                                'title': contact.name or contact.phone or 'Lead WhatsApp',
                                'contact_id': contact.id,
                                'conversation_id': conv.external_id,
                                'pipeline_id': pipeline.id,
                                'stage_id': stage.id,
                                'value': 0,
                                'currency': 'MXN',
                                'status': 'open',
                            })
                            contacts_with_deals.add(contact.external_id)
                            deals_created += 1
                        except Exception as e:
                            _logger.warning('No se pudo auto-crear deal para contacto %s: %s', contact.external_id, e)
        except Exception as e:
            _logger.warning('Auto-deals omitidos: %s', e)

        return {
            'contacts': len(contacts_data),
            'conversations': len(conversations_data),
            'messages': len(messages_data),
            'pipelines': len(pipelines_data),
            'stages': len(stages_data),
            'deals': len(deals_data),
            'deals_created': deals_created,
            'account_id': account_id,
        }

    # ============================================================
    # Mensajes
    # ============================================================
    @http.route('/skeen/frontend/v1/wacrm/messages', type='http', auth='none', methods=['POST', 'OPTIONS'], csrf=False)
    @require_role('lectura')
    @require_perm('whatsapp.responder')
    def send_message(self, **kw):
        try:
            data = _parse_json_body()
            conversation_id = data.get('conversation_id')
            to = data.get('to')
            text = data.get('text')
            assigned_agent_id = data.get('assigned_agent_id')

            if not text:
                return json_response({'status': 'error', 'message': 'Falta texto del mensaje'}, 400)
            if not conversation_id and not to:
                return json_response({'status': 'error', 'message': 'Falta conversation_id o destinatario'}, 400)

            # Resolver teléfono de destino
            phone = to
            conv_external_id = conversation_id
            if conversation_id and not phone:
                conv = request.env['skeen.wacrm.conversation'].sudo().search([('external_id', '=', conversation_id)], limit=1)
                if conv and conv.contact_id:
                    phone = conv.contact_id.phone
                elif conv:
                    phone = conv.contact_phone

            # Normalizar a E.164
            if phone and not phone.startswith('+'):
                digits = re.sub(r'\D', '', phone)
                phone = '+' + digits.lstrip('0') if digits else ''

            if not phone:
                return json_response({'status': 'error', 'message': 'No se pudo resolver el teléfono destino'}, 400)

            # Enviar mensaje vía bridge de Hermes (tiene la API key real de WACRM)
            result = _hermes_bridge_request('/send-message', {
                'conversation_id': conv_external_id,
                'text': text,
                'assigned_agent_id': assigned_agent_id,
            })

            return json_response({'status': 'success', 'message': 'Mensaje enviado', 'result': result})
        except Exception as e:
            _logger.exception('Error enviando mensaje WACRM')
            return json_response({'status': 'error', 'message': str(e)}, 500)

    @http.route('/skeen/frontend/v1/wacrm/messages', type='http', auth='none', methods=['GET', 'OPTIONS'], csrf=False)
    def list_messages(self, **kw):
        try:
            domain = []
            if kw.get('conversation_id'):
                conv = request.env['skeen.wacrm.conversation'].sudo().search([('external_id', '=', kw.get('conversation_id'))], limit=1)
                if conv:
                    domain.append(('conversation_id', '=', conv.id))
            if kw.get('contact_id'):
                contact = request.env['skeen.wacrm.contact'].sudo().search([('external_id', '=', kw.get('contact_id'))], limit=1)
                if contact:
                    domain.append(('contact_id', '=', contact.id))
            if kw.get('search'):
                search = kw.get('search')
                domain += ['|', ('content_text', 'ilike', search), ('contact_name', 'ilike', search)]

            messages = request.env['skeen.wacrm.message'].sudo().search(domain, order='created_at desc', limit=200)
            return json_response({
                'status': 'success',
                'messages': [self._message_to_dict(m) for m in messages],
            })
        except Exception as e:
            _logger.exception('Error listando mensajes WACRM')
            return json_response({'status': 'error', 'message': str(e)}, 500)

    def _supabase_message_to_dict(self, m):
        """Mensaje de Supabase en el formato que consume el frontend."""
        return {
            'id': m.get('id'),
            'external_id': m.get('id'),
            'conversation_id': m.get('conversation_id'),
            'sender_type': {'contact': 'customer', 'user': 'agent'}.get(m.get('sender_type', 'customer'), m.get('sender_type', 'customer')),
            'content_type': m.get('content_type', 'text'),
            'content_text': m.get('content_text') or m.get('content') or '',
            'media_url': m.get('media_url') or '',
            'template_name': m.get('template_name') or '',
            'status': m.get('status', 'sent'),
            'created_at': (m.get('created_at') or '')[:19].replace('T', ' '),
        }

    @http.route('/skeen/frontend/v1/wacrm/conversations/<string:external_id>/messages', type='http', auth='none', methods=['GET', 'OPTIONS'], csrf=False)
    def list_conversation_messages_origin(self, external_id, **kw):
        """Historial COMPLETO de una conversación, leído directo del origen
        (Supabase del WACRM), paginado. Devuelve los mensajes en orden
        ascendente dentro de la página; `has_more` indica si hay página previa
        (mensajes más antiguos)."""
        try:
            page = max(int(kw.get('page', 1) or 1), 1)
            page_size = min(max(int(kw.get('page_size', 50) or 50), 1), 200)
            data = _supabase_request('GET', 'messages', params={
                'select': '*',
                'conversation_id': f'eq.{external_id}',
                'order': 'created_at.desc',
                'limit': page_size,
                'offset': (page - 1) * page_size,
            })
            msgs = [self._supabase_message_to_dict(m) for m in data]
            msgs.reverse()  # ascendente dentro de la página
            return json_response({
                'status': 'success',
                'messages': msgs,
                'page': page,
                'page_size': page_size,
                'has_more': len(data) == page_size,
            })
        except Exception as e:
            _logger.exception('Error listando mensajes del origen WACRM')
            return json_response({'status': 'error', 'message': str(e)}, 500)

    @http.route('/skeen/frontend/v1/wacrm/conversations', type='http', auth='none', methods=['GET', 'OPTIONS'], csrf=False)
    def list_conversations(self, **kw):
        try:
            domain = []
            if kw.get('search'):
                search = kw.get('search')
                domain += ['|', ('contact_name', 'ilike', search), ('contact_phone', 'ilike', search)]
            conversations = request.env['skeen.wacrm.conversation'].sudo().search(domain, order='last_message_at desc', limit=200)
            return json_response({
                'status': 'success',
                'conversations': [self._conversation_to_dict(c) for c in conversations],
            })
        except Exception as e:
            _logger.exception('Error listando conversaciones WACRM')
            return json_response({'status': 'error', 'message': str(e)}, 500)

    @http.route('/skeen/frontend/v1/wacrm/members', type='http', auth='none', methods=['GET', 'OPTIONS'], csrf=False)
    def list_members(self, **kw):
        try:
            rows = _supabase_request(
                'GET',
                'profiles',
                params={'select': 'user_id,full_name,email,avatar_url,account_role,created_at', 'order': 'created_at.asc'}
            )
            members = [{
                'id': r.get('user_id'),
                'profile_id': r.get('id'),
                'name': r.get('full_name') or r.get('email') or r.get('user_id'),
                'email': r.get('email'),
                'avatar_url': r.get('avatar_url'),
                'role': r.get('account_role') or 'user',
            } for r in rows]
            return json_response({'status': 'success', 'members': members})
        except Exception as e:
            _logger.exception('Error listando miembros WACRM')
            return json_response({'status': 'error', 'message': str(e)}, 500)

    @http.route('/skeen/frontend/v1/wacrm/conversations/<string:external_id>/assign', type='http', auth='none', methods=['POST', 'OPTIONS'], csrf=False)
    @require_role('lectura')
    @require_perm('whatsapp.asignar')
    def assign_conversation(self, external_id, **kw):
        try:
            data = _parse_json_body()
            assigned_agent_id = data.get('assigned_agent_id')

            # Actualizar directamente en Supabase
            update = {'assigned_agent_id': assigned_agent_id, 'updated_at': datetime.utcnow().isoformat() + 'Z'}
            _supabase_request(
                'PATCH',
                'conversations',
                params={'id': f'eq.{external_id}'},
                json=update,
                headers_extra={'Prefer': 'return=minimal'}
            )

            # Actualizar cache local en Odoo
            conv = request.env['skeen.wacrm.conversation'].sudo().search([('external_id', '=', external_id)], limit=1)
            if conv:
                conv.write({
                    'assigned_agent_id': assigned_agent_id or None,
                    'assigned_agent': str(assigned_agent_id) if assigned_agent_id else None,
                })

            return json_response({'status': 'success', 'assigned_agent_id': assigned_agent_id})
        except Exception as e:
            _logger.exception('Error asignando conversación WACRM')
            return json_response({'status': 'error', 'message': str(e)}, 500)

    @http.route('/skeen/frontend/v1/wacrm/conversations/<string:external_id>/assigned', type='http', auth='none', methods=['GET', 'OPTIONS'], csrf=False)
    def is_conversation_assigned(self, external_id, **kw):
        try:
            conv = request.env['skeen.wacrm.conversation'].sudo().search([('external_id', '=', external_id)], limit=1)
            if not conv:
                return json_response({'status': 'success', 'assigned': False})
            return json_response({
                'status': 'success',
                'assigned': bool(conv.assigned_agent_id),
                'assigned_agent_id': conv.assigned_agent_id or None,
                'assigned_agent_name': conv.assigned_agent or None,
            })
        except Exception as e:
            _logger.exception('Error consultando asignación WACRM')
            return json_response({'status': 'error', 'message': str(e)}, 500)

    # ============================================================
    # Leads / Deals
    # ============================================================
    @http.route('/skeen/frontend/v1/wacrm/pipelines', type='http', auth='none', methods=['GET', 'OPTIONS'], csrf=False)
    def list_pipelines(self, **kw):
        try:
            pipelines = request.env['skeen.wacrm.pipeline'].sudo().search([], order='name asc')
            return json_response({
                'status': 'success',
                'pipelines': [{
                    'id': p.id,
                    'external_id': p.external_id,
                    'name': p.name,
                    'stages': [{
                        'id': s.id,
                        'external_id': s.external_id,
                        'name': s.name,
                        'position': s.position,
                        'color': s.color or '#3b82f6',
                    } for s in request.env['skeen.wacrm.stage'].sudo().search([('pipeline_id', '=', p.id)], order='position asc')]
                } for p in pipelines],
            })
        except Exception as e:
            _logger.exception('Error listando pipelines WACRM')
            return json_response({'status': 'error', 'message': str(e)}, 500)

    @http.route('/skeen/frontend/v1/wacrm/leads', type='http', auth='none', methods=['GET', 'OPTIONS'], csrf=False)
    def list_leads(self, **kw):
        try:
            domain = []
            if kw.get('status'):
                domain.append(('status', '=', kw.get('status')))
            if kw.get('pipeline_id'):
                pipe = request.env['skeen.wacrm.pipeline'].sudo().search([('external_id', '=', kw.get('pipeline_id'))], limit=1)
                if pipe:
                    domain.append(('pipeline_id', '=', pipe.id))
            if kw.get('search'):
                search = kw.get('search')
                domain += ['|', ('title', 'ilike', search), ('contact_name', 'ilike', search)]

            deals = request.env['skeen.wacrm.deal'].sudo().search(domain, order='created_at desc', limit=200)
            return json_response({
                'status': 'success',
                'leads': [self._deal_to_dict(d) for d in deals],
            })
        except Exception as e:
            _logger.exception('Error listando leads WACRM')
            return json_response({'status': 'error', 'message': str(e)}, 500)

    @http.route('/skeen/frontend/v1/wacrm/leads/<int:lead_id>/status', type='http', auth='none', methods=['PUT'], csrf=False)
    @require_role('lectura')
    @require_perm('whatsapp.asignar')
    def update_lead_status(self, lead_id, **kw):
        try:
            deal = request.env['skeen.wacrm.deal'].sudo().browse(lead_id)
            if not deal.exists():
                return json_response({'status': 'error', 'message': 'Lead no encontrado'}, 404)
            data = _parse_json_body()
            update_remote = {}
            if data.get('status') in ('open', 'won', 'lost'):
                deal.write({'status': data.get('status')})
                update_remote['status'] = data.get('status')
            if data.get('stage_id'):
                stage = request.env['skeen.wacrm.stage'].sudo().search([('external_id', '=', data.get('stage_id'))], limit=1)
                if stage:
                    deal.write({'stage_id': stage.id})
                    update_remote['stage_id'] = stage.external_id
            if 'assigned_to' in data:
                # La UI manda user_id; el FK remoto deals.assigned_to apunta a profiles.id
                assigned = data.get('assigned_to') or None
                deal.write({'assigned_to': assigned})
                if assigned:
                    prof = _supabase_request('GET', 'profiles', params={
                        'select': 'id', 'user_id': f'eq.{assigned}', 'limit': 1})
                    update_remote['assigned_to'] = prof[0]['id'] if prof else None
                else:
                    update_remote['assigned_to'] = None
            if update_remote:
                # Reflejar en Supabase para que el próximo sync no lo revierta
                update_remote['updated_at'] = datetime.utcnow().isoformat() + 'Z'
                _supabase_request(
                    'PATCH', 'deals',
                    params={'id': f'eq.{deal.external_id}'},
                    json=update_remote,
                    headers_extra={'Prefer': 'return=minimal'})
            return json_response({'status': 'success', 'lead': self._deal_to_dict(deal)})
        except Exception as e:
            return json_response({'status': 'error', 'message': str(e)}, 500)

    @http.route('/skeen/frontend/v1/wacrm/leads/<int:lead_id>/convert', type='http', auth='none', methods=['POST', 'OPTIONS'], csrf=False)
    @require_role('lectura')
    @require_perm('whatsapp.asignar')
    def convert_lead(self, lead_id, **kw):
        """Convierte el lead en paciente SKEEN (crea o liga por teléfono) y lo marca ganado"""
        try:
            deal = request.env['skeen.wacrm.deal'].sudo().browse(lead_id)
            if not deal.exists():
                return json_response({'status': 'error', 'message': 'Lead no encontrado'}, 404)
            # Idempotente: ya convertido
            if deal.partner_id:
                return json_response({
                    'status': 'success',
                    'lead': self._deal_to_dict(deal),
                    'patient_id': deal.partner_id.id,
                    'created': False,
                })
            contact = deal.contact_id
            if not contact:
                return json_response({'status': 'error', 'message': 'El lead no tiene contacto'}, 400)
            # Normalizar teléfono (52 + 10 dígitos, como el padrón de pacientes)
            digits = re.sub(r'\D', '', contact.phone or '')
            if len(digits) == 10:
                phone = '52' + digits
            else:
                phone = digits
            if not phone:
                return json_response({'status': 'error', 'message': 'El contacto no tiene teléfono'}, 400)
            Partner = request.env['res.partner'].sudo()
            partner = Partner.search([('is_patient', '=', True), '|', ('phone', '=', phone), ('mobile', '=', phone)], limit=1)
            created = False
            if not partner:
                partner = Partner.create({
                    'name': contact.name or phone,
                    'phone': phone,
                    'is_patient': True,
                    'source': 'whatsapp',
                })
                created = True
            deal.write({'partner_id': partner.id, 'status': 'won'})
            _supabase_request(
                'PATCH', 'deals',
                params={'id': f'eq.{deal.external_id}'},
                json={'status': 'won', 'updated_at': datetime.utcnow().isoformat() + 'Z'},
                headers_extra={'Prefer': 'return=minimal'})
            return json_response({
                'status': 'success',
                'lead': self._deal_to_dict(deal),
                'patient_id': partner.id,
                'created': created,
            })
        except Exception as e:
            return json_response({'status': 'error', 'message': str(e)}, 500)

    def _message_to_dict(self, m):
        return {
            'id': m.id,
            'external_id': m.external_id,
            'conversation_id': m.conversation_id.external_id if m.conversation_id else None,
            'contact_name': m.contact_id.name if m.contact_id else '',
            'contact_phone': m.contact_id.phone if m.contact_id else '',
            'sender_type': m.sender_type,
            'content_type': m.content_type,
            'content_text': m.content_text or '',
            'media_url': m.media_url or '',
            'template_name': m.template_name or '',
            'status': m.status,
            'created_at': m.created_at.strftime('%Y-%m-%d %H:%M:%S') if m.created_at else None,
        }

    def _conversation_to_dict(self, c):
        return {
            'id': c.id,
            'external_id': c.external_id,
            'contact_id': c.contact_id.external_id if c.contact_id else None,
            'contact_name': c.contact_name,
            'contact_phone': c.contact_phone,
            'status': c.status,
            'assigned_agent': c.assigned_agent or '',
            'assigned_agent_id': c.assigned_agent_id or '',
            'last_message_text': c.last_message_text or '',
            'last_message_at': c.last_message_at.strftime('%Y-%m-%d %H:%M:%S') if c.last_message_at else None,
            'unread_count': c.unread_count,
            'created_at': c.created_at.strftime('%Y-%m-%d %H:%M:%S') if c.created_at else None,
            'tags': self._tags_de(c.external_id),
        }

    # ============================================================
    # Notas internas y etiquetas (viven en Odoo, sobreviven al sync)
    # ============================================================
    def _tags_de(self, external_id):
        rows = request.env['skeen.wacrm.conversation.tag'].sudo().search([
            ('conversation_external_id', '=', external_id)])
        return [{'id': r.tag_id.id, 'name': r.tag_id.name, 'color': r.tag_id.color}
                for r in rows if r.tag_id.active]

    def _note_to_dict(self, n):
        return {
            'id': n.id,
            'body': n.body,
            'author': n.author_name or n.author_login or '',
            'date': n.create_date.strftime('%Y-%m-%d %H:%M') if n.create_date else None,
            'resolved': n.resolved,
            'resolved_at': n.resolved_at.strftime('%Y-%m-%d %H:%M') if n.resolved_at else None,
            'resolved_by': n.resolved_by or '',
        }

    def _tag_to_dict(self, t):
        return {'id': t.id, 'name': t.name, 'color': t.color, 'sequence': t.sequence,
                'active': t.active}

    # ---- Notas internas ----
    @http.route('/skeen/frontend/v1/wacrm/conversations/<string:external_id>/notes', type='http', auth='none', methods=['GET', 'OPTIONS'], csrf=False)
    @require_role('lectura')
    def list_notes(self, external_id, **kw):
        """Notas internas de la conversación. Nunca se envían al paciente."""
        try:
            notes = request.env['skeen.wacrm.note'].sudo().search([
                ('conversation_external_id', '=', external_id)])
            return json_response({
                'status': 'success',
                'notes': [self._note_to_dict(n) for n in notes],
                'pendientes': notes.filtered(lambda n: not n.resolved).__len__(),
            })
        except Exception as e:
            return json_response({'status': 'error', 'message': str(e)}, 500)

    @http.route('/skeen/frontend/v1/wacrm/conversations/<string:external_id>/notes', type='http', auth='none', methods=['POST', 'OPTIONS'], csrf=False)
    @require_role('recepcion')
    @require_perm('whatsapp.responder')
    def create_note(self, external_id, **kw):
        try:
            data = _parse_json_body()
            body = (data.get('body') or '').strip()
            if not body:
                return json_response({'status': 'error', 'message': 'La nota no puede estar vacía'}, 400)
            me = getattr(request, 'frontend_user', None)
            conv = request.env['skeen.wacrm.conversation'].sudo().search(
                [('external_id', '=', external_id)], limit=1)
            note = request.env['skeen.wacrm.note'].sudo().create({
                'conversation_external_id': external_id,
                'contact_name': conv.contact_name if conv else '',
                'body': body,
                'author_name': getattr(me, 'name', '') or '',
                'author_login': getattr(me, 'login', '') or '',
            })
            return json_response({'status': 'success', 'note': self._note_to_dict(note)}, 201)
        except Exception as e:
            return json_response({'status': 'error', 'message': str(e)}, 500)

    @http.route('/skeen/frontend/v1/wacrm/notes/<int:note_id>', type='http', auth='none', methods=['PUT', 'OPTIONS'], csrf=False)
    @require_role('recepcion')
    @require_perm('whatsapp.responder')
    def update_note(self, note_id, **kw):
        """Marca/desmarca una nota como atendida, o edita su texto."""
        try:
            note = request.env['skeen.wacrm.note'].sudo().browse(note_id)
            if not note.exists():
                return json_response({'status': 'error', 'message': 'Nota no encontrada'}, 404)
            data = _parse_json_body()
            vals = {}
            if 'body' in data:
                body = (data.get('body') or '').strip()
                if not body:
                    return json_response({'status': 'error', 'message': 'La nota no puede estar vacía'}, 400)
                vals['body'] = body
            if 'resolved' in data:
                me = getattr(request, 'frontend_user', None)
                resolved = bool(data.get('resolved'))
                vals['resolved'] = resolved
                vals['resolved_at'] = fields.Datetime.now() if resolved else False
                vals['resolved_by'] = (getattr(me, 'name', '') or getattr(me, 'login', '')) if resolved else ''
            if vals:
                note.write(vals)
            return json_response({'status': 'success', 'note': self._note_to_dict(note)})
        except Exception as e:
            return json_response({'status': 'error', 'message': str(e)}, 500)

    @http.route('/skeen/frontend/v1/wacrm/notes/<int:note_id>', type='http', auth='none', methods=['DELETE'], csrf=False)
    @require_role('recepcion')
    @require_perm('whatsapp.responder')
    def delete_note(self, note_id, **kw):
        try:
            note = request.env['skeen.wacrm.note'].sudo().browse(note_id)
            if not note.exists():
                return json_response({'status': 'error', 'message': 'Nota no encontrada'}, 404)
            note.unlink()
            return json_response({'status': 'success', 'message': 'Nota eliminada'})
        except Exception as e:
            return json_response({'status': 'error', 'message': str(e)}, 500)

    # ---- Etiquetas ----
    @http.route('/skeen/frontend/v1/wacrm/tags', type='http', auth='none', methods=['GET', 'OPTIONS'], csrf=False)
    @require_role('lectura')
    def list_tags(self, **kw):
        try:
            tags = request.env['skeen.wacrm.tag'].sudo().search([('active', '=', True)])
            return json_response({'status': 'success', 'tags': [self._tag_to_dict(t) for t in tags]})
        except Exception as e:
            return json_response({'status': 'error', 'message': str(e)}, 500)

    @http.route('/skeen/frontend/v1/wacrm/tags', type='http', auth='none', methods=['POST', 'OPTIONS'], csrf=False)
    @require_role('recepcion')
    @require_perm('whatsapp.responder')
    def create_tag(self, **kw):
        try:
            data = _parse_json_body()
            name = (data.get('name') or '').strip()
            if not name:
                return json_response({'status': 'error', 'message': 'El nombre es obligatorio'}, 400)
            # active_test=False: una etiqueta desactivada debe poder reactivarse
            Tag = request.env['skeen.wacrm.tag'].sudo().with_context(active_test=False)
            existente = Tag.search([('name', '=ilike', name)], limit=1)
            if existente and existente.active:
                return json_response({'status': 'error', 'message': 'Ya existe una etiqueta con ese nombre'}, 409)
            if existente:
                # Estaba desactivada: se reactiva en vez de fallar por el nombre
                existente.write({
                    'active': True,
                    'color': data.get('color') or existente.color or '#605ca8',
                    'sequence': int(data.get('sequence') or existente.sequence or 10),
                })
                return json_response({'status': 'success', 'tag': self._tag_to_dict(existente)})
            tag = Tag.create({
                'name': name,
                'color': data.get('color') or '#605ca8',
                'sequence': int(data.get('sequence') or 10),
            })
            return json_response({'status': 'success', 'tag': self._tag_to_dict(tag)}, 201)
        except Exception as e:
            return json_response({'status': 'error', 'message': str(e)}, 500)

    @http.route('/skeen/frontend/v1/wacrm/tags/<int:tag_id>', type='http', auth='none', methods=['PUT', 'OPTIONS'], csrf=False)
    @require_role('recepcion')
    @require_perm('whatsapp.responder')
    def update_tag(self, tag_id, **kw):
        try:
            tag = request.env['skeen.wacrm.tag'].sudo().browse(tag_id)
            if not tag.exists():
                return json_response({'status': 'error', 'message': 'Etiqueta no encontrada'}, 404)
            data = _parse_json_body()
            vals = {}
            if 'name' in data:
                name = (data.get('name') or '').strip()
                if not name:
                    return json_response({'status': 'error', 'message': 'El nombre es obligatorio'}, 400)
                dup = request.env['skeen.wacrm.tag'].sudo().with_context(active_test=False).search(
                    [('name', '=ilike', name), ('id', '!=', tag_id), ('active', '=', True)], limit=1)
                if dup:
                    return json_response({'status': 'error', 'message': 'Ya existe una etiqueta con ese nombre'}, 409)
                vals['name'] = name
            if 'color' in data:
                vals['color'] = data.get('color') or '#605ca8'
            if 'sequence' in data:
                vals['sequence'] = int(data.get('sequence') or 10)
            if 'active' in data:
                vals['active'] = bool(data.get('active'))
            if vals:
                tag.write(vals)
            return json_response({'status': 'success', 'tag': self._tag_to_dict(tag)})
        except Exception as e:
            return json_response({'status': 'error', 'message': str(e)}, 500)

    @http.route('/skeen/frontend/v1/wacrm/tags/<int:tag_id>', type='http', auth='none', methods=['DELETE'], csrf=False)
    @require_role('recepcion')
    @require_perm('whatsapp.responder')
    def delete_tag(self, tag_id, **kw):
        """Desactiva la etiqueta (conserva el histórico de asignaciones)."""
        try:
            tag = request.env['skeen.wacrm.tag'].sudo().browse(tag_id)
            if not tag.exists():
                return json_response({'status': 'error', 'message': 'Etiqueta no encontrada'}, 404)
            tag.write({'active': False})
            return json_response({'status': 'success', 'message': 'Etiqueta desactivada'})
        except Exception as e:
            return json_response({'status': 'error', 'message': str(e)}, 500)

    @http.route('/skeen/frontend/v1/wacrm/conversations/<string:external_id>/tags', type='http', auth='none', methods=['POST', 'OPTIONS'], csrf=False)
    @require_role('recepcion')
    def assign_tag(self, external_id, **kw):
        """Asigna o quita una etiqueta de la conversación.

        Body: {"tag_id": 3, "action": "add" | "remove"} (action por defecto add).
        """
        try:
            data = _parse_json_body()
            tag_id = int(data.get('tag_id') or 0)
            tag = request.env['skeen.wacrm.tag'].sudo().browse(tag_id)
            if not tag.exists():
                return json_response({'status': 'error', 'message': 'Etiqueta no encontrada'}, 404)
            Rel = request.env['skeen.wacrm.conversation.tag'].sudo()
            action = (data.get('action') or 'add').lower()
            if action == 'remove':
                Rel.search([('conversation_external_id', '=', external_id),
                            ('tag_id', '=', tag_id)]).unlink()
            else:
                if not Rel.search([('conversation_external_id', '=', external_id),
                                   ('tag_id', '=', tag_id)], limit=1):
                    me = getattr(request, 'frontend_user', None)
                    Rel.create({
                        'conversation_external_id': external_id,
                        'tag_id': tag_id,
                        'assigned_by': getattr(me, 'login', '') or '',
                    })
            return json_response({'status': 'success', 'tags': self._tags_de(external_id)})
        except Exception as e:
            return json_response({'status': 'error', 'message': str(e)}, 500)

    # ============================================================
    # Métricas para gerencia
    # ============================================================
    @http.route('/skeen/frontend/v1/wacrm/metrics', type='http', auth='none', methods=['GET', 'OPTIONS'], csrf=False)
    @require_role('lectura')
    def wacrm_metrics(self, **kw):
        """Tablero de atención de WhatsApp para gerencia.

        Criterios (documentados también en la respuesta):
        - "primera respuesta": minutos entre el PRIMER mensaje entrante del
          cliente y el PRIMER mensaje saliente posterior en la misma
          conversación. En WACRM el bot se registra como sender_type='agent',
          así que cuenta como respuesta del equipo.
        - "sin responder": conversaciones cuyo ÚLTIMO mensaje es del cliente y
          lleva más de N horas (parámetro `sin_respuesta_horas`, 4 por defecto).
        - "leads ganados/perdidos del mes": deals con status won/lost y
          updated_at dentro del mes en curso.
        """
        try:
            # Sólo admin/gerencia: el rango de roles no distingue gerencia de
            # medico (ambos 50), así que se comprueba el rol explícitamente.
            if request.frontend_user.role not in ('admin', 'gerencia'):
                return json_response({'status': 'error', 'message': 'Sólo gerencia puede ver las métricas'}, 403)
            from statistics import median
            hoy = datetime.utcnow()
            horas = float(kw.get('sin_respuesta_horas') or 4)

            convs = _supabase_request_paginated('conversations', {'select': '*'})
            msgs = _supabase_request_paginated(
                'messages', {'select': 'conversation_id,sender_type,created_at', 'order': 'created_at.asc'})

            def en_rango(dt, ini, fin=None):
                return dt is not None and dt >= ini and (fin is None or dt <= fin)

            ini_hoy = hoy.replace(hour=0, minute=0, second=0, microsecond=0)
            ini_semana = ini_hoy - timedelta(days=ini_hoy.weekday())
            ini_mes = ini_hoy.replace(day=1)

            creadas_hoy = creadas_semana = creadas_mes = 0
            for c in convs:
                dt = _parse_datetime(c.get('created_at'))
                if not dt:
                    continue
                if dt >= ini_hoy:
                    creadas_hoy += 1
                if dt >= ini_semana:
                    creadas_semana += 1
                if dt >= ini_mes:
                    creadas_mes += 1

            entrantes_hoy = salientes_hoy = 0
            entrantes_semana = salientes_semana = 0
            entrantes_mes = salientes_mes = 0
            for m in msgs:
                dt = _parse_datetime(m.get('created_at'))
                if not dt:
                    continue
                es_in = m.get('sender_type') == 'customer'
                if dt >= ini_hoy:
                    entrantes_hoy += 1 if es_in else 0
                    salientes_hoy += 0 if es_in else 1
                if dt >= ini_semana:
                    entrantes_semana += 1 if es_in else 0
                    salientes_semana += 0 if es_in else 1
                if dt >= ini_mes:
                    entrantes_mes += 1 if es_in else 0
                    salientes_mes += 0 if es_in else 1

            # Primera respuesta por conversación
            por_conv = {}
            for m in msgs:
                dt = _parse_datetime(m.get('created_at'))
                if not dt:
                    continue
                por_conv.setdefault(m.get('conversation_id'), []).append((dt, m.get('sender_type')))

            tiempos = []
            for cid, lista in por_conv.items():
                lista.sort(key=lambda x: x[0])
                primera_in = next((dt for dt, st in lista if st == 'customer'), None)
                if not primera_in:
                    continue
                respuesta = next((dt for dt, st in lista if st != 'customer' and dt >= primera_in), None)
                if respuesta:
                    tiempos.append((respuesta - primera_in).total_seconds() / 60.0)

            sin_responder = 0
            detalle_sin_responder = []
            for c in convs:
                lista = por_conv.get(c.get('id'))
                if not lista:
                    continue
                ultimo_dt, ultimo_st = max(lista, key=lambda x: x[0])
                if ultimo_st != 'customer':
                    continue
                horas_esperando = (hoy - ultimo_dt).total_seconds() / 3600.0
                if horas_esperando >= horas:
                    sin_responder += 1
                    detalle_sin_responder.append({
                        'conversation_id': c.get('id'),
                        'horas': round(horas_esperando, 1),
                        'ultimo_mensaje': (c.get('last_message_text') or '')[:120],
                    })
            detalle_sin_responder.sort(key=lambda d: -d['horas'])

            # Leads del mes
            deals = _supabase_request_paginated('deals', {'select': 'id,status,created_at,updated_at,title,value'})
            ganados = perdidos = abiertos = 0
            valor_ganado = 0.0
            for d in deals:
                dt = _parse_datetime(d.get('updated_at')) or _parse_datetime(d.get('created_at'))
                if not dt or dt < ini_mes:
                    continue
                st = d.get('status')
                if st == 'won':
                    ganados += 1
                    valor_ganado += float(d.get('value') or 0)
                elif st == 'lost':
                    perdidos += 1
                elif st == 'open':
                    abiertos += 1

            return json_response({
                'status': 'success',
                'generado': hoy.strftime('%Y-%m-%d %H:%M'),
                'periodo': {'desde': ini_mes.strftime('%Y-%m-%d'), 'hasta': hoy.strftime('%Y-%m-%d')},
                'sin_respuesta_horas': horas,
                'conversaciones': {
                    'hoy': creadas_hoy,
                    'semana': creadas_semana,
                    'mes': creadas_mes,
                    'total': len(convs),
                },
                'mensajes': {
                    'hoy': {'entrantes': entrantes_hoy, 'salientes': salientes_hoy},
                    'semana': {'entrantes': entrantes_semana, 'salientes': salientes_semana},
                    'mes': {'entrantes': entrantes_mes, 'salientes': salientes_mes},
                },
                'primera_respuesta': {
                    'muestras': len(tiempos),
                    'promedio_min': round(sum(tiempos) / len(tiempos), 1) if tiempos else None,
                    'mediana_min': round(median(tiempos), 1) if tiempos else None,
                },
                'sin_responder': {
                    'total': sin_responder,
                    'horas_minimas': horas,
                    'detalle': detalle_sin_responder[:20],
                },
                'leads': {
                    'ganados': ganados,
                    'perdidos': perdidos,
                    'abiertos': abiertos,
                    'valor_ganado': round(valor_ganado, 2),
                },
                'criterios': {
                    'primera_respuesta': 'Minutos entre el primer mensaje entrante del cliente y el primer mensaje saliente posterior en la misma conversación. En WACRM el bot se registra como "agent", así que cuenta como respuesta del equipo.',
                    'sin_responder': f'Conversaciones cuyo último mensaje es del cliente y lleva más de {horas:g} h sin respuesta.',
                    'leads': 'Deals con status won/lost y updated_at dentro del mes en curso.',
                },
            })
        except Exception as e:
            _logger.exception('Error calculando métricas WACRM')
            return json_response({'status': 'error', 'message': str(e)}, 500)

    def _deal_to_dict(self, d):
        return {
            'id': d.id,
            'external_id': d.external_id,
            'title': d.title,
            'contact_id': d.contact_id.external_id if d.contact_id else None,
            'contact_name': d.contact_name,
            'contact_phone': d.contact_phone,
            'pipeline': d.pipeline_id.name if d.pipeline_id else '',
            'pipeline_id': d.pipeline_id.id if d.pipeline_id else None,
            'stage': d.stage_id.name if d.stage_id else '',
            'stage_id': d.stage_id.id if d.stage_id else None,
            'stage_color': d.stage_id.color if d.stage_id else '#3b82f6',
            'value': d.value,
            'currency': d.currency,
            'status': d.status,
            'expected_close_date': d.expected_close_date.strftime('%Y-%m-%d') if d.expected_close_date else None,
            'notes': d.notes or '',
            'assigned_to': d.assigned_to or '',
            'partner_id': d.partner_id.id if d.partner_id else None,
            'conversation_id': d.conversation_id or '',
            'created_at': d.created_at.strftime('%Y-%m-%d %H:%M:%S') if d.created_at else None,
        }