vm2_staging_105_redeploy

<?php
/**
 * Plugin Name: VivaMais CRM V2
 * Plugin URI: https://vivamaiseventos.com
 * Description: CRM V2 — Modular e limpo. Roda em paralelo com V1 sem conflito.
 * Version:           1.5.105
 * Author: VivaMais
 * Text Domain: vivamais-crm-v2
 */

if ( ! defined( 'ABSPATH' ) ) exit;

define('VM2_VERSION', '1.5.104');

// [v1.5.87] ONE-TIME IMPORT: executa server-side ao visitar /?vm2_import_run=vm2import87
add_action('template_redirect', function() {
    if (empty($_GET['vm2_import_run']) || $_GET['vm2_import_run'] !== 'vm2import87') return;
    global $wpdb;
    $table = $wpdb->prefix . 'vm2_contacts';
    $pending = [
        ['11984038530','SamantaFreitas'],['17997057153','Josiane'],['11966727395','Pri'],
        ['11982344830','Simone'],['11966713340','Margareth'],['17991805363','Tamy'],
        ['11948627616','Cida'],['11946794823','C.L'],['17997464086','Dalva Meire'],
        ['17992683182','meire'],['11976185486','Kissya'],['13981850802','Suh'],
        ['12982632940','Fernanda Mayara'],['13981035797','Mayara'],['17981090965','R'],
        ['19987100755','Lu Carmo'],['11913367714','100'],['11973912379','Vanessa Almeida'],
        ['11948523705','Caroline Alvares'],['12981476645','Gabriela Francine'],
        ['11983702783','Fee'],['11963362430','Tania Malouki'],['11998966598','Malu'],
        ['13998067124','thalita'],['11993677226','Isa Sabino'],['11941779084','Lidy'],
        ['13988822519','Elaine Pereira'],['11939178626','MIRANDA RAFFAELLY'],
        ['21983444915','Derek Silva'],['11983127574','Monica Pedro'],['6692479960','Tio Teko'],
        ['11987293712',''],['16991836780','Du'],['16997652100','Renata'],
        ['11982295206','Victorino Sauria'],['19999458504','Sophie Carlini'],
        ['19996582009','Bruna Michelle Gaspar'],['18997980097','Bruna'],
        ['14996506911','Vivian Carvalho'],['16988091977','faby'],['15997995405','Gisele Vieira'],
        ['13996489755','Carol Campos'],['15996576366','Fabi Lourenco'],
        ['11939121900','Jessica Mercado Livre'],['11984629893','Cah Martins PROD'],
        ['4599547407','Ana Cassol'],['11973500468','Amanda Munhoz'],['11963187839','Auda Alves'],
        ['16988029488','Debora'],['19997167672','Beatriz Gomes'],['19989134708','Dani Berti'],
        ['13978040730','Patricia'],['14996232449','Anderson'],['11981269660','Juhh'],
        ['19983696684','Daia'],['11973595399','Karina'],['17997614160',''],['11911674261',''],
        ['11991342081','Gabi Oliveira'],['12982280190','Marina'],['11982221679','Josy'],
        ['14997810311','Karina lopes'],['12988493938','milene ribeir'],['19992453495','Roselaine'],
        ['16988100008','Helia'],['11981483846','Carmem'],['11930434138','Bianca Cre'],
        ['19992999066','anajuh'],['11966805608','MIRELA'],['11912084604','Kris Sanches'],
        ['11997144415','Roberta'],['11946854178','Tan'],['11964094339','Jane Confeitaria'],
        ['17981722757','Jessica Melo'],['11981365015','IR'],['11996978987','Isabella Antonini'],
        ['11941472016','Rose'],['11951768511','Ana Camara'],['11985206660','Larissa Spinoso'],
        ['11986941603','Patricia Pires'],['11967490738','Priscila'],['13997323167','Silvia Mara'],
        ['11941082571','Deus acima de tudo'],['19993454599','KTudes'],['17997822708','Day'],
        ['12981015344','Fran'],['24998370399','Viva A Vida'],['11971561499','Patricia'],
        ['16988086085','Josy'],['19981712655','Priscila Dagues'],['11974143863','Jaque'],
        ['19989092543','Claudia'],['19991590376','Regiane'],['16988078510','Rita'],
        ['16994574845','Yara Messias'],['19994284962','Malothur Decoracoes'],
        ['16997820122','Tati'],['16992026336','Mari Salvador'],['11947649396','Lucelia'],
        ['16991157223','Santos Elisane'],['11991886216','Naiara'],['11993007252','Lidiane Freitas'],
        ['12974115068','dra Valquiria'],['19982368752','Kei Kanayama'],['11952804216','Raissa'],
        ['3188703861','FMCA'],['16993172958','Thamires Queiroz'],['11960584020','Sonia Regina'],
        ['11976012892','Camila Reis'],['18991306082','Ketza'],['11993870500','LORENA'],
        ['16982055400','Geni Coladao'],['12974052715','Tamires'],['11920006732','Monica Indumax'],
        ['13974130709','Kaah'],['13996551167','Marco'],['11970111555',''],['11913369980','Caren Cris'],
        ['11969072622','Zan Leme'],['11954023790','Vilma'],['14998066350','Larissa'],
        ['18997679948','Lavinia'],['11995731410','Leandro Oliveira'],['11948182559','Vanessa Vilar'],
        ['3591920047','Maria Julieta'],['13991593291','Leticia Lopes'],['19989920827','Pamela'],
        ['11945681427','Andrea'],['11967751623','Bruna'],['19999996549','salao de beleza'],
        ['11951454173','Leticia Vitoria'],['17991026216','Elaine'],['11978167497','Bruno Barbosa'],
        ['19992050683','Heitor'],['17997020923','Jessica Indiano'],['12981346214','Paula Frederice'],
        ['19991171848','Monica'],['11950304559','Amanda Oliveira'],['19987667344','Stephanie Ester'],
        ['3398574163','Katia Castro'],['19991183388','Dulcelena'],['11951762575','Dani'],
        ['19953225871','Janireis'],['11971718176','daniele alves'],['11976218912','Rosangela'],
        ['11910042803','Lore'],['11932167099','Yo'],['17981814549','Alessandra'],
        ['11954399259','Andreia Campos'],['13996852232','Elaine Wisniewski'],['11997148444','Debora'],
        ['11950689442','Jaque'],['19994948176',''],['11962191024','Raay'],['19991045084','Karina'],
        ['11981311790','Michele'],['11957847423','Patylopesvariedades'],['3192608674','Diego Herneck'],
        ['11965933511','Julia Merencio'],['11933165155','Nath'],['12981387169','Jessica'],
        ['19981766288','Maria Tereza'],['13955428191','Juh'],['11930404572','rocacamila18'],
        ['11992803556','Ana'],['17996504665','Gualberto Clenea'],['11947134614','adriana Antunes'],
        ['11996490677','Eng Civil'],['11954934229','Maiah'],
    ];
    $inserted = 0; $skipped = 0;
    foreach ($pending as [$phone, $name]) {
        if (!$phone) { $skipped++; continue; }
        $exists = $wpdb->get_var($wpdb->prepare("SELECT id FROM $table WHERE phone=%s", $phone));
        if ($exists) { $skipped++; continue; }
        $wpdb->insert($table, [
            'phone' => $phone, 'name' => $name, 'email' => '',
            'origens' => wp_json_encode(['kommo_import']),
            'last_activity' => current_time('mysql'),
            'created_at' => current_time('mysql'), 'updated_at' => current_time('mysql'),
        ]);
        $inserted++;
    }
    header('Content-Type: application/json');
    echo wp_json_encode(['ok' => true, 'inserted' => $inserted, 'skipped' => $skipped, 'total' => count($pending)]);
    exit;
});

// ── Helper: status de pagamento confirmado (gateway) ────────────────────────
if ( ! function_exists( 'vm2_order_statuses' ) ) {
    function vm2_order_statuses() {
        return [ 'processing', 'completed' ];
    }
    function vm2_order_statuses_prefixed() {
        return [ 'wc-processing', 'wc-completed' ];
    }
}

define( 'VM2_PLUGIN_DIR', plugin_dir_path( __FILE__ ) );
define( 'VM2_PLUGIN_URL', plugin_dir_url( __FILE__ ) );
define( 'VM2_ZAPI_CLIENT', 'F1171b821f92c49d2b16f329f44d450a0S' );

// ─────────────────────────────────────────────────────────────
// HELPER: DATA/HORA EM UTC-3 (AMERICA/SAO_PAULO)
// ─────────────────────────────────────────────────────────────
function vm2_local_date( $format, $timestamp_or_str ) {
    if ( empty( $timestamp_or_str ) ) return '—';
    $ts = is_numeric( $timestamp_or_str ) ? (int) $timestamp_or_str : strtotime( $timestamp_or_str );
    if ( ! $ts ) return '—';
    try {
        $tz = new DateTimeZone( 'America/Sao_Paulo' );
        $dt = new DateTime( '@' . $ts );
        $dt->setTimezone( $tz );
        return $dt->format( $format );
    } catch ( Exception $e ) {
        return date( $format, $ts );
    }
}

// ─────────────────────────────────────────────────────────────
// CANAIS Z-API
// ─────────────────────────────────────────────────────────────
function vm2_channels() {
    $pool = get_option( 'vm2_channel_pool', [] );
    if ( is_string( $pool ) ) $pool = json_decode( $pool, true ) ?: [];

    // Auto-popular SOMENTE se o pool estiver completamente vazio
    if ( empty( $pool ) ) {
        $pool['zapi_7551'] = [
            'label'    => '📞 VIVA 7551 (admin)',
            'type'     => 'zapi',
            'instance' => '3F1FCBB5942B61F53313AAE399BC1248',
            'token'    => 'DE0D34DA97E5E7621D3DFADC',
            'client'   => 'F1171b821f92c49d2b16f329f44d450a0S',
            'number'   => '5511988137551',
        ];
        $pool['zapi_1886'] = [
            'label'    => '📱 VIVA 1886 (atendimento)',
            'type'     => 'zapi',
            'instance' => '3F24D459CDD6615733FDC60C7A17E6CF',
            'token'    => '45982BD10E5E7BFAA766A1B4',
            'client'   => 'F1171b821f92c49d2b16f329f44d450a0S',
            'number'   => '5511947771886',
        ];
        update_option( 'vm2_channel_pool', $pool );
    }
    return $pool;
}

// ─────────────────────────────────────────────────────────────
// SENDS TABLE — deduplicação central multi-módulo
// ─────────────────────────────────────────────────────────────

/**
 * Verifica se está em horário silencioso (quiet hours).
 * Usa vm_wa_quiet_start e vm_wa_quiet_end (compartilhado com WA Recovery).
 * Retorna true se NÃO deve enviar agora.
 */
function vm2_is_quiet_time() {
    $start = (int) get_option( 'vm_wa_quiet_start', 22 );
    $end   = (int) get_option( 'vm_wa_quiet_end',    8 );
    $hora  = (int) wp_date( 'G' ); // hora atual em America/Sao_Paulo via WP timezone
    if ( $start === $end ) return false; // desabilitado se igual
    if ( $start > $end ) {
        // overnight: ex. 22h–8h → quieto se hora >= 22 OU hora < 8
        return ( $hora >= $start || $hora < $end );
    }
    // mesmo dia: ex. 1h–6h
    return ( $hora >= $start && $hora < $end );
}

/**
 * Verifica se o cap global diário de envios foi atingido.
 * vm2_global_daily_limit = 0 → desabilitado (sem limite).
 * Retorna true se NÃO deve enviar mais hoje.
 */
function vm2_daily_cap_reached() {
    $cap = (int) get_option( 'vm2_global_daily_limit', 0 );
    if ( $cap <= 0 ) return false; // 0 = desabilitado
    global $wpdb;
    $today = current_time( 'Y-m-d' );
    $count = (int) $wpdb->get_var( $wpdb->prepare(
        "SELECT COUNT(*) FROM {$wpdb->prefix}vm2_sends WHERE DATE(sent_at) = %s",
        $today
    ) );
    return ( $count >= $cap );
}

/**
 * Registra um envio na tabela vm2_sends (árbitro central de cooldown).
 */
function vm2_record_send( $phone, $module, $channel_key = '' ) {
    global $wpdb;
    $wpdb->insert(
        $wpdb->prefix . 'vm2_sends',
        [
            'phone'       => (string) $phone,
            'module'      => (string) $module,
            'channel_key' => (string) $channel_key,
            'sent_at'     => current_time( 'mysql' ),
        ],
        [ '%s', '%s', '%s', '%s' ]
    );
}

/**
 * Verifica se este número pode receber mensagem agora.
 * @param string $phone       Número formatado
 * @param int    $min_hours   Cooldown mínimo em horas desde o último envio (default 72)
 * @param int    $max_weekly  Máx msgs nos últimos 7 dias; 0 = sem limite (default 0)
 * Retorna true se PODE enviar.
 */
function vm2_can_send( $phone, $min_hours = 72, $max_weekly = 0 ) {
    global $wpdb;
    // Critério 1: cooldown desde o último envio
    $cnt = (int) $wpdb->get_var( $wpdb->prepare(
        "SELECT COUNT(*) FROM {$wpdb->prefix}vm2_sends
         WHERE phone = %s AND sent_at >= DATE_SUB(NOW(), INTERVAL %d HOUR)",
        $phone, $min_hours
    ) );
    if ( $cnt > 0 ) return false;
    // Critério 2: limite semanal (se configurado)
    if ( $max_weekly > 0 ) {
        $weekly = (int) $wpdb->get_var( $wpdb->prepare(
            "SELECT COUNT(*) FROM {$wpdb->prefix}vm2_sends
             WHERE phone = %s AND sent_at >= DATE_SUB(NOW(), INTERVAL 7 DAY)",
            $phone
        ) );
        if ( $weekly >= $max_weekly ) return false;
    }
    return true;
}

/**
 * Quantas mensagens este canal enviou hoje (para controle de limite diário).
 */
function vm2_channel_today_count( $channel_key ) {
    global $wpdb;
    return (int) $wpdb->get_var( $wpdb->prepare(
        "SELECT COUNT(*) FROM {$wpdb->prefix}vm2_sends
         WHERE channel_key = %s AND DATE(sent_at) = CURDATE()",
        $channel_key
    ) );
}

/**
 * Retorna o canal do pool com mais capacidade restante para hoje.
 * $preferred_key — tenta usar este canal primeiro (configuração do módulo).
 * Retorna null se todos os canais atingiram o limite diário.
 */
function vm2_get_best_channel( $preferred_key = null ) {
    $channels = vm2_channels();
    if ( empty( $channels ) ) return null;

    // Se o canal preferido está ATIVO e ainda tem capacidade, usa ele
    if ( $preferred_key && isset( $channels[ $preferred_key ] ) ) {
        $ch_pref = $channels[ $preferred_key ];
        if ( ( $ch_pref['status'] ?? 'active' ) !== 'paused' ) {
            $limit = (int) ( $ch_pref['daily_limit'] ?? 50 );
            if ( vm2_channel_today_count( $preferred_key ) < $limit ) {
                return $preferred_key;
            }
        }
    }

    // Caso contrário, rotaciona para o canal ATIVO com maior capacidade restante
    // ⏸ Canais pausados são completamente ignorados — nunca recebem overflow
    $best           = null;
    $best_remaining = -1;
    foreach ( $channels as $key => $ch ) {
        if ( ( $ch['status'] ?? 'active' ) === 'paused' ) continue; // pula pausados
        $limit     = (int) ( $ch['daily_limit'] ?? 50 );
        $remaining = $limit - vm2_channel_today_count( $key );
        if ( $remaining > $best_remaining ) {
            $best_remaining = $remaining;
            $best           = $key;
        }
    }
    return $best_remaining > 0 ? $best : null;
}

/**
 * Gera URL rastreável com UTM para mensagens outbound.
 * Variável {link} nas mensagens é substituída por este valor.
 */
function vm2_tracking_url( $phone, $module, $dest = '' ) {
    if ( ! $dest ) $dest = home_url( '/' );
    return add_query_arg( [
        'utm_source'   => 'vm2_wa',
        'utm_medium'   => $module,
        'utm_campaign' => 'followup',
        'vm2t'         => substr( md5( $phone . $module . date( 'Ymd' ) ), 0, 8 ),
    ], $dest );
}

// Helper: array slug => label legível para todos os canais do pool
function vm2_channel_labels() {
    $map = [];
    foreach ( vm2_channels() as $slug => $ch ) {
        $type  = strtoupper( $ch['type'] ?? 'zapi' );
        $num   = isset( $ch['number'] ) ? ' · +' . substr( $ch['number'], -4 ) : '';
        $map[ $slug ] = '[' . $type . '] ' . $ch['label'] . $num;
    }
    return $map;
}

// Helper: <option> dinâmicos para <select> de canal
function vm2_channel_options_html( $selected ) {
    $html = '';
    foreach ( vm2_channels() as $slug => $ch ) {
        $sel   = selected( $selected, $slug, false );
        $type  = strtoupper( $ch['type'] ?? 'zapi' );
        $num   = isset( $ch['number'] ) ? ' · +' . substr( $ch['number'], -4 ) : '';
        $label = '[' . $type . '] ' . $ch['label'] . $num;
        $html .= '<option value="' . esc_attr( $slug ) . "\" {$sel}>" . esc_html( $label ) . "</option>\n";
    }
    return $html;
}

// Helper: radio buttons dinâmicos para seleção de canal
function vm2_channel_radio_html( $name, $selected ) {
    $html = '';
    foreach ( vm2_channels() as $slug => $ch ) {
        $chk   = checked( $selected, $slug, false );
        $type  = $ch['type'] ?? 'zapi';
        $color = $type === 'waba' ? '#0866ff' : '#25d366';
        $badge = strtoupper( $type );
        $num   = isset( $ch['number'] ) ? ' · +' . substr( $ch['number'], -4 ) : '';
        $label = $ch['label'] . $num;
        $html .= '<label style="display:inline-flex;align-items:center;gap:5px;margin-right:16px;margin-bottom:4px;cursor:pointer;font-size:13px;flex-wrap:wrap">';
        $html .= '<input type="radio" name="' . esc_attr( $name ) . '" value="' . esc_attr( $slug ) . "\" {$chk}>";
        $html .= '<span style="background:' . $color . ';color:#fff;padding:1px 6px;border-radius:3px;font-size:10px;font-weight:bold">' . $badge . '</span>';
        $html .= esc_html( $label );
        $html .= "</label>\n";
    }
    return $html;
}


// ─────────────────────────────────────────────────────────────
// TEMPLATES WABA APROVADOS (dinâmico — gerenciável em Settings)
// ─────────────────────────────────────────────────────────────
function vm2_waba_templates_list() {
    $defaults = [
        ''                             => '— Nenhum —',
        'vm_pos_janela_d3'             => 'vm_pos_janela_d3 — D+1 pós janela',
        '48h_waba_4loz4q'              => '48h_waba_4loz4q — D+1 alternativo',
        '5d_waba_gg939i'               => '5d_waba_gg939i — D+5/7',
        '15d_waba_qlwlek'              => '15d_waba_qlwlek — D+15',
        '30d_waba_h2turh'              => '30d_waba_h2turh — D+30',
        'cartaopresente'               => 'cartaopresente — Vale Presente',
        'oferta_de_reconquista_vxu081' => 'oferta_de_reconquista_vxu081 — Reengajamento',
        'recupera_carrinho_woo'        => 'recupera_carrinho_woo — WA Recovery',
    ];
    $custom = get_option( 'vm2_waba_templates', [] );
    if ( is_string( $custom ) ) $custom = json_decode( $custom, true ) ?: [];
    return array_merge( $defaults, $custom );
}

function vm2_waba_template_options_html( $selected = '' ) {
    $html = '';
    foreach ( vm2_waba_templates_list() as $tv => $tl ) {
        $sel   = selected( $selected, $tv, false );
        $html .= sprintf( '<option value="%s"%s>%s</option>', esc_attr( $tv ), $sel, esc_html( $tl ) );
    }
    return $html;
}

// ─────────────────────────────────────────────────────────────
// MENSAGENS PADRÃO
// ─────────────────────────────────────────────────────────────
function vm2_default_msg_vendas() {
    return "💰 *NOVO PEDIDO NR {numero}*\n"
         . "✅ Processando — Pago\n"
         . "👤 {nome}\n"
         . "📱 +{telefone}\n"
         . "📅 Evento: {data_evento}\n"
         . "🎪 {atracao}\n"
         . "💳 Pgto: {pgto}\n"
         . "💵 R\$ {valor}\n"
         . "📍 Origem: {utm_source} / {utm_campaign}\n"
         . "🔗 {link_admin}";
}

function vm2_default_msg_agenda() {
    return "📋 *FICHA DO EVENTO — PEDIDO #{numero}*\n\n"
         . "DATA DO EVENTO: {data_evento}\n\n"
         . "Tipo Evento: {tipo_evento}\n"
         . "Homenageado(s): {homenageado}\n"
         . "Local do Evento: {local_evento}\n"
         . "Endereço do Evento: {endereco}\n\n"
         . "EVENTO INÍCIO: {hora_inicio}\n"
         . "EVENTO TÉRMINO: {hora_termino}\n\n"
         . "✅ *Serviços VivaMais*\n"
         . "ATRAÇÃO: {atracao}\n"
         . "DURAÇÃO: {duracao} min\n"
         . "HORA ENTRADA: {hora_inicio}\n"
         . "HORA SAÍDA: {hora_termino}\n\n"
         . "Assessor: {assessor}\n"
         . "Observações: {obs}\n\n"
         . "📝 Contrato: {contrato}";
}

function vm2_default_msg_cliente() {
    return "Olá, {nome}! 🎉\n\n"
         . "Seu pedido #{numero} foi confirmado!\n"
         . "Data do seu evento: {data_evento}\n\n"
         . "Qualquer dúvida, estamos aqui 😊\n"
         . "https://wa.me/5511947771886";
}

// ─────────────────────────────────────────────────────────────
// ATIVAÇÃO
// ─────────────────────────────────────────────────────────────
register_activation_hook( __FILE__, 'vm2_activate' );

// Migration v1.5.14 — patch null coupon_code in active discounts (fix: coluna é discount_percent)
add_action('plugins_loaded', function() {
    if ( get_option('vm2_migrated_coupon_code_v1514') ) return;
    global $wpdb;
    $tbl = 'wz_active_discounts';
    if ( $wpdb->get_var("SHOW TABLES LIKE '{$tbl}'") !== $tbl ) {
        update_option('vm2_migrated_coupon_code_v1514', 1);
        return;
    }
    $row = $wpdb->get_row("SELECT * FROM {$tbl} WHERE reverted_at IS NULL AND (coupon_code IS NULL OR coupon_code='') ORDER BY id DESC LIMIT 1");
    if ( $row ) {
        // Coluna pode ser discount_percent ou discount dependendo da versão do plugin
        $discount = intval( $row->discount_percent ?? $row->discount ?? 0 );
        if ( $discount > 0 ) {
            $coupon_code = strtoupper('PROMO' . $discount . 'OFF');
            // Cria cupom WooCommerce se não existir
            $existing = get_page_by_title($coupon_code, OBJECT, 'shop_coupon');
            if ( !$existing ) {
                $coupon_id = wp_insert_post(['post_title'=>$coupon_code,'post_status'=>'publish','post_type'=>'shop_coupon']);
                if ( $coupon_id && !is_wp_error($coupon_id) ) {
                    update_post_meta($coupon_id, 'discount_type', 'percent');
                    update_post_meta($coupon_id, 'coupon_amount', $discount);
                    update_post_meta($coupon_id, 'individual_use', 'no');
                    if ( !empty($row->expires_at) && $row->expires_at !== '0000-00-00 00:00:00' ) {
                        update_post_meta($coupon_id, 'expiry_date', date('Y-m-d', strtotime($row->expires_at)));
                    }
                }
            }
            // Salva coupon_code no registro
            $wpdb->update($tbl, ['coupon_code' => $coupon_code], ['id' => $row->id]);
        }
    }
    update_option('vm2_migrated_coupon_code_v1514', 1);
}, 20);
function vm2_activate() {
    $defaults = [
        'vm2_kill_switch'              => '0',
        'vm2_pedidos_vendas_enabled'   => '1',
        'vm2_pedidos_vendas_channel'   => 'zapi_7551',
        'vm2_pedidos_vendas_group_id'  => '120363425785358764-group',
        'vm2_pedidos_vendas_msg'       => vm2_default_msg_vendas(),
        'vm2_pedidos_agenda_enabled'   => '1',
        'vm2_pedidos_agenda_channel'   => 'zapi_7551',
        'vm2_pedidos_agenda_group_id'  => '120363419180214481-group',
        'vm2_pedidos_agenda_msg'       => vm2_default_msg_agenda(),
        'vm2_pedidos_cliente_enabled'  => '0',
        'vm2_pedidos_cliente_channel'  => 'zapi_1886',
        'vm2_pedidos_cliente_msg'      => vm2_default_msg_cliente(),
    ];
    foreach ( $defaults as $key => $val ) {
        if ( get_option( $key ) === false ) {
            add_option( $key, $val );
        }
    }
    vm2_create_partner_tables();
    vm2_create_sends_table();
    vm2_create_sofia_table();
}

// ─────────────────────────────────────────────────────────────
// MENUS
// ─────────────────────────────────────────────────────────────
add_action( 'admin_menu', 'vm2_register_menus' );
function vm2_register_menus() {
    add_menu_page(
        'VivaMais 2.0',
        '🌟 VIVAMAIS 2.0',
        'manage_options',
        'vm2-crm',
        'vm2_dashboard_page',
        'dashicons-star-filled',
        3
    );
    add_submenu_page( 'vm2-crm', 'Dashboard',              'Dashboard',         'manage_options', 'vm2-crm',      'vm2_dashboard_page' );
    add_submenu_page( 'vm2-crm', 'Contatos',               '👥 Contatos',       'manage_options', 'vm2-contacts', 'vm2_contacts_page' );
    add_submenu_page( 'vm2-crm', 'Agenda',                  '📅 Agenda',         'manage_options', 'vm2-agenda',   'vm2_agenda_page' );
    add_submenu_page( 'vm2-crm', 'Automações',              '🤖 Automações',     'manage_options', 'vm2-automacoes', 'vm2_automacoes_page' );
    add_submenu_page( 'vm2-crm', 'Parceiros',            '🎭 Parceiros',      'manage_options', 'vm2-parceiros','vm2_parceiros_page' );
    add_submenu_page( 'vm2-crm', 'Financeiro',            '💰 Financeiro',     'manage_options', 'vm2-financeiro','vm2_financeiro_page' );
    add_submenu_page( 'vm2-crm', 'Notificação de Pedidos', '🛒 Pedidos',        'manage_options', 'vm2-pedidos',  'vm2_pedidos_page' );
    add_submenu_page( 'vm2-crm', 'Grupo Promo',            '💬 Grupo Promo',    'manage_options', 'vm2-grupo-promo', 'vm2_grupo_promo_page' );
    add_submenu_page( 'vm2-crm', 'Promos Dashboard',       '📊 Promos',         'manage_options', 'vm2-promos',        'vm2_promos_page' );
    add_submenu_page( 'vm2-crm', 'Barras Promocionais',    '📣 Barras',         'manage_options', 'vm2-barras',        'vm2_barras_page' );
    // Banner Promo → aba config dentro de vm2-promos (sem menu separado)
    add_submenu_page( 'vm2-crm', 'Gatilhos Visuais',       '✨ Gatilhos Visuais', 'manage_options', 'vm2-gatilhos',    'vm2_gatilhos_page' );
    add_submenu_page( 'vm2-crm', 'SofIA Intelligence',     '🧠 SofIA',          'manage_options', 'vm2-sofia',         'vm2_sofia_page' );
    add_submenu_page( 'vm2-crm', 'Configurações V2',       '⚙️ Configurações',  'manage_options', 'vm2-settings',      'vm2_settings_page' );
}

// ─────────────────────────────────────────────────────────────
// MOBILE-FIRST GLOBAL CSS (admin_head)
// ─────────────────────────────────────────────────────────────
add_action('admin_head', function() {
    $screen = get_current_screen();
    if (!$screen || strpos($screen->id, 'vm2') === false) return;
    ?>
    <style id="vm2-mobile-global">
    /* ── VM2 mobile-first global overrides ── */
    @media (max-width: 600px) {
        /* Todos os grids 2-col → 1 col no mobile */
        .vm2-detail-grid,
        .vm2-step-grid,
        .vm2-form-row,
        .vm2-cfg-2col { grid-template-columns: 1fr !important; }

        /* KPI cards: mínimo de 140px no mobile */
        .vm2-kpis { grid-template-columns: repeat(auto-fit,minmax(140px,1fr)) !important; }

        /* Cards: sem padding excessivo */
        .vm2-card { padding: 12px !important; }

        /* Tabs: wrap melhor */
        .vm2-tabs { gap: 4px !important; }
        .vm2-tab { padding: 6px 10px !important; font-size: 12px !important; }

        /* Tabelas: sempre com scroll horizontal */
        .vm2-card > div[style*="overflow-x"] { overflow-x: auto !important; -webkit-overflow-scrolling: touch; }

        /* Botões em linha: wrap */
        .vm2-actions, .button-group { flex-wrap: wrap !important; gap: 4px !important; }

        /* Inputs full-width no mobile */
        .vm2-cfg-2col input[type="number"] { width: 80px; }
    }
    @media (max-width: 782px) {
        /* Sidebar WP collapsed no mobile — mais espaço para conteúdo */
        #wpcontent { margin-left: 0 !important; }
    }
    </style>
    <?php
});

// ─────────────────────────────────────────────────────────────
// WP_HEAD — BARRAS PROMOCIONAIS KILL SWITCH (v1.5.35)
// Hub pode ser auto-atualizado removendo o guard — este hook
// garante que as barras ficam ocultas quando pausadas no admin V2.
// ─────────────────────────────────────────────────────────────
add_action('wp_head', function() {
    $coupon_on      = (int) get_option('vmhub_coupon_bar_enabled',        1);
    $viral_on       = (int) get_option('vmhub_viral_bar_enabled',         1);
    $discount_on    = (int) get_option('vm2_sp_discount_badge_enabled',   1);
    $sticky_cta_on  = (int) get_option('vm2_sticky_cta_enabled',          0); // Barra VER DATAS — padrão: desativada
    if ($coupon_on && $viral_on && $discount_on && $sticky_cta_on) return; // tudo ativo — nada a fazer
    $css = '';
    if (!$coupon_on)     $css .= '.vmhub-coupon-bar{display:none!important;}';
    if (!$viral_on)      $css .= '#vmhub-viral-bar,.vmhub-viral-bar{display:none!important;}';
    if (!$discount_on)   $css .= '.vmap-badge,.vmap-de{display:none!important;}';
    if (!$sticky_cta_on) $css .= '#vm-sticky-product-cta{display:none!important;}';
    echo '<style id="vm2-barras-override">' . $css . '</style>' . "\n";
}, 99); // priority 99 — depois do Hub

// ─────────────────────────────────────────────────────────────
// DASHBOARD
// ─────────────────────────────────────────────────────────────
function vm2_dashboard_page() {
    global $wpdb;

    $ks = get_option( 'vm2_kill_switch', '0' );

    // ── Period selector ──────────────────────────────────────────
    $period  = isset( $_GET['period'] ) ? sanitize_text_field( $_GET['period'] ) : 'month';
    $periods = [
        'month'     => 'Mês Atual',
        'lastmonth' => 'Mês Anterior',
        'year'      => date( 'Y' ),
        'all'       => 'Acumulado Total',
    ];

    switch ( $period ) {
        case 'lastmonth':
            $start      = date( 'Y-m-01', strtotime( 'first day of last month' ) );
            $end        = date( 'Y-m-t',  strtotime( 'last day of last month' ) );
            $start_prev = date( 'Y-m-01', strtotime( 'first day of 2 months ago' ) );
            $end_prev   = date( 'Y-m-t',  strtotime( 'last day of 2 months ago' ) );
            break;
        case 'year':
            $start      = date( 'Y-01-01' );
            $end        = date( 'Y-12-31' );
            $start_prev = date( 'Y-01-01', strtotime( '-1 year' ) );
            $end_prev   = date( 'Y-12-31', strtotime( '-1 year' ) );
            break;
        case 'all':
            $start      = '2020-01-01';
            $end        = date( 'Y-12-31' );
            $start_prev = null;
            $end_prev   = null;
            break;
        default: // month
            $start      = date( 'Y-m-01' );
            $end        = date( 'Y-m-t' );
            $start_prev = date( 'Y-m-01', strtotime( 'first day of last month' ) );
            $end_prev   = date( 'Y-m-t',  strtotime( 'last day of last month' ) );
            break;
    }

    // ── WooCommerce KPIs (query direta HPOS — evita bug date_created com status custom) ─
    $tbl_o     = $wpdb->prefix . 'wc_orders';
    $start_gmt = get_gmt_from_date( $start . ' 00:00:00' );
    $end_gmt   = get_gmt_from_date( $end   . ' 23:59:59' );

    // Receita confirmada (processing + completed — gateway confirmou pagamento)
    $kpi_cur = $wpdb->get_row( $wpdb->prepare(
        "SELECT COUNT(*) AS cnt, COALESCE(SUM(total_amount),0) AS total
         FROM `{$tbl_o}`
         WHERE status IN ('wc-processing','wc-completed')
         AND date_created_gmt >= %s AND date_created_gmt <= %s",
        $start_gmt, $end_gmt
    ) );
    $num_pedidos = (int)( $kpi_cur->cnt ?? 0 );
    $receita     = (float)( $kpi_cur->total ?? 0 );
    $ticket      = $num_pedidos > 0 ? $receita / $num_pedidos : 0;

    // ClickSign pipeline (signing-pending + contract-signed)
    $cs_cur = $wpdb->get_row( $wpdb->prepare(
        "SELECT COUNT(*) AS cnt, COALESCE(SUM(total_amount),0) AS total
         FROM `{$tbl_o}`
         WHERE status IN ('wc-signing-pending','wc-contract-signed')
         AND date_created_gmt >= %s AND date_created_gmt <= %s",
        $start_gmt, $end_gmt
    ) );
    $num_contratos = (int)( $cs_cur->cnt ?? 0 );
    $val_contratos = (float)( $cs_cur->total ?? 0 );

    // Período anterior (só confirmed)
    $receita_prev = 0;
    $num_prev     = 0;
    if ( $start_prev ) {
        $sp_gmt  = get_gmt_from_date( $start_prev . ' 00:00:00' );
        $ep_gmt  = get_gmt_from_date( $end_prev   . ' 23:59:59' );
        $kpi_prv = $wpdb->get_row( $wpdb->prepare(
            "SELECT COUNT(*) AS cnt, COALESCE(SUM(total_amount),0) AS total
             FROM `{$tbl_o}`
             WHERE status IN ('wc-processing','wc-completed')
             AND date_created_gmt >= %s AND date_created_gmt <= %s",
            $sp_gmt, $ep_gmt
        ) );
        $num_prev     = (int)( $kpi_prv->cnt ?? 0 );
        $receita_prev = (float)( $kpi_prv->total ?? 0 );
    }

    // ── Kommo Funil ──────────────────────────────────────────────
    $total_leads    = (int) $wpdb->get_var( "SELECT COUNT(*) FROM vm_kommo_leads" );
    $leads_hot      = (int) $wpdb->get_var( "SELECT COUNT(*) FROM vm_kommo_leads WHERE status_id = 94305664" );
    $leads_conv     = (int) $wpdb->get_var( "SELECT COUNT(*) FROM vm_kommo_leads WHERE status_id = 94325167" );
    $leads_sem_data = (int) $wpdb->get_var( "SELECT COUNT(*) FROM vm_kommo_leads WHERE (data_evento IS NULL OR data_evento = '') AND status_id NOT IN (142, 143)" );

    // ── WA Recovery stats ────────────────────────────────────────
    $wa_ks    = get_option( 'vm_wa_kill_switch', '1' );
    $wa_total = (int) $wpdb->get_var( $wpdb->prepare(
        "SELECT COUNT(*) FROM vm_warmup_log WHERE sent_at >= %s AND sent_at <= %s",
        $start . ' 00:00:00', $end . ' 23:59:59'
    ) );

    // ── Alertas ──────────────────────────────────────────────────
    $alertas = [];
    if ( $ks === '1' ) $alertas[] = ['🔴', 'Kill Switch Global V2 ATIVO — nenhuma mensagem V2 está saindo.', 'error'];
    if ( get_option( 'vm_kill_switch', '1' ) === '1' ) $alertas[] = ['🟡', 'V1 pausada (kill switch ON). Apenas WA Recovery envia mensagens.', 'warning'];
    if ( $leads_sem_data > 500 ) $alertas[] = ['🟡', $leads_sem_data . ' leads no Kommo sem data de evento — considere campanha de reengajamento.', 'warning'];

    // ── Pedidos Recentes ─────────────────────────────────────────
    $recent_orders = wc_get_orders( [
        'limit'   => 6,
        'orderby' => 'date',
        'order'   => 'DESC',
        'status'  => array_map( fn($s) => "wc-$s", vm2_order_statuses() ),
    ] );

    $channels = vm2_channels();
    $delta_r  = ( $receita_prev > 0 ) ? round( ( $receita - $receita_prev ) / $receita_prev * 100, 1 ) : null;
    $delta_p  = $start_prev ? ( $num_pedidos - $num_prev ) : null;

    // ── Dashboard Smart KPIs v1.3.9 ──────────────────────────────
    // Carrinhos abandonados hoje
    $carrinhos_hoje = (int) $wpdb->get_var(
        "SELECT COUNT(*) FROM vm_wa_captures WHERE DATE(captured_at) = CURDATE()"
    );
    $carrinho_val = (float) $wpdb->get_var(
        "SELECT COALESCE(SUM(cart_total),0) FROM vm_wa_captures WHERE DATE(captured_at) = CURDATE()"
    );

    // WA Recovery hoje
    $wa_hoje = (int) $wpdb->get_var(
        "SELECT COUNT(*) FROM vm_warmup_log WHERE DATE(sent_at) = CURDATE()"
    );

    // Popup stats
    $popup_conv  = (int) get_option( 'vm2_popup_stat_conversions', 0 );
    $popup_shows = (int) get_option( 'vm2_popup_stat_shows', 0 );

    // Eventos próximos — parse event_date de pedidos ativos
    $tbl_om   = $wpdb->prefix . 'wc_orders_meta';
    $tbl_wo   = $wpdb->prefix . 'wc_orders';
    $ev_rows  = $wpdb->get_results(
        "SELECT m.meta_value AS ev
         FROM `{$tbl_wo}` o
         INNER JOIN `{$tbl_om}` m ON o.id = m.order_id AND m.meta_key = '_billing_event_date'
         WHERE o.status IN ('wc-processing','wc-completed','wc-signing-pending','wc-contract-signed')
         AND m.meta_value != ''"
    );
    $today_ts  = strtotime( 'today' );
    $in7_ts    = strtotime( '+7 days' );
    $in30_ts   = strtotime( '+30 days' );
    $ev_prox7  = 0;
    $ev_prox30 = 0;
    foreach ( $ev_rows as $ev_row ) {
        $v  = trim( $ev_row->ev );
        $ts = 0;
        if ( preg_match( '/^\d{8}$/', $v ) ) {
            $ts = mktime( 0, 0, 0, (int) substr( $v, 2, 2 ), (int) substr( $v, 0, 2 ), (int) substr( $v, 4, 4 ) );
        } elseif ( preg_match( '/^(\d{2})\/(\d{2})\/(\d{2,4})$/', $v, $dm ) ) {
            $yr = strlen( $dm[3] ) === 2 ? 2000 + (int) $dm[3] : (int) $dm[3];
            $ts = mktime( 0, 0, 0, (int) $dm[2], (int) $dm[1], $yr );
        }
        if ( $ts >= $today_ts && $ts <= $in30_ts ) $ev_prox30++;
        if ( $ts >= $today_ts && $ts <= $in7_ts  ) $ev_prox7++;
    }

    // Conversão HOT → Pedido (mês)
    $conv_hot_pct = $leads_hot > 0 ? round( $num_pedidos / $leads_hot * 100, 1 ) : 0;

    ?>
    <div class="wrap">
    <style>
    .vm2-wrap{font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif}
    .vm2-header{display:flex;align-items:center;justify-content:space-between;flex-wrap:wrap;gap:8px;margin-bottom:16px}
    .vm2-period-tabs{display:flex;gap:4px;flex-wrap:wrap}
    .vm2-period-tab{padding:5px 14px;border:1px solid #ddd;border-radius:20px;font-size:12px;text-decoration:none;color:#555;background:#fff;transition:all .15s}
    .vm2-period-tab:hover{border-color:#0073aa;color:#0073aa}
    .vm2-period-tab.active{background:#0073aa;color:#fff!important;border-color:#0073aa}
    .vm2-kpis{display:grid;grid-template-columns:repeat(auto-fit,minmax(190px,1fr));gap:12px;margin-bottom:16px}
    .vm2-kpi{background:#fff;border:1px solid #ddd;border-radius:10px;padding:18px 20px;box-shadow:0 1px 3px rgba(0,0,0,.04);cursor:pointer;transition:all .15s ease}
    .vm2-kpi:hover{transform:translateY(-2px);box-shadow:0 4px 14px rgba(0,0,0,.13);border-color:#0073aa}
    .vm2-kpi .label{font-size:11px;color:#888;text-transform:uppercase;letter-spacing:.5px;margin-bottom:8px}
    .vm2-kpi .value{font-size:28px;font-weight:700;color:#1a1a1a;line-height:1}
    .vm2-kpi .delta{font-size:12px;margin-top:8px}
    .vm2-kpi .delta.up{color:#27ae60}.vm2-kpi .delta.down{color:#e74c3c}.vm2-kpi .delta.neutral{color:#999}
    .vm2-grid2{display:grid;grid-template-columns:repeat(auto-fit,minmax(300px,1fr));gap:12px;margin-bottom:16px}
    .vm2-card{background:#fff;border:1px solid #ddd;border-radius:10px;padding:18px 20px;box-shadow:0 1px 3px rgba(0,0,0,.04)}
    .vm2-card h3{margin:0 0 14px;font-size:14px;color:#333;display:flex;align-items:center;gap:6px}
    .vm2-section-label{font-size:10px;text-transform:uppercase;letter-spacing:.5px;color:#aaa;margin:12px 0 6px;font-weight:600}
    .vm2-row{display:flex;align-items:center;gap:8px;padding:7px 0;border-bottom:1px solid #f5f5f5;font-size:13px}
    .vm2-row:last-child{border-bottom:none}
    .vm2-bar-wrap{flex:1;height:7px;background:#f0f0f0;border-radius:4px;overflow:hidden}
    .vm2-bar-fill{height:100%;border-radius:4px;transition:width .3s}
    .vm2-badge{display:inline-block;padding:2px 8px;border-radius:10px;font-size:11px;font-weight:600}
    .vm2-badge-green{background:#d4edda;color:#155724}
    .vm2-badge-blue{background:#cce5ff;color:#004085}
    .vm2-badge-orange{background:#fff3cd;color:#856404}
    .vm2-table{width:100%;border-collapse:collapse;font-size:13px}
    .vm2-table th{text-align:left;padding:6px 8px;background:#f9f9f9;border-bottom:2px solid #eee;font-size:11px;text-transform:uppercase;color:#888;white-space:nowrap}
    .vm2-table td{padding:8px;border-bottom:1px solid #f5f5f5;vertical-align:middle}
    .vm2-table tr:last-child td{border-bottom:none}
    .vm2-roadmap{display:flex;flex-wrap:wrap;gap:8px}
    .vm2-rm{padding:4px 14px;border-radius:20px;font-size:12px}
    .vm2-rm.done{background:#d4edda;color:#155724}
    .vm2-rm.pending{background:#f0f0f0;color:#999}
    .vm2-rm.progress{background:#fef9c3;color:#92400e}
    .vm2-alert-box{display:flex;align-items:flex-start;gap:8px;padding:10px 14px;border-radius:8px;font-size:13px;margin-bottom:8px}
    .vm2-alert-error{background:#fdf3f3;border:1px solid #f5c6cb;color:#721c24}
    .vm2-alert-warning{background:#fffbea;border:1px solid #ffeeba;color:#856404}
    .vm2-mono{font-family:monospace;font-size:11px;background:#f0f0f0;padding:2px 6px;border-radius:3px}
    </style>

    <div class="vm2-wrap">

    <!-- Header + Period Tabs -->
    <div class="vm2-header">
        <h1 style="margin:0">🌟 VIVAMAIS 2.0 <span style="font-size:12px;color:#999;font-weight:normal">v<?php echo VM2_VERSION; ?></span></h1>
        <div style="display:flex;align-items:center;gap:8px;flex-wrap:wrap">
            <div class="vm2-period-tabs">
                <?php foreach ( $periods as $key => $label ) : ?>
                <a href="?page=vm2-crm&period=<?php echo esc_attr($key); ?>"
                   class="vm2-period-tab <?php echo $period === $key ? 'active' : ''; ?>"><?php echo esc_html($label); ?></a>
                <?php endforeach; ?>
            </div>
            <button id="vm2-sync-btn" onclick="vm2DoSync()" style="background:#0073aa;color:#fff;border:none;border-radius:6px;padding:6px 14px;font-size:13px;cursor:pointer;display:flex;align-items:center;gap:5px;white-space:nowrap">
                🔄 <span id="vm2-sync-label">Sincronizar</span>
            </button>
        </div>
    </div>
    <script>
    function vm2DoSync() {
        var btn = document.getElementById('vm2-sync-btn');
        var lbl = document.getElementById('vm2-sync-label');
        btn.disabled = true;
        lbl.textContent = 'Sincronizando...';
        btn.style.opacity = '0.7';
        fetch(ajaxurl, {
            method: 'POST',
            headers: {'Content-Type': 'application/x-www-form-urlencoded'},
            body: 'action=vm2_manual_sync&nonce=' + <?php echo json_encode(wp_create_nonce('vm2_manual_sync')); ?>
        })
        .then(r => r.json())
        .then(function(res) {
            btn.disabled = false;
            btn.style.opacity = '1';
            if (res.success) {
                lbl.textContent = '✅ ' + (res.data.msg || 'Sincronizado!');
                setTimeout(function(){ lbl.textContent = 'Sincronizar'; location.reload(); }, 2500);
            } else {
                lbl.textContent = '❌ Erro';
                setTimeout(function(){ lbl.textContent = 'Sincronizar'; }, 3000);
            }
        })
        .catch(function(){ btn.disabled=false; btn.style.opacity='1'; lbl.textContent='❌ Falha'; setTimeout(function(){ lbl.textContent='Sincronizar'; },3000); });
    }
    </script>

    <!-- Alertas -->
    <?php foreach ( $alertas as $alerta ) : ?>
    <div class="vm2-alert-box vm2-alert-<?php echo $alerta[2]; ?>">
        <span><?php echo $alerta[0]; ?></span>
        <span><?php echo esc_html($alerta[1]); ?></span>
    </div>
    <?php endforeach; ?>

    <!-- KPI Cards — Gestão Inteligente v1.3.9 -->
    <p style="font-size:11px;text-transform:uppercase;letter-spacing:.5px;color:#aaa;margin:4px 0 8px;font-weight:600">🚨 Ação Imediata</p>
    <div class="vm2-kpis" style="margin-bottom:8px">

        <div class="vm2-kpi" style="border-left:3px solid #e67e22" onclick="location.href='?page=vm2-contatos'">
            <div class="label">🔥 Leads HOT</div>
            <div class="value"><?php echo number_format($leads_hot); ?></div>
            <div class="delta <?php echo $leads_hot > 0 ? 'down' : 'neutral'; ?>">
                <?php echo $leads_hot > 0 ? 'aguardando fechamento' : 'Nenhum lead quente'; ?>
            </div>
        </div>

        <div class="vm2-kpi" style="border-left:3px solid #9b59b6" onclick="location.href='?page=vm2-automacoes&tab=carrinho'">
            <div class="label">🛒 Carrinhos hoje</div>
            <div class="value"><?php echo $carrinhos_hoje; ?></div>
            <div class="delta <?php echo $carrinhos_hoje > 0 ? 'down' : 'neutral'; ?>">
                <?php echo $carrinhos_hoje > 0 ? 'R$ ' . number_format($carrinho_val, 0, ',', '.') . ' em risco' : 'Nenhum abandono hoje'; ?>
            </div>
        </div>

        <div class="vm2-kpi" style="border-left:3px solid #3498db" onclick="location.href='?page=vm2-pedidos'">
            <div class="label">🖊️ Contratos pendentes</div>
            <div class="value"><?php echo $num_contratos; ?></div>
            <div class="delta <?php echo $num_contratos > 0 ? 'neutral' : 'up'; ?>">
                <?php echo $num_contratos > 0 ? $num_contratos . ' aguard. assinatura' : 'Nenhum pendente ✓'; ?>
            </div>
        </div>

        <div class="vm2-kpi" style="border-left:3px solid #95a5a6" onclick="location.href='?page=vm2-contatos'">
            <div class="label">📅 Leads sem data</div>
            <div class="value"><?php echo number_format($leads_sem_data); ?></div>
            <div class="delta <?php echo $leads_sem_data > 500 ? 'down' : ($leads_sem_data > 0 ? 'neutral' : 'up'); ?>">
                <?php echo $leads_sem_data > 0 ? 'leads para reengajar' : 'Todos com data ✓'; ?>
            </div>
        </div>

    </div>

    <p style="font-size:11px;text-transform:uppercase;letter-spacing:.5px;color:#aaa;margin:12px 0 8px;font-weight:600">📊 Saúde do Negócio</p>
    <div class="vm2-kpis">

        <div class="vm2-kpi" style="border-left:3px solid #27ae60" onclick="location.href='?page=vm2-agenda'">
            <div class="label">🎪 Eventos próx. 30d</div>
            <div class="value"><?php echo $ev_prox30; ?></div>
            <div class="delta <?php echo $ev_prox7 > 0 ? 'down' : 'up'; ?>">
                <?php echo $ev_prox7 > 0 ? $ev_prox7 . ' esta semana 🔴' : 'Nenhum esta semana'; ?>
            </div>
        </div>

        <div class="vm2-kpi" style="border-left:3px solid #f39c12" onclick="location.href='?page=vm2-pedidos'">
            <div class="label">📈 Conversão HOT→Venda</div>
            <div class="value"><?php echo $conv_hot_pct; ?>%</div>
            <div class="delta neutral"><?php echo $num_pedidos; ?> pedidos / <?php echo $leads_hot; ?> HOT</div>
        </div>

        <div class="vm2-kpi" style="border-left:3px solid #1abc9c" onclick="location.href='?page=vm2-automacoes&tab=carrinho'">
            <div class="label">📨 WA Recovery hoje</div>
            <div class="value"><?php echo $wa_hoje; ?></div>
            <div class="delta <?php echo $wa_hoje > 0 ? 'up' : 'neutral'; ?>">
                <?php echo $wa_hoje > 0 ? 'mensagens enviadas ✓' : number_format($wa_total) . ' no período'; ?>
            </div>
        </div>

        <div class="vm2-kpi" style="border-left:3px solid #e74c3c" onclick="location.href='?page=vm2-automacoes&tab=popup'">
            <div class="label">🎯 Popup — Conversões</div>
            <div class="value"><?php echo $popup_conv; ?></div>
            <div class="delta neutral">
                <?php echo $popup_shows > 0 ? number_format($popup_conv/$popup_shows*100,1) . '% de ' . number_format($popup_shows) . ' exib.' : 'Aguardando dados'; ?>
            </div>
        </div>

    </div>
    <!-- Funil + Status -->
    <div class="vm2-grid2">

        <!-- Funil de Vendas -->
        <div class="vm2-card">
            <h3>🔻 Funil de Vendas</h3>
            <?php
            $max = max( $total_leads, 1 );
            $funil = [
                ['Total Leads Kommo', $total_leads,   '#3498db'],
                ['🔥 Hot / Incoming', $leads_hot,     '#e67e22'],
                ['✅ Contratou',      $leads_conv,    '#27ae60'],
                ['🛒 Pedidos WC',    $num_pedidos,   '#8e44ad'],
            ];
            foreach ( $funil as [$lbl, $val, $cor] ) :
                $pct = round( min(100, $val / $max * 100) );
            ?>
            <div class="vm2-row">
                <span style="width:150px;font-size:12px;flex-shrink:0"><?php echo $lbl; ?></span>
                <div class="vm2-bar-wrap"><div class="vm2-bar-fill" style="width:<?php echo $pct; ?>%;background:<?php echo $cor; ?>"></div></div>
                <span style="width:42px;text-align:right;font-weight:700;font-size:13px"><?php echo number_format($val); ?></span>
            </div>
            <?php endforeach; ?>
            <div style="margin-top:12px;padding:10px;background:#f9f9f9;border-radius:6px;font-size:12px;color:#555">
                🎯 Conversão Lead → Venda: <strong style="color:#0073aa"><?php echo $total_leads > 0 ? number_format($num_pedidos / $total_leads * 100, 2) : '0,00'; ?>%</strong>
                &nbsp;&nbsp;|&nbsp;&nbsp;
                🔥 Taxa Hot: <strong><?php echo $total_leads > 0 ? number_format($leads_hot / $total_leads * 100, 1) : '0'; ?>%</strong>
            </div>
        </div>

        <!-- Status do Sistema -->
        <div class="vm2-card">
            <h3>📡 Status do Sistema</h3>

            <div class="vm2-section-label">Canais de Envio</div>
            <?php foreach ( $channels as $key => $ch ) : ?>
            <div class="vm2-row">
                <span class="vm2-mono"><?php echo esc_html($key); ?></span>
                <span style="font-size:12px"><?php echo esc_html($ch['label']); ?></span>
                <span style="margin-left:auto">🟢 Ativo</span>
            </div>
            <?php endforeach; ?>

            <div class="vm2-section-label">Módulos</div>
            <?php
            $v2ks = $ks === '1';
            $v1ks = get_option( 'vm_kill_switch', '1' ) === '1';
            $modulos = [
                ['🛒 Notificação Pedidos (V2)', !$v2ks && get_option('vm2_pedidos_vendas_enabled','1')==='1'],
                ['🔁 WA Recovery',              $wa_ks === '0'],
                ['🔥 Aquecer / Nurturing (V1)', !$v1ks],
                ['🔒 Kill Switch Global V2',    !$v2ks],
            ];
            foreach ( $modulos as [$lbl, $ok] ) : ?>
            <div class="vm2-row">
                <span style="font-size:12px"><?php echo $lbl; ?></span>
                <span style="margin-left:auto;font-weight:600;font-size:12px;color:<?php echo $ok ? '#27ae60' : '#c0392b'; ?>">
                    <?php echo $ok ? '🟢 ON' : '🔴 OFF'; ?>
                </span>
            </div>
            <?php endforeach; ?>

            <?php if ( $wa_total > 0 ) : ?>
            <div style="margin-top:10px;padding:8px 10px;background:#f9f9f9;border-radius:6px;font-size:12px;color:#555">
                📨 WA Recovery enviados no período: <strong><?php echo number_format($wa_total); ?></strong>
            </div>
            <?php endif; ?>
        </div>

    </div>

    <!-- Pedidos Recentes -->
    <div class="vm2-card" style="margin-bottom:16px">
        <h3>📋 Pedidos Recentes</h3>
        <div style="overflow-x:auto">
        <table class="vm2-table">
            <thead>
                <tr>
                    <th>#</th>
                    <th>Cliente</th>
                    <th>Data Pedido</th>
                    <th>Data Evento</th>
                    <th>Valor</th>
                    <th>Status</th>
                    <th></th>
                </tr>
            </thead>
            <tbody>
            <?php foreach ( $recent_orders as $order ) :
                $ev_raw = $order->get_meta( '_billing_event_date' );
                $ev_fmt = vm2_format_event_date( $ev_raw );
                $st     = $order->get_status();
                $badge  = $st === 'processing' ? ['vm2-badge-blue','⚙️ Processando'] : ( $st === 'completed' ? ['vm2-badge-green','✅ Concluído'] : ['vm2-badge-orange','⏳ ' . ucfirst($st)] );
            ?>
            <tr>
                <td><strong>#<?php echo $order->get_id(); ?></strong></td>
                <td><?php echo esc_html( trim( $order->get_billing_first_name() . ' ' . $order->get_billing_last_name() ) ); ?></td>
                <td><?php echo esc_html( date( 'd/m/Y', strtotime( $order->get_date_created() ) ) ); ?></td>
                <td><?php echo $ev_fmt ? esc_html($ev_fmt) : '<span style="color:#ccc">—</span>'; ?></td>
                <td><strong>R$ <?php echo number_format( $order->get_total(), 0, ',', '.' ); ?></strong></td>
                <td><span class="vm2-badge <?php echo $badge[0]; ?>"><?php echo $badge[1]; ?></span></td>
                <td><a href="<?php echo esc_url( admin_url( 'post.php?post=' . $order->get_id() . '&action=edit' ) ); ?>" target="_blank" style="font-size:12px;color:#0073aa">Ver →</a></td>
            </tr>
            <?php endforeach; ?>
            </tbody>
        </table>
        </div>
        <div style="margin-top:10px;text-align:right">
            <a href="<?php echo esc_url( admin_url( 'edit.php?post_type=shop_order' ) ); ?>" class="button button-secondary" style="font-size:12px">Ver todos os pedidos →</a>
        </div>
    </div>

    <!-- Roadmap -->
    <div class="vm2-card">
        <h3>🗺️ Roadmap V2</h3>
        <div class="vm2-roadmap">
            <span class="vm2-rm done">✅ F1 — Plugin Base</span>
            <span class="vm2-rm done">✅ F2 — Dashboard + KPIs</span>
            <span class="vm2-rm done">✅ F3 — 🛒 Pedidos</span>
            <span class="vm2-rm done">✅ F4 — 👤 Contatos + Scoring</span>
            <span class="vm2-rm done">✅ F5 — ⚡ Automações</span>
            <span class="vm2-rm done">✅ F6 — 💬 Carrinho + Exit-Intent + Popup</span>
            <span class="vm2-rm done">✅ F7 — 📅 Agenda</span>
            <span class="vm2-rm progress">🔄 F8 — 🤝 Parceiros & Artistas</span>
            <span class="vm2-rm progress">🔄 F9 — 💰 Financeiro</span>
            <span class="vm2-rm pending">⏳ F10 — ⚙️ Config unificada</span>
            <span class="vm2-rm pending">⏳ F11 — 📋 Log unificado</span>
            <span class="vm2-rm pending">⏳ F12 — 🔄 Sync Planilha → Cron WP</span>
            <span class="vm2-rm pending">⏳ F13 — ✍️ ClickSign webhook</span>
        </div>
    </div>

    </div><!-- .vm2-wrap -->
    <?php
}


// ─────────────────────────────────────────────────────────────
// PEDIDOS PAGE
// ─────────────────────────────────────────────────────────────

// ═══════════════════════════════════════════════════════════════
// MÓDULO CONTATOS — v1.0.4
// ═══════════════════════════════════════════════════════════════

function vm2_lead_score( $lead, $wa_count = 0 ) {
    $score = 10;
    // Event date
    $ev_col = $lead->data_evento ?? $lead->ev_date ?? '';
    if ( ! empty( $ev_col ) ) {
        $ts   = strtotime( $ev_col );
        $days = ( $ts - time() ) / 86400;
        $score += 20;
        if ( $days >= 0 && $days <= 7 )       $score += 40;
        elseif ( $days >= 0 && $days <= 30 )  $score += 30;
        elseif ( $days >= 0 && $days <= 90 )  $score += 20;
        elseif ( $days >= 0 )                 $score += 10;
        else                                   $score -= 10; // past
    }
    // Kommo HOT stage
    if ( isset( $lead->status_id ) && (int) $lead->status_id === 94305664 ) $score += 25;
    // WA messages
    if ( $wa_count > 3 )      $score += 10;
    elseif ( $wa_count > 0 )  $score +=  5;
    // Email
    if ( ! empty( $lead->email ) ) $score += 5;
    return max( 0, min( 100, $score ) );
}

function vm2_score_badge( $score ) {
    if ( $score >= 75 ) return '<span class="vm2-badge-score vm2-hot">🔥 ' . $score . '</span>';
    if ( $score >= 45 ) return '<span class="vm2-badge-score vm2-warm">⚡ ' . $score . '</span>';
    return '<span class="vm2-badge-score vm2-cold">🌱 ' . $score . '</span>';
}

// ─────────────────────────────────────────────────────────────
// HELPER — NORMALIZE PHONE + LAST11
// ─────────────────────────────────────────────────────────────
function vm2_normalize_phone( $raw ) {
    $d = preg_replace( '/\D/', '', $raw );
    if ( strlen($d) === 11 ) $d = '55' . $d;
    if ( strlen($d) === 10 ) $d = '55' . $d;
    return ( strlen($d) >= 12 && strlen($d) <= 13 ) ? $d : '';
}

function vm2_phone_last11( $phone ) {
    return substr( preg_replace( '/\D/', '', $phone ), -11 );
}

// ─────────────────────────────────────────────────────────────
// HELPER — GET LEADS PARA AQUECER (multi-fonte, rankeados)
// Score: Kommo+10, DataEvento+15..55, HOT stage+25,
//        Galeria token+15, Galeria aberta+25..55,
//        Carrinho abandonado+20
// ─────────────────────────────────────────────────────────────
function vm2_get_leads_para_aquecer( $args = [] ) {
    global $wpdb;
    $score_min  = (int)( $args['score_min'] ?? 0 );
    $limit      = (int)( $args['limit']     ?? 300 );
    $src_filter = $args['source'] ?? 'all';
    $use_cache  = isset($args['cache']) ? (bool)$args['cache'] : true;

    $cache_key = 'vm2_leads_aq_v2';
    if ( $use_cache ) {
        $cached = get_transient($cache_key);
        if ( $cached !== false ) {
            $out = $score_min > 0
                ? array_values( array_filter($cached, fn($l) => $l['score'] >= $score_min) )
                : array_values($cached);
            return array_slice($out, 0, $limit);
        }
    }

    $phones = [];

    // ── Source 1: Kommo leads ──
    if ( $src_filter === 'all' || $src_filter === 'kommo' ) {
        $rows = $wpdb->get_results(
            "SELECT phone, name, data_evento, status_id
             FROM {$wpdb->prefix}vm_kommo_leads
             WHERE phone != ''
             ORDER BY last_synced DESC LIMIT 1000"
        );
        foreach ( $rows as $r ) {
            $p = vm2_normalize_phone( $r->phone );
            if ( ! $p ) continue;
            if ( ! isset($phones[$p]) ) {
                $phones[$p] = [
                    'phone'       => $p,
                    'name'        => $r->name ?? '',
                    'data_evento' => $r->data_evento ?? '',
                    'status_id'   => $r->status_id,
                    'sources'     => ['kommo'],
                ];
            } else {
                if ( ! in_array('kommo', $phones[$p]['sources']) ) $phones[$p]['sources'][] = 'kommo';
                if ( empty($phones[$p]['name']) ) $phones[$p]['name'] = $r->name ?? '';
            }
        }
    }

    // ── Source 2: Galeria tokens (60 dias) ──
    if ( $src_filter === 'all' || $src_filter === 'galeria' ) {
        $rows = $wpdb->get_results(
            "SELECT t.whatsapp, a.nome AS atracao_nome
             FROM {$wpdb->prefix}vmgal_tokens t
             LEFT JOIN {$wpdb->prefix}vmgal_atracoes a ON FIND_IN_SET(a.id, t.atracao_ids)
             WHERE t.created_at >= DATE_SUB(NOW(), INTERVAL 60 DAY)
             ORDER BY t.created_at DESC LIMIT 400"
        );
        foreach ( $rows as $r ) {
            $p = vm2_normalize_phone( $r->whatsapp );
            if ( ! $p ) continue;
            if ( ! isset($phones[$p]) ) {
                $phones[$p] = [
                    'phone'          => $p,
                    'name'           => '',
                    'data_evento'    => '',
                    'status_id'      => null,
                    'sources'        => ['galeria'],
                    'galeria_atracao' => $r->atracao_nome ?? '',
                ];
            } else {
                if ( ! in_array('galeria', $phones[$p]['sources']) ) $phones[$p]['sources'][] = 'galeria';
            }
        }
    }

    // ── Source 3: Carrinho abandonado (60 dias) ──
    if ( $src_filter === 'all' || $src_filter === 'carrinho' ) {
        $rows = $wpdb->get_results(
            "SELECT phone, product_name
             FROM {$wpdb->prefix}vm_wa_captures
             WHERE status != 'bought'
             AND captured_at >= DATE_SUB(NOW(), INTERVAL 60 DAY)
             ORDER BY captured_at DESC LIMIT 300"
        );
        foreach ( $rows as $r ) {
            $p = vm2_normalize_phone( $r->phone );
            if ( ! $p ) continue;
            if ( ! isset($phones[$p]) ) {
                $phones[$p] = [
                    'phone'        => $p,
                    'name'         => '',
                    'data_evento'  => '',
                    'status_id'    => null,
                    'sources'      => ['carrinho'],
                    'cart_product' => $r->product_name ?? '',
                ];
            } else {
                if ( ! in_array('carrinho', $phones[$p]['sources']) ) $phones[$p]['sources'][] = 'carrinho';
                if ( empty($phones[$p]['cart_product']) ) $phones[$p]['cart_product'] = $r->product_name ?? '';
            }
        }
    }

    if ( empty($phones) ) return [];

    // ── Batch enrichment (2 queries, not N×phones) ──

    // Galeria: token + view count per last-11
    $galeria_map = [];
    $tok_rows = $wpdb->get_results(
        "SELECT RIGHT(t.whatsapp, 11) AS p11,
         a.nome AS atracao_nome,
         (SELECT COUNT(*) FROM {$wpdb->prefix}vmgal_views v
          WHERE v.token_id = t.id AND v.acao != 'cta_view') AS vc
         FROM {$wpdb->prefix}vmgal_tokens t
         LEFT JOIN {$wpdb->prefix}vmgal_atracoes a ON FIND_IN_SET(a.id, t.atracao_ids)
         WHERE t.created_at >= DATE_SUB(NOW(), INTERVAL 60 DAY)
         ORDER BY t.created_at DESC"
    );
    foreach ( $tok_rows as $r ) {
        if ( ! isset($galeria_map[$r->p11]) ) $galeria_map[$r->p11] = $r;
    }

    // Carrinho: latest abandoned product per last-11
    $cart_map = [];
    $cart_rows = $wpdb->get_results(
        "SELECT RIGHT(phone, 11) AS p11, product_name
         FROM {$wpdb->prefix}vm_wa_captures
         WHERE status != 'bought'
         AND captured_at >= DATE_SUB(NOW(), INTERVAL 60 DAY)
         ORDER BY captured_at DESC"
    );
    foreach ( $cart_rows as $r ) {
        if ( ! isset($cart_map[$r->p11]) ) $cart_map[$r->p11] = $r->product_name;
    }

    // ── Score each unique phone ──
    $results = [];
    foreach ( $phones as $phone => $base ) {
        $p11     = vm2_phone_last11($phone);
        $score   = 0;
        $signals = [];

        // Kommo
        if ( in_array('kommo', $base['sources']) ) {
            $score += 10;
            $signals[] = ['icon' => '💼', 'label' => 'Kommo', 'pts' => 10, 'src' => 'kommo'];
            if ( ! empty($base['data_evento']) ) {
                $ts   = strtotime($base['data_evento']);
                $days = ( $ts - time() ) / 86400;
                $pts  = 15;
                if      ( $days >= 0 && $days <=  7 ) $pts += 40;
                elseif  ( $days >= 0 && $days <= 30 ) $pts += 30;
                elseif  ( $days >= 0 && $days <= 90 ) $pts += 20;
                elseif  ( $days >= 0 )                $pts += 10;
                $score += $pts;
                $signals[] = ['icon' => '📅', 'label' => 'Evento ' . date('d/m/y', $ts), 'pts' => $pts, 'src' => 'kommo'];
            }
            if ( (int)( $base['status_id'] ?? 0 ) === 94305664 ) {
                $score += 25;
                $signals[] = ['icon' => '🔴', 'label' => 'HOT Kommo', 'pts' => 25, 'src' => 'kommo'];
            }
        }

        // Galeria (batch map)
        if ( isset($galeria_map[$p11]) ) {
            $gd = $galeria_map[$p11];
            $score += 15;
            $signals[] = ['icon' => '📸', 'label' => 'Galeria: ' . ( $gd->atracao_nome ?? '?' ), 'pts' => 15, 'src' => 'galeria'];
            $vc = (int)( $gd->vc ?? 0 );
            if ( $vc > 0 ) {
                $gpts = 25 + min(30, $vc * 5);
                $score += $gpts;
                $signals[] = ['icon' => '👁', 'label' => "Abriu ({$vc}x)", 'pts' => $gpts, 'src' => 'galeria'];
            }
        }

        // Carrinho (batch map)
        if ( isset($cart_map[$p11]) ) {
            $score += 20;
            $prod  = $cart_map[$p11] ? ': ' . mb_substr($cart_map[$p11], 0, 28) : '';
            $signals[] = ['icon' => '🛒', 'label' => "Carrinho{$prod}", 'pts' => 20, 'src' => 'carrinho'];
        }

        $score = min(100, max(0, $score));
        if ( $score < $score_min ) continue;
        $level = $score >= 60 ? 'hot' : ( $score >= 30 ? 'warm' : 'cold' );

        $results[] = array_merge($base, [
            'score'   => $score,
            'signals' => $signals,
            'level'   => $level,
            'p11'     => $p11,
        ]);
    }

    usort( $results, fn($a, $b) => $b['score'] - $a['score'] );
    $all_results = array_slice($results, 0, 500); // store up to 500 in cache

    if ( $use_cache ) {
        set_transient($cache_key, $all_results, 30 * MINUTE_IN_SECONDS);
    }

    $out = $score_min > 0
        ? array_values( array_filter($all_results, fn($l) => $l['score'] >= $score_min) )
        : array_values($all_results);
    return array_slice($out, 0, $limit);
}

function vm2_stage_label( $status_id ) {
    $map = [
        94305664 => [ '🔴', 'HOT',       'vm2-tag-hot'  ],
        94325167 => [ '✅', 'Contratou', 'vm2-tag-conv' ],
        142       => [ '❌', 'Perdido',  'vm2-tag-lost' ],
        143       => [ '🗑', 'Lixo',     'vm2-tag-lost' ],
    ];
    if ( isset( $map[ $status_id ] ) ) {
        [$icon, $label, $cls] = $map[ $status_id ];
        return "<span class='vm2-tag $cls'>$icon $label</span>";
    }
    return "<span class='vm2-tag'>📥 Lead</span>";
}

function vm2_contacts_page() {
    global $wpdb;
    $table = $wpdb->prefix . 'vm2_contacts';

    // Auto-sync se tabela vazia
    $total_all = (int) $wpdb->get_var("SELECT COUNT(*) FROM $table");
    if ($total_all === 0) vm2_sync_contacts();

    // === Params ===
    $search      = sanitize_text_field($_GET['s']       ?? '');
    $stage_f     = sanitize_text_field($_GET['stage']   ?? '');
    $source_f    = sanitize_text_field($_GET['source']  ?? '');
    $tipo_f      = sanitize_text_field($_GET['tipo']    ?? '');
    $score_f     = sanitize_text_field($_GET['score_f'] ?? '');
    $date_period = sanitize_text_field($_GET['dp']      ?? '');
    $date_from   = sanitize_text_field($_GET['df']      ?? '');
    $date_to     = sanitize_text_field($_GET['dt']      ?? '');
    $sort        = sanitize_text_field($_GET['sort']    ?? ($date_period ? 'evento' : 'activity'));
    $paged       = max(1, (int)($_GET['paged']          ?? 1));
    $per_page    = 25;
    $offset      = ($paged - 1) * $per_page;

    // === CSV Export ===
    if (!empty($_GET['export']) && $_GET['export'] === 'csv' && current_user_can('manage_options')) {
        // will build same WHERE below then export
    }

    // === Datas de referência ===
    $today      = wp_date('Y-m-d');
    $next7      = wp_date('Y-m-d', strtotime('+7 days'));
    $next15     = wp_date('Y-m-d', strtotime('+15 days'));
    $next30     = wp_date('Y-m-d', strtotime('+30 days'));
    $week_start = wp_date('Y-m-d', strtotime('monday this week'));
    $week_end   = wp_date('Y-m-d', strtotime('sunday this week'));
    $month_start= wp_date('Y-m-01');
    $month_end  = wp_date('Y-m-t');
    $past60     = wp_date('Y-m-d', strtotime('-60 days'));

    // === WHERE builder ===
    $where  = '1=1';
    $params = [];

    if ($search) {
        $like = '%' . $wpdb->esc_like($search) . '%';
        $where .= ' AND (c.name LIKE %s OR c.phone LIKE %s OR c.email LIKE %s OR c.galeria_atracao LIKE %s OR c.cart_product LIKE %s)';
        $params = array_merge($params, [$like,$like,$like,$like,$like]);
    }
    if ($stage_f === 'hot')         $where .= ' AND c.kommo_status_id = 94305664';
    elseif ($stage_f === 'conv')    $where .= ' AND c.kommo_status_id = 94325167';
    elseif ($stage_f === 'lost')    $where .= ' AND c.kommo_status_id IN (142,143)';
    elseif ($stage_f === 'nodate')  $where .= ' AND (c.data_evento IS NULL OR c.data_evento = "")';

    if ($source_f && in_array($source_f, ['kommo','galeria','carrinho','pedido','sofia'])) {
        $where .= ' AND c.origens LIKE %s';
        $params[] = '%"' . $source_f . '"%';
    }
    if ($tipo_f) { $where .= ' AND c.tipo_evento = %s'; $params[] = $tipo_f; }

    if ($score_f === 'hot')       $where .= ' AND c.score >= 70';
    elseif ($score_f === 'warm')  $where .= ' AND c.score >= 40 AND c.score < 70';
    elseif ($score_f === 'cold')  $where .= ' AND (c.score < 40 OR c.score = 0)';

    // Date period
    switch ($date_period) {
        case 'week':   $where .= ' AND c.data_evento >= %s AND c.data_evento <= %s'; $params[]=$week_start;  $params[]=$week_end;  break;
        case 'month':  $where .= ' AND c.data_evento >= %s AND c.data_evento <= %s'; $params[]=$month_start; $params[]=$month_end; break;
        case 'next15': $where .= ' AND c.data_evento >= %s AND c.data_evento <= %s'; $params[]=$today;       $params[]=$next15;    break;
        case 'next30': $where .= ' AND c.data_evento >= %s AND c.data_evento <= %s'; $params[]=$today;       $params[]=$next30;    break;
        case 'urgent': $where .= ' AND c.data_evento >= %s AND c.data_evento <= %s'; $params[]=$today;       $params[]=$next7;     break;
        case 'past':   $where .= ' AND c.data_evento >= %s AND c.data_evento < %s';  $params[]=$past60;      $params[]=$today;     break;
        case 'nodate': $where .= ' AND (c.data_evento IS NULL OR c.data_evento = "")'; break;
    }
    if (!$date_period) {
        if ($date_from) { $where .= ' AND c.data_evento >= %s'; $params[] = $date_from; }
        if ($date_to)   { $where .= ' AND c.data_evento <= %s'; $params[] = $date_to; }
    }

    // === Sort ===
    $order_by = match($sort) {
        'evento'     => 'c.data_evento ASC',
        'evento_d'   => 'c.data_evento DESC',
        'nome'       => 'c.name ASC',
        'nome_d'     => 'c.name DESC',
        'activity'   => 'COALESCE(c.last_activity, c.created_at) DESC',
        'activity_a' => 'COALESCE(c.last_activity, c.created_at) ASC',
        'wa'         => 'wa_count DESC',
        'wa_a'       => 'wa_count ASC',
        'score'      => 'c.score DESC',
        default      => 'COALESCE(c.last_activity, c.created_at) DESC',
    };

    // === Queries ===
    $base_sql  = "SELECT c.*,
        (SELECT COUNT(*) FROM {$wpdb->prefix}vm_warmup_log w WHERE w.lead_id = c.kommo_lead_id) as wa_count
        FROM $table c WHERE $where ORDER BY $order_by";
    $count_sql = "SELECT COUNT(*) FROM $table c WHERE $where";

    if ($params) {
        $total    = (int) $wpdb->get_var($wpdb->prepare($count_sql, ...$params));
        $contacts = $wpdb->get_results($wpdb->prepare("$base_sql LIMIT %d OFFSET %d", ...array_merge($params, [$per_page, $offset])));
    } else {
        $total    = (int) $wpdb->get_var($count_sql);
        $contacts = $wpdb->get_results($wpdb->prepare("$base_sql LIMIT %d OFFSET %d", $per_page, $offset));
    }

    // === CSV Export (after WHERE is built) ===
    if (!empty($_GET['export']) && $_GET['export'] === 'csv' && current_user_can('manage_options')) {
        $all_csv = $params
            ? $wpdb->get_results($wpdb->prepare("$base_sql LIMIT 5000", ...$params))
            : $wpdb->get_results($wpdb->prepare("$base_sql LIMIT 5000", 5000, 0));
        ob_end_clean();
        header('Content-Type: text/csv; charset=UTF-8');
        header('Content-Disposition: attachment; filename="contatos-vivamais-' . date('Y-m-d') . '.csv"');
        echo "\xEF\xBB\xBF"; // BOM UTF-8
        $out = fopen('php://output', 'w');
        fputcsv($out, ['Nome','Telefone','Email','Tipo Evento','Data Evento','Score','Origem','Estágio','Atração','Canal (utm_source)','Campanha (utm_campaign)','Última Atividade'], ';');
        foreach ($all_csv as $c) {
            $origens = implode(',', json_decode($c->origens, true) ?: []);
            fputcsv($out, [
                $c->name, $c->phone, $c->email, $c->tipo_evento, $c->data_evento,
                $c->score, $origens,
                ($c->kommo_status_id ? vm2_stage_label($c->kommo_status_id) : 'Lead'),
                ($c->galeria_atracao ?: $c->cart_product),
                ($c->utm_source ?? ''), ($c->utm_campaign ?? ''), // [v1.5.76]
                $c->last_activity,
            ], ';');
        }
        fclose($out);
        exit;
    }

    // === KPI counts ===
    $cnt_hot    = (int)$wpdb->get_var("SELECT COUNT(*) FROM $table WHERE score >= 70");
    $cnt_urgent = (int)$wpdb->get_var($wpdb->prepare("SELECT COUNT(*) FROM $table WHERE data_evento >= %s AND data_evento <= %s", $today, $next7));
    $cnt_next30 = (int)$wpdb->get_var($wpdb->prepare("SELECT COUNT(*) FROM $table WHERE data_evento > %s AND data_evento <= %s", $today, $next30));
    $cnt_nodate = (int)$wpdb->get_var("SELECT COUNT(*) FROM $table WHERE data_evento IS NULL OR data_evento = ''");
    $cnt_past   = (int)$wpdb->get_var($wpdb->prepare("SELECT COUNT(*) FROM $table WHERE data_evento >= %s AND data_evento < %s", $past60, $today));

    // === Source counts ===
    $cnt_kommo   = (int)$wpdb->get_var("SELECT COUNT(*) FROM $table WHERE origens LIKE '%\"kommo\"%'");
    $cnt_galeria  = (int)$wpdb->get_var("SELECT COUNT(*) FROM $table WHERE origens LIKE '%\"galeria\"%'");
    $cnt_carrinho = (int)$wpdb->get_var("SELECT COUNT(*) FROM $table WHERE origens LIKE '%\"carrinho\"%'");
    $cnt_pedido   = (int)$wpdb->get_var("SELECT COUNT(*) FROM $table WHERE origens LIKE '%\"pedido\"%'");
    $cnt_sofia    = (int)$wpdb->get_var("SELECT COUNT(*) FROM $table WHERE origens LIKE '%\"sofia\"%'");

    // === Tipos distintos ===
    $tipos = $wpdb->get_col("SELECT DISTINCT tipo_evento FROM $table WHERE tipo_evento != '' ORDER BY tipo_evento ASC LIMIT 40");

    $last_sync   = get_option('vm2_contacts_last_sync', '');
    $total_pages = max(1, ceil($total / $per_page));
    $nonce_val   = wp_create_nonce('vm2_contact_detail');
    $rest_nonce  = wp_create_nonce('wp_rest');

    // URL helpers
    $all_filters = array_filter(['s'=>$search,'stage'=>$stage_f,'source'=>$source_f,'tipo'=>$tipo_f,'score_f'=>$score_f,'dp'=>$date_period,'df'=>$date_from,'dt'=>$date_to,'sort'=>$sort]);
    $base_url    = add_query_arg(array_merge(['page'=>'vm2-contacts','paged'=>''], $all_filters), admin_url('admin.php'));
    $export_url  = add_query_arg(array_merge(['page'=>'vm2-contacts','export'=>'csv'], $all_filters), admin_url('admin.php'));
    $clear_url   = admin_url('admin.php?page=vm2-contacts');

    $_sf = array_filter(['s'=>$search,'source'=>$source_f,'tipo'=>$tipo_f,'score_f'=>$score_f,'dp'=>$date_period,'df'=>$date_from,'dt'=>$date_to]);
    $_su = function(string $key) use ($_sf): string {
        $p = array_merge($_sf, ['page'=>'vm2-contacts','sort'=>$key]);
        return esc_url(admin_url('admin.php').'?'.http_build_query($p));
    };
    $_arrow = function(string $a, string $d) use ($sort): string {
        if ($sort===$a) return ' <span style="color:#0073aa">↑</span>';
        if ($sort===$d) return ' <span style="color:#0073aa">↓</span>';
        return '';
    };

    // Active filter labels
    $active_labels = [];
    if ($search)      $active_labels[] = ['🔍 "' . esc_html($search) . '"', 's'];
    if ($stage_f)     $active_labels[] = ['🏷️ ' . ['hot'=>'HOT','conv'=>'Contratou','lost'=>'Perdido','nodate'=>'Sem data'][$stage_f] ?? $stage_f, 'stage'];
    if ($source_f)    $active_labels[] = ['📌 ' . ucfirst($source_f), 'source'];
    if ($tipo_f)      $active_labels[] = ['🎉 ' . esc_html($tipo_f), 'tipo'];
    if ($score_f)     $active_labels[] = ['⚡ Score ' . ucfirst($score_f), 'score_f'];
    $dp_labels = ['week'=>'Esta semana','month'=>'Este mês','next15'=>'Próx. 15d','next30'=>'Próx. 30d','urgent'=>'🔥 Urgente','past'=>'Já passou','nodate'=>'Sem data'];
    if ($date_period) $active_labels[] = ['📅 ' . ($dp_labels[$date_period] ?? $date_period), 'dp'];
    if ($date_from)   $active_labels[] = ['📅 De ' . esc_html($date_from), 'df'];
    if ($date_to)     $active_labels[] = ['📅 Até ' . esc_html($date_to), 'dt'];

    // Relative event date badge helper
    $ev_badge = function(string $ev_date) use ($today): string {
        if (!$ev_date) return '<span style="color:#ccc;font-size:11px">—</span>';
        $ts      = strtotime($ev_date);
        if (!$ts) return '<span style="font-size:11px">'.esc_html($ev_date).'</span>';
        $fmt     = date('d/m/Y', $ts);
        $diff    = (int)(($ts - strtotime($today)) / 86400);
        if ($diff === 0)
            return "<span style='font-weight:700;color:#d63638'>🔴 HOJE</span>";
        if ($diff > 0 && $diff <= 7)
            return "<span style='color:#d63638;font-weight:600;font-size:12px'>🔥 $fmt</span><br><span style='font-size:10px;color:#d63638'>em $diff dia".($diff>1?'s':'')."</span>";
        if ($diff > 7 && $diff <= 30)
            return "<span style='color:#c77700;font-weight:600;font-size:12px'>⚡ $fmt</span><br><span style='font-size:10px;color:#c77700'>em $diff dias</span>";
        if ($diff > 30)
            return "<span style='color:#2271b1;font-size:12px'>$fmt</span><br><span style='font-size:10px;color:#bbb'>em $diff dias</span>";
        // Past
        $ago = abs($diff);
        if ($ago <= 60)
            return "<span style='color:#888;font-size:12px'>$fmt</span><br><span style='font-size:10px;color:#aaa'>passou {$ago}d</span>";
        return "<span style='color:#ccc;font-size:11px'>$fmt</span>";
    };
    ?>
    <div class="wrap vm2-wrap">
    <style>
    .vm2-wrap{max-width:1360px;margin:0 auto;padding:20px 0}
    .vm2-page-header{display:flex;align-items:center;gap:10px;margin-bottom:14px;flex-wrap:wrap}
    .vm2-page-header h1{margin:0;font-size:22px;font-weight:700}
    /* KPI cards */
    .vm2c-kpis{display:grid;grid-template-columns:repeat(2,1fr);gap:10px;margin-bottom:14px}
    @media(min-width:600px){.vm2c-kpis{grid-template-columns:repeat(3,1fr)}}
    @media(min-width:900px){.vm2c-kpis{grid-template-columns:repeat(5,1fr)}}
    .vm2c-kpi{background:#fff;border-radius:10px;padding:14px 16px;box-shadow:0 1px 4px rgba(0,0,0,.07);cursor:pointer;text-decoration:none;display:flex;flex-direction:column;gap:4px;border:2px solid transparent;transition:.15s}
    .vm2c-kpi:hover{box-shadow:0 3px 10px rgba(0,0,0,.12);transform:translateY(-1px)}
    .vm2c-kpi.active{border-color:currentColor}
    .vm2c-kpi .kpi-val{font-size:26px;font-weight:800;line-height:1}
    .vm2c-kpi .kpi-lbl{font-size:11px;font-weight:600;text-transform:uppercase;letter-spacing:.4px;opacity:.75}
    .kpi-hot{color:#d63638}.kpi-urgent{color:#d63638}.kpi-next30{color:#c77700}.kpi-nodate{color:#57606a}.kpi-past{color:#888}
    /* Source pills */
    .vm2-source-bar{display:flex;gap:7px;flex-wrap:wrap;margin-bottom:10px}
    .vm2-source-btn{padding:5px 14px;border-radius:20px;font-size:12px;font-weight:600;text-decoration:none;border:2px solid transparent;transition:.15s;white-space:nowrap}
    .vm2-source-btn.all{background:#f0f4ff;color:#2271b1;border-color:#c8d8ff}
    .vm2-source-btn.kommo{background:#fff0f0;color:#d63638;border-color:#ffc8c8}
    .vm2-source-btn.galeria{background:#f0e8ff;color:#6b21a8;border-color:#d9b3ff}
    .vm2-source-btn.carrinho{background:#fff8e7;color:#c77700;border-color:#ffd97a}
    .vm2-source-btn.pedido{background:#e8f5e9;color:#2e7d32;border-color:#b2dfdb}
    .vm2-source-btn.sofia{background:#fdf0ff;color:#7c3aed;border-color:#d8b4fe}
    .vm2-source-btn.active{font-weight:800;box-shadow:0 1px 6px rgba(0,0,0,.13)}
    /* Filter bar */
    .vm2c-filter-bar{background:#fff;border-radius:10px;padding:14px 16px;box-shadow:0 1px 4px rgba(0,0,0,.07);margin-bottom:10px}
    .vm2c-filter-row{display:flex;gap:8px;flex-wrap:wrap;align-items:flex-end;margin-bottom:10px}
    .vm2c-filter-row:last-child{margin-bottom:0}
    .vm2c-field{display:flex;flex-direction:column;gap:3px}
    .vm2c-field label{font-size:10px;font-weight:700;text-transform:uppercase;color:#888;letter-spacing:.4px}
    .vm2c-field input,.vm2c-field select{padding:7px 10px;border:1px solid #d0d7de;border-radius:6px;font-size:13px;background:#fff}
    .vm2c-field input[type=search]{width:200px}
    .vm2c-field select{min-width:140px}
    /* Date period pills */
    .vm2c-dp-pills{display:flex;gap:6px;flex-wrap:wrap;align-items:center}
    .vm2c-dp-pill{padding:5px 12px;border-radius:20px;font-size:12px;font-weight:600;cursor:pointer;text-decoration:none;border:1.5px solid #d0d7de;color:#57606a;background:#f6f8fa;white-space:nowrap;transition:.12s}
    .vm2c-dp-pill:hover{background:#e8eaed}
    .vm2c-dp-pill.active{background:#2271b1;color:#fff;border-color:#2271b1}
    .vm2c-dp-pill.urgent{border-color:#ffc8c8;color:#d63638;background:#fff0f0}
    .vm2c-dp-pill.urgent.active{background:#d63638;color:#fff;border-color:#d63638}
    /* Active filter chips */
    .vm2c-active-filters{display:flex;gap:6px;flex-wrap:wrap;margin-bottom:10px;align-items:center}
    .vm2c-chip{display:inline-flex;align-items:center;gap:4px;padding:3px 10px;background:#e8f0fe;color:#1a56db;border-radius:20px;font-size:12px;font-weight:600}
    .vm2c-chip a{color:#1a56db;text-decoration:none;margin-left:2px;font-weight:700}
    /* Table */
    .vm2-contacts-table{width:100%;border-collapse:collapse;background:#fff;border-radius:10px;overflow:hidden;box-shadow:0 1px 4px rgba(0,0,0,.07)}
    .vm2-contacts-table th{background:#f6f8fa;padding:10px 12px;text-align:left;font-size:11px;color:#57606a;font-weight:700;border-bottom:1px solid #e8eaed;white-space:nowrap;text-transform:uppercase;letter-spacing:.3px}
    .vm2-contacts-table td{padding:10px 12px;border-bottom:1px solid #f0f0f0;font-size:13px;vertical-align:middle}
    .vm2-contacts-table tr:last-child td{border-bottom:none}
    .vm2-contacts-table tr:hover td{background:#f9fafb;cursor:pointer}
    .vm2-name{font-weight:600;color:#1d2327;font-size:13px}
    .vm2-phone{color:#57606a;font-size:11px}
    .vm2-tag{display:inline-block;padding:2px 7px;border-radius:4px;font-size:11px;font-weight:600;background:#f0f4ff;color:#2271b1}
    .vm2-tag-hot{background:#fff0f0;color:#d63638}
    .vm2-tag-conv{background:#e8f5e9;color:#2e7d32}
    .vm2-tag-lost{background:#f5f5f5;color:#888}
    .vm2-origin-badge{display:inline-block;padding:2px 6px;border-radius:4px;font-size:10px;font-weight:700;margin:1px}
    .ob-kommo{background:#fff0f0;color:#d63638}.ob-galeria{background:#f0e8ff;color:#6b21a8}
    .ob-carrinho{background:#fff8e7;color:#c77700}.ob-pedido{background:#e8f5e9;color:#2e7d32}.ob-sofia{background:#fdf0ff;color:#7c3aed}
    .vm2-actions a{color:#2271b1;text-decoration:none;font-size:13px;margin-right:4px}
    .vm2-actions a:hover{opacity:.7}
    .vm2-count-badge{background:#eef2ff;color:#2271b1;padding:2px 8px;border-radius:12px;font-size:12px;font-weight:600}
    .vm2c-score-hot{background:#fff0f0;color:#d63638;padding:2px 7px;border-radius:4px;font-size:11px;font-weight:700}
    .vm2c-score-warm{background:#fff8e7;color:#c77700;padding:2px 7px;border-radius:4px;font-size:11px;font-weight:700}
    .vm2c-score-cold{background:#f0f4ff;color:#2271b1;padding:2px 7px;border-radius:4px;font-size:11px;font-weight:700}
    .vm2c-tipo{display:inline-block;padding:2px 7px;background:#f0fdf4;color:#16a34a;border-radius:4px;font-size:11px;font-weight:600}
    .vm2-pagination{display:flex;gap:6px;align-items:center;justify-content:flex-end;margin-top:16px;flex-wrap:wrap}
    .vm2-pagination a,.vm2-pagination span{padding:5px 11px;border:1px solid #d0d7de;border-radius:5px;font-size:13px;text-decoration:none;color:#2271b1}
    .vm2-pagination span.current{background:#2271b1;color:#fff;border-color:#2271b1}
    .vm2-empty-state{text-align:center;padding:60px 20px;color:#57606a;background:#fff;border-radius:10px}
    .vm2-empty-state .vm2-empty-icon{font-size:48px;margin-bottom:12px}
    /* Modal */
    .vm2-modal-overlay{display:none;position:fixed;inset:0;background:rgba(0,0,0,.45);z-index:99999}
    .vm2-modal-overlay.open{display:flex;align-items:flex-start;justify-content:flex-end}
    .vm2-modal-panel{width:520px;max-width:100vw;height:100vh;background:#fff;overflow-y:auto;box-shadow:-4px 0 24px rgba(0,0,0,.18);display:flex;flex-direction:column}
    .vm2-modal-header{padding:20px 24px 16px;border-bottom:1px solid #e8eaed;display:flex;justify-content:space-between;align-items:center;position:sticky;top:0;background:#fff;z-index:1}
    .vm2-modal-body{padding:20px 24px;flex:1}
    .vm2-modal-close{background:none;border:none;font-size:22px;cursor:pointer;color:#57606a;line-height:1}
    .vm2-modal-actions{padding:16px 24px;border-top:1px solid #e8eaed;display:flex;gap:8px;flex-wrap:wrap}
    .vm2-modal-actions a{padding:8px 16px;border-radius:6px;font-size:13px;text-decoration:none;font-weight:600}
    .vm2-btn-wa{background:#25D366;color:#fff}
    .vm2-btn-kommo{background:#4a90e2;color:#fff}
    .vm2-btn-sm{padding:7px 14px;background:#2271b1;color:#fff;border:none;border-radius:6px;cursor:pointer;font-size:13px;text-decoration:none;display:inline-block}
    #vm2SyncBtn.syncing{opacity:.6;pointer-events:none}
    .vm2c-date-range{display:none;gap:8px;align-items:flex-end;flex-wrap:wrap;margin-top:8px}
    .vm2c-date-range.show{display:flex}
    @media(max-width:768px){
        .vm2-contacts-table{display:block;overflow-x:auto}
        .vm2-modal-panel{width:100vw}
        .vm2c-field input[type=search]{width:100%}
        .vm2-contacts-table th:nth-child(6),.vm2-contacts-table td:nth-child(6),
        .vm2-contacts-table th:nth-child(8),.vm2-contacts-table td:nth-child(8){display:none}
    }
    </style>

    <!-- Header -->
    <div class="vm2-page-header">
        <h1>👥 Contatos</h1>
        <span class="vm2-count-badge"><?php echo number_format($total_all); ?> unificados</span>
        <?php if ($last_sync): ?>
        <span style="font-size:12px;color:#888">Sync: <?php echo vm2_local_date('d/m H:i', $last_sync); ?></span>
        <?php endif; ?>
        <div style="margin-left:auto;display:flex;gap:8px;flex-wrap:wrap">
            <a href="<?php echo esc_url($export_url); ?>" class="vm2-btn-sm" style="background:#16a34a" title="Exportar contatos filtrados">📥 CSV</a>
            <button id="vm2SyncBtn" style="padding:7px 16px;background:#0d9488;color:#fff;border:none;border-radius:6px;cursor:pointer;font-size:13px;font-weight:600">
                🔄 Sync
            </button>
        </div>
    </div>

    <!-- KPI Cards -->
    <div class="vm2c-kpis">
        <?php
        $kpis = [
            ['🔥','HOT',"color:#d63638",'kpi-hot','score_f','hot',$cnt_hot,'Leads engajados'],
            ['⚡','Urgente',"color:#d63638",'kpi-urgent','dp','urgent',$cnt_urgent,'Evento em 7 dias'],
            ['📅','Próx. 30d',"color:#c77700",'kpi-next30','dp','next30',$cnt_next30,'Eventos este mês'],
            ['⚠️','Sem Data',"color:#57606a",'kpi-nodate','dp','nodate',$cnt_nodate,'Leads sem data'],
            ['🕐','Já Passou',"color:#888",'kpi-past','dp','past',$cnt_past,'Últ. 60 dias'],
        ];
        foreach ($kpis as [$icon, $title, $style, $cls, $param_key, $param_val, $cnt, $sub]):
            $is_active = (isset($_GET[$param_key]) && $_GET[$param_key] === $param_val);
            $kpi_url   = add_query_arg(['page'=>'vm2-contacts', $param_key=>$param_val,'paged'=>1], admin_url('admin.php'));
            $clear_kpi = add_query_arg(['page'=>'vm2-contacts', $param_key=>'','paged'=>1], admin_url('admin.php'));
        ?>
        <a href="<?php echo esc_url($is_active ? $clear_kpi : $kpi_url); ?>"
           class="vm2c-kpi <?php echo $cls; ?> <?php echo $is_active ? 'active' : ''; ?>"
           style="<?php echo $style; ?>" title="<?php echo esc_attr($sub); ?>">
            <div class="kpi-val"><?php echo number_format($cnt); ?></div>
            <div class="kpi-lbl"><?php echo $icon; ?> <?php echo $title; ?></div>
        </a>
        <?php endforeach; ?>
    </div>

    <!-- Source Pills -->
    <div class="vm2-source-bar">
        <?php
        $sources = [
            ['all','🌐 Todos','all',$total_all,''],
            ['kommo','🔥 Kommo','kommo',$cnt_kommo,'kommo'],
            ['galeria','📸 Galeria','galeria',$cnt_galeria,'galeria'],
            ['carrinho','🛒 Carrinho','carrinho',$cnt_carrinho,'carrinho'],
            ['pedido','📦 Pedido','pedido',$cnt_pedido,'pedido'],
            ['sofia','🧠 SofIA','sofia',$cnt_sofia,'sofia'],
        ];
        foreach ($sources as [$cls, $lbl, $val, $cnt, $sv]):
            $active_src = (!$sv && !$source_f) || ($sv && $source_f === $sv);
            $src_url = $sv
                ? add_query_arg(['page'=>'vm2-contacts','source'=>$sv,'paged'=>1], admin_url('admin.php'))
                : add_query_arg(['page'=>'vm2-contacts','source'=>'','paged'=>1], admin_url('admin.php'));
        ?>
        <a href="<?php echo esc_url($src_url); ?>"
           class="vm2-source-btn <?php echo $cls; ?> <?php echo $active_src ? 'active' : ''; ?>">
            <?php echo $lbl; ?> (<?php echo number_format($cnt); ?>)
        </a>
        <?php endforeach; ?>
    </div>

    <!-- Filter Bar -->
    <div class="vm2c-filter-bar">
        <form method="get" action="">
            <input type="hidden" name="page" value="vm2-contacts">
            <?php if ($source_f): ?><input type="hidden" name="source" value="<?php echo esc_attr($source_f); ?>"><?php endif; ?>
            <div class="vm2c-filter-row">
                <div class="vm2c-field">
                    <label>Busca</label>
                    <input type="search" name="s" value="<?php echo esc_attr($search); ?>" placeholder="Nome, tel., email, atração...">
                </div>
                <?php if (!empty($tipos)): ?>
                <div class="vm2c-field">
                    <label>Tipo de Evento</label>
                    <select name="tipo">
                        <option value="">Todos os tipos</option>
                        <?php foreach ($tipos as $t): ?>
                        <option value="<?php echo esc_attr($t); ?>" <?php selected($tipo_f, $t); ?>><?php echo esc_html($t); ?></option>
                        <?php endforeach; ?>
                    </select>
                </div>
                <?php endif; ?>
                <div class="vm2c-field">
                    <label>Score</label>
                    <select name="score_f">
                        <option value="">Todos</option>
                        <option value="hot"  <?php selected($score_f,'hot');  ?>>🔥 HOT (70+)</option>
                        <option value="warm" <?php selected($score_f,'warm'); ?>>⚡ WARM (40+)</option>
                        <option value="cold" <?php selected($score_f,'cold'); ?>>❄️ COLD</option>
                    </select>
                </div>
                <div class="vm2c-field">
                    <label>Estágio</label>
                    <select name="stage">
                        <option value="">Todos</option>
                        <option value="hot"    <?php selected($stage_f,'hot');    ?>>🔴 HOT Kommo</option>
                        <option value="conv"   <?php selected($stage_f,'conv');   ?>>✅ Contratou</option>
                        <option value="lost"   <?php selected($stage_f,'lost');   ?>>❌ Perdido</option>
                    </select>
                </div>
                <div class="vm2c-field">
                    <label>Ordenar</label>
                    <select name="sort">
                        <option value="activity" <?php selected($sort,'activity'); ?>>⏱ Última atividade</option>
                        <option value="evento"   <?php selected($sort,'evento');   ?>>📅 Evento ↑</option>
                        <option value="evento_d" <?php selected($sort,'evento_d'); ?>>📅 Evento ↓</option>
                        <option value="score"    <?php selected($sort,'score');    ?>>🔥 Score</option>
                        <option value="nome"     <?php selected($sort,'nome');     ?>>A–Z Nome</option>
                        <option value="wa"       <?php selected($sort,'wa');       ?>>💬 Mais WA</option>
                    </select>
                </div>
                <div style="display:flex;gap:6px;align-items:flex-end">
                    <button type="submit" class="vm2-btn-sm">Filtrar</button>
                    <?php if ($search || $stage_f || $tipo_f || $score_f || $date_period || $date_from || $date_to): ?>
                    <a href="<?php echo esc_url(add_query_arg(['page'=>'vm2-contacts','source'=>$source_f], admin_url('admin.php'))); ?>" class="vm2-btn-sm" style="background:#6e7781">✕</a>
                    <?php endif; ?>
                </div>
            </div>

            <!-- Date period pills -->
            <div>
                <div style="font-size:10px;font-weight:700;text-transform:uppercase;color:#888;letter-spacing:.4px;margin-bottom:6px">📅 Data do Evento</div>
                <div class="vm2c-dp-pills">
                    <?php
                    $dp_options = [
                        'urgent' => '🔥 Urgente (7d)',
                        'week'   => 'Esta semana',
                        'month'  => 'Este mês',
                        'next15' => 'Próx. 15 dias',
                        'next30' => 'Próx. 30 dias',
                        'past'   => 'Já passou',
                        'nodate' => '⚠️ Sem data',
                    ];
                    foreach ($dp_options as $dp_val => $dp_lbl):
                        $dp_active = ($date_period === $dp_val);
                        $dp_url = $dp_active
                            ? add_query_arg(['page'=>'vm2-contacts','dp'=>'','s'=>$search,'stage'=>$stage_f,'source'=>$source_f,'tipo'=>$tipo_f,'score_f'=>$score_f,'paged'=>1], admin_url('admin.php'))
                            : add_query_arg(['page'=>'vm2-contacts','dp'=>$dp_val,'s'=>$search,'stage'=>$stage_f,'source'=>$source_f,'tipo'=>$tipo_f,'score_f'=>$score_f,'paged'=>1], admin_url('admin.php'));
                    ?>
                    <a href="<?php echo esc_url($dp_url); ?>"
                       class="vm2c-dp-pill <?php echo $dp_val==='urgent'?'urgent':''; ?> <?php echo $dp_active?'active':''; ?>">
                        <?php echo $dp_lbl; ?>
                    </a>
                    <?php endforeach; ?>
                    <a href="#" id="vm2cToggleRange" class="vm2c-dp-pill <?php echo ($date_from||$date_to)?'active':''; ?>" onclick="event.preventDefault();var r=document.getElementById('vm2cDateRange');r.classList.toggle('show')">
                        📆 Intervalo
                    </a>
                </div>
                <div id="vm2cDateRange" class="vm2c-date-range <?php echo ($date_from||$date_to)?'show':''; ?>">
                    <div class="vm2c-field">
                        <label>De</label>
                        <input type="date" name="df" value="<?php echo esc_attr($date_from); ?>">
                    </div>
                    <div class="vm2c-field">
                        <label>Até</label>
                        <input type="date" name="dt" value="<?php echo esc_attr($date_to); ?>">
                    </div>
                    <div style="align-self:flex-end">
                        <button type="submit" class="vm2-btn-sm" style="background:#16a34a">Aplicar</button>
                    </div>
                </div>
            </div>
        </form>
    </div>

    <!-- Active filter chips -->
    <?php if (!empty($active_labels)): ?>
    <div class="vm2c-active-filters">
        <span style="font-size:11px;color:#888;font-weight:600">Filtros ativos:</span>
        <?php foreach ($active_labels as [$chip_label, $chip_key]):
            $remove_url = add_query_arg(array_merge(['page'=>'vm2-contacts','paged'=>1,$chip_key=>'']), admin_url('admin.php'));
        ?>
        <span class="vm2c-chip">
            <?php echo $chip_label; ?>
            <a href="<?php echo esc_url($remove_url); ?>" title="Remover filtro">×</a>
        </span>
        <?php endforeach; ?>
        <a href="<?php echo esc_url($clear_url); ?>" style="font-size:12px;color:#d63638;text-decoration:none">Limpar tudo</a>
    </div>
    <?php endif; ?>

    <!-- Results count -->
    <div style="font-size:13px;color:#57606a;margin-bottom:8px">
        <?php echo number_format($total); ?> contato<?php echo $total!=1?'s':''; ?> encontrado<?php echo $total!=1?'s':''; ?>
        <?php if ($total > $per_page): ?>
        · Página <?php echo $paged; ?> de <?php echo $total_pages; ?>
        <?php endif; ?>
    </div>

    <?php if (empty($contacts)): ?>
    <div class="vm2-empty-state">
        <div class="vm2-empty-icon">🔍</div>
        <p>Nenhum contato encontrado<?php echo $search ? ' para <strong>"' . esc_html($search) . '"</strong>' : ''; ?></p>
        <?php if (!empty($active_labels)): ?>
        <p><a href="<?php echo esc_url($clear_url); ?>">Limpar filtros</a></p>
        <?php endif; ?>
    </div>
    <?php else: ?>

    <?php
    $bulk_nonce = wp_create_nonce('vm2_bulk_aquecer');
    ?>
    <style>
    /* ── Bulk action bar ── */
    .vm2-bulk-bar{display:none;align-items:center;gap:10px;background:#1a1a2e;color:#fff;padding:10px 16px;border-radius:8px;margin-bottom:10px;flex-wrap:wrap}
    .vm2-bulk-bar.visible{display:flex}
    .vm2-bulk-count{font-weight:700;font-size:13px;flex:1}
    .vm2-bulk-btn{background:#FFD700;color:#1a1a2e;border:none;padding:6px 14px;border-radius:6px;font-size:12px;font-weight:700;cursor:pointer;transition:opacity .15s}
    .vm2-bulk-btn:hover{opacity:.85}
    .vm2-bulk-cancel{background:transparent;color:#aaa;border:none;font-size:12px;cursor:pointer;padding:4px 8px}
    /* ── Checkbox col ── */
    .vm2-cb-col{width:32px;text-align:center}
    .vm2-contacts-table .vm2-cb-col input[type=checkbox]{cursor:pointer;width:15px;height:15px}
    /* ── Sequências chips ── */
    .vm2-seq-chips{display:flex;flex-wrap:wrap;gap:3px}
    .vm2-seq-chip{display:inline-block;padding:2px 6px;border-radius:10px;color:#fff;font-size:10px;font-weight:700;white-space:nowrap}
    </style>

    <!-- Bulk Action Bar -->
    <div class="vm2-bulk-bar" id="vm2BulkBar">
        <span class="vm2-bulk-count" id="vm2BulkCount">0 selecionado(s)</span>
        <button class="vm2-bulk-btn" id="vm2BulkAquecer" data-nonce="<?php echo esc_attr($bulk_nonce); ?>">
            🔥 Adicionar a Aquecer
        </button>
        <button class="vm2-bulk-btn" style="background:#3b82f6" id="vm2BulkBydate" data-nonce="<?php echo esc_attr($bulk_nonce); ?>">
            📅 Fila Por Data
        </button>
        <button class="vm2-bulk-cancel" id="vm2BulkCancel">✕ Cancelar</button>
    </div>

    <table class="vm2-contacts-table">
        <thead>
            <tr>
                <th class="vm2-cb-col"><input type="checkbox" id="vm2SelectAll" title="Selecionar todos" style="cursor:pointer"></th>
                <th><a href="<?php echo $_su($sort==='nome'?'nome_d':'nome'); ?>" style="color:inherit;text-decoration:none">Contato<?php echo $_arrow('nome','nome_d'); ?></a></th>
                <th>Origem</th>
                <th>Canal</th>
                <th>Tipo Evento</th>
                <th><a href="<?php echo $_su($sort==='evento'?'evento_d':'evento'); ?>" style="color:inherit;text-decoration:none">Data Evento<?php echo $_arrow('evento','evento_d'); ?></a></th>
                <th>Estágio</th>
                <th><a href="<?php echo $_su($sort==='score'?'activity':'score'); ?>" style="color:inherit;text-decoration:none">Score<?php echo $_arrow('score','activity'); ?></a></th>
                <th style="min-width:120px">Atração</th>
                <th><a href="<?php echo $_su($sort==='wa'?'wa_a':'wa'); ?>" style="color:inherit;text-decoration:none">WA<?php echo $_arrow('wa_a','wa'); ?></a></th>
                <th title="Email capturado">📧</th>
                <th><a href="<?php echo $_su($sort==='activity_a'?'activity':'activity_a'); ?>" style="color:inherit;text-decoration:none">Atividade<?php echo $_arrow('activity_a','activity'); ?></a></th>
                <th style="min-width:80px">Sequências</th>
                <th>Ações</th>
            </tr>
        </thead>
        <tbody>
        <?php
        // ── Sequências: pré-carrega envios por telefone (últimos 30d) ──
        $contact_phones = array_map(fn($c) => $c->phone, $contacts);
        $seq_data = [];
        if (!empty($contact_phones)) {
            $ph_in = implode(',', array_fill(0, count($contact_phones), '%s'));
            $seq_rows = $wpdb->get_results($wpdb->prepare(
                "SELECT phone, module FROM {$wpdb->prefix}vm2_sends
                 WHERE phone IN ($ph_in)
                 AND sent_at > DATE_SUB(NOW(), INTERVAL 30 DAY)
                 GROUP BY phone, module",
                ...$contact_phones
            ));
            foreach ($seq_rows as $sr) {
                $seq_data[$sr->phone][] = $sr->module;
            }
        }
        $seq_chip_map = [
            'aquecer'      => ['🔥', '#e74c3c', 'Aquecer'],
            'auto_aquecer' => ['🤖', '#9b59b6', 'Auto'],
            'leads'        => ['🎯', '#e67e22', 'HOT'],
            'bydate'       => ['📅', '#3498db', 'Data'],
            'carrinho'     => ['🛒', '#27ae60', 'Cart'],
        ];

        $origin_labels = [
            'kommo'    => '<span class="vm2-origin-badge ob-kommo">🔥 Kommo</span>',
            'galeria'  => '<span class="vm2-origin-badge ob-galeria">📸 Galeria</span>',
            'carrinho' => '<span class="vm2-origin-badge ob-carrinho">🛒 Cart</span>',
            'pedido'   => '<span class="vm2-origin-badge ob-pedido">📦 Pedido</span>',
            'sofia'    => '<span class="vm2-origin-badge ob-sofia">🧠 SofIA</span>',
        ];
        foreach ($contacts as $c):
            $origens     = json_decode($c->origens, true) ?: [];
            $phone_clean = preg_replace('/\D/', '', $c->phone);
            $kommo_url   = $c->kommo_lead_id ? 'https://rleitemartins.kommo.com/leads/detail/' . $c->kommo_lead_id : '';
            $interest    = $c->galeria_atracao ?: $c->cart_product ?: '';
            $score       = (int)$c->score ?: vm2_lead_score((object)['status_id'=>$c->kommo_status_id,'data_evento'=>$c->data_evento], (int)$c->wa_count);
            $score_html  = $score >= 70
                ? '<span class="vm2c-score-hot">🔥 ' . $score . '</span>'
                : ($score >= 40
                    ? '<span class="vm2c-score-warm">⚡ ' . $score . '</span>'
                    : '<span class="vm2c-score-cold">❄️ ' . $score . '</span>');
            $last_fmt    = $c->last_activity ? vm2_local_date('d/m H:i', $c->last_activity) : '—';
            $tipo_html   = $c->tipo_evento ? '<span class="vm2c-tipo">' . esc_html($c->tipo_evento) . '</span>' : '<span style="color:#ccc;font-size:11px">—</span>';
        ?>
            <tr class="vm2-contact-row"
                data-id="<?php echo esc_attr($c->kommo_lead_id ?: 0); ?>"
                data-contact-id="<?php echo esc_attr($c->id); ?>"
                data-nonce="<?php echo esc_attr($nonce_val); ?>">
                <td class="vm2-cb-col" onclick="event.stopPropagation()">
                    <input type="checkbox" class="vm2-cb-row" value="<?php echo esc_attr($c->phone ?: ''); ?>">
                </td>
                <td>
                    <div class="vm2-name"><?php echo esc_html($c->name ?: '—'); ?></div>
                    <div class="vm2-phone"><?php echo esc_html($c->phone ?: '—'); ?></div>
                </td>
                <td><?php foreach ($origens as $o) echo $origin_labels[$o] ?? ''; ?></td>
                <td><?php
                    // [v1.5.76] UTM source/medium/campaign
                    $utm_src = $c->utm_source ?? '';
                    $utm_med = $c->utm_medium ?? '';
                    $utm_cam = $c->utm_campaign ?? '';
                    if ($utm_src) {
                        $tip = esc_attr(implode(' / ', array_filter([$utm_src, $utm_med, $utm_cam])));
                        $icon = $utm_src === 'facebook' ? '📘' : ($utm_src === 'google' ? '🔍' : ($utm_src === 'instagram' ? '📸' : ($utm_src === 'kommo' ? '🤖' : '🌐')));
                        echo '<span title="' . $tip . '" style="font-size:11px;background:#e8f0fe;color:#1a73e8;border-radius:4px;padding:2px 6px;cursor:default">' . $icon . ' ' . esc_html($utm_src) . '</span>';
                        if ($utm_cam) echo '<br><span style="font-size:10px;color:#888;display:block;max-width:100px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap" title="' . esc_attr($utm_cam) . '">' . esc_html($utm_cam) . '</span>';
                    } else { echo '<span style="color:#d1d5db;font-size:11px">—</span>'; }
                ?></td>
                <td><?php echo $tipo_html; ?></td>
                <td><?php echo $ev_badge($c->data_evento ?? ''); ?></td>
                <td><?php echo $c->kommo_status_id ? vm2_stage_label($c->kommo_status_id) : '<span style="color:#bbb;font-size:11px">—</span>'; ?></td>
                <td><?php echo $score_html; ?></td>
                <td style="font-size:11px;color:#57606a;max-width:140px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap" title="<?php echo esc_attr($interest); ?>"><?php echo esc_html($interest ?: '—'); ?></td>
                <td><span style="font-weight:600;color:<?php echo (int)$c->wa_count > 0 ? '#25D366' : '#bbb'; ?>"><?php echo (int)$c->wa_count; ?></span></td>
                <td title="<?php echo esc_attr($c->email ?: ''); ?>"><?php echo !empty($c->email) ? '<span style="color:#2271b1;font-size:12px" title="' . esc_attr($c->email) . '">✉️</span>' : '<span style="color:#e0e0e0;font-size:11px">—</span>'; ?></td>
                <td style="color:#57606a;font-size:11px;white-space:nowrap"><?php echo $last_fmt; ?></td>
                <td onclick="event.stopPropagation()">
                    <?php
                    $seq_chips_html = '';
                    if (!empty($seq_data[$c->phone])) {
                        foreach (array_unique($seq_data[$c->phone]) as $seq_mod) {
                            if (isset($seq_chip_map[$seq_mod])) {
                                [$ic, $col, $lb] = $seq_chip_map[$seq_mod];
                                $seq_chips_html .= '<span class="vm2-seq-chip" style="background:' . $col . '" title="' . esc_attr($lb) . '">' . $ic . ' ' . esc_html($lb) . '</span>';
                            }
                        }
                    }
                    echo $seq_chips_html ?: '<span style="color:#d1d5db;font-size:11px">—</span>';
                    ?>
                </td>
                <td class="vm2-actions" onclick="event.stopPropagation()">
                    <?php if ($phone_clean): ?>
                    <a href="https://wa.me/<?php echo esc_attr($phone_clean); ?>" target="_blank" title="WhatsApp">💬</a>
                    <?php endif; ?>
                    <?php if ($kommo_url): ?>
                    <a href="<?php echo esc_url($kommo_url); ?>" target="_blank" title="Ver no Kommo">🔗</a>
                    <?php endif; ?>
                </td>
            </tr>
        <?php endforeach; ?>
        </tbody>
    </table>

    <?php if ($total_pages > 1): ?>
    <div class="vm2-pagination">
        <span><?php echo $paged; ?>/<?php echo $total_pages; ?></span>
        <?php if ($paged > 1) echo '<a href="' . esc_url($base_url . ($paged-1)) . '">← Ant</a>'; ?>
        <?php for ($p = max(1,$paged-2); $p <= min($total_pages,$paged+2); $p++):
            if ($p===$paged) echo '<span class="current">'.$p.'</span>';
            else echo '<a href="'.esc_url($base_url.$p).'">'.$p.'</a>';
        endfor; ?>
        <?php if ($paged < $total_pages) echo '<a href="' . esc_url($base_url . ($paged+1)) . '">Próx →</a>'; ?>
    </div>
    <?php endif; ?>
    <?php endif; ?>

    <!-- Modal de detalhe do contato -->
    <div class="vm2-modal-overlay" id="vm2ContactModal">
        <div class="vm2-modal-panel">
            <div class="vm2-modal-header">
                <div>
                    <div style="font-size:16px;font-weight:700" id="vm2ModalName">—</div>
                    <div style="font-size:12px;color:#57606a" id="vm2ModalPhone"></div>
                </div>
                <button class="vm2-modal-close" id="vm2ModalClose">✕</button>
            </div>
            <div class="vm2-modal-body" id="vm2ModalBody">
                <div style="text-align:center;padding:40px;color:#57606a">Carregando...</div>
            </div>
            <div class="vm2-modal-actions" id="vm2ModalActions"></div>
        </div>
    </div>

    <script>
    (function(){
        var modal = document.getElementById('vm2ContactModal');
        document.getElementById('vm2ModalClose').addEventListener('click', function(){
            modal.classList.remove('open');
        });
        modal.addEventListener('click', function(e){ if(e.target===modal) modal.classList.remove('open'); });

        document.querySelectorAll('.vm2-contact-row').forEach(function(row){
            row.addEventListener('click', function(){
                var id    = row.dataset.id;
                var nonce = row.dataset.nonce;
                var name  = row.querySelector('.vm2-name').textContent;
                var phone = row.querySelector('.vm2-phone').textContent;
                document.getElementById('vm2ModalName').textContent  = name;
                document.getElementById('vm2ModalPhone').textContent = phone;
                document.getElementById('vm2ModalBody').innerHTML    = '<div style="text-align:center;padding:40px;color:#57606a">⏳ Carregando ficha...</div>';
                document.getElementById('vm2ModalActions').innerHTML = '';
                modal.classList.add('open');
                if (!id || id === '0') {
                    document.getElementById('vm2ModalBody').innerHTML = '<p style="color:#888;padding:20px">Contato sem Kommo ID — detalhes em breve.</p>';
                    return;
                }
                var fd = new FormData();
                fd.append('action','vm2_contact_detail');
                fd.append('nonce', nonce);
                fd.append('kommo_id', id);
                fetch(ajaxurl, {method:'POST', body:fd})
                    .then(r=>r.json())
                    .then(function(res){
                        if(res.success){
                            document.getElementById('vm2ModalBody').innerHTML    = res.data.html;
                            document.getElementById('vm2ModalActions').innerHTML = res.data.actions;
                        } else {
                            document.getElementById('vm2ModalBody').innerHTML = '<p style="color:red">Erro ao carregar contato.</p>';
                        }
                    });
            });
        });

        // Botão Sync
        var syncBtn = document.getElementById('vm2SyncBtn');
        if (syncBtn) {
            syncBtn.addEventListener('click', function(){
                syncBtn.textContent = '⏳ Sync...';
                syncBtn.classList.add('syncing');
                fetch('<?php echo esc_js(rest_url('vm-crm-v2/v1/contacts/sync')); ?>', {
                    method: 'POST',
                    headers: {'X-WP-Nonce': '<?php echo esc_js($rest_nonce); ?>'}
                })
                .then(r=>r.json())
                .then(function(res){
                    if (res.ok) {
                        var r = res.result;
                        syncBtn.textContent = '✅ ' + r.total + ' (' + r.new + ' novos)';
                        setTimeout(function(){ location.reload(); }, 1200);
                    } else {
                        syncBtn.textContent = '❌ Erro';
                        syncBtn.classList.remove('syncing');
                    }
                })
                .catch(function(){
                    syncBtn.textContent = '❌ Erro';
                    syncBtn.classList.remove('syncing');
                });
            });
        }
    })();
    <script>
    (function(){
        var selectAll = document.getElementById('vm2SelectAll');
        var bulkBar   = document.getElementById('vm2BulkBar');
        var bulkCount = document.getElementById('vm2BulkCount');
        if (!selectAll) return;

        function getChecked() {
            return Array.from(document.querySelectorAll('.vm2-cb-row:checked'));
        }
        function updateBar() {
            var checked = getChecked();
            if (checked.length > 0) {
                bulkBar.classList.add('visible');
                bulkCount.textContent = checked.length + ' selecionado(s)';
            } else {
                bulkBar.classList.remove('visible');
            }
        }
        selectAll.addEventListener('change', function() {
            document.querySelectorAll('.vm2-cb-row').forEach(function(cb){ cb.checked = selectAll.checked; });
            updateBar();
        });
        document.querySelectorAll('.vm2-cb-row').forEach(function(cb){
            cb.addEventListener('change', updateBar);
        });
        document.getElementById('vm2BulkCancel').addEventListener('click', function(){
            document.querySelectorAll('.vm2-cb-row').forEach(function(cb){ cb.checked = false; });
            selectAll.checked = false;
            updateBar();
        });
        function bulkAction(module) {
            var phones = getChecked().map(function(cb){ return cb.value; }).filter(Boolean);
            if (!phones.length) { alert('Selecione ao menos um contato.'); return; }
            var label = module === 'aquecer' ? 'Aquecer D+X' : 'Por Data';
            if (!confirm('Adicionar ' + phones.length + ' contato(s) à fila de ' + label + '?

(Remove cooldown recente e os inclui no próximo disparo)')) return;
            var btn = document.getElementById(module === 'aquecer' ? 'vm2BulkAquecer' : 'vm2BulkBydate');
            var nonce = btn.dataset.nonce;
            var body = new URLSearchParams({ action: 'vm2_bulk_aquecer', nonce: nonce, module: module });
            phones.forEach(function(p){ body.append('phones[]', p); });
            btn.disabled = true;
            btn.textContent = '⏳ Processando...';
            fetch(ajaxurl, { method: 'POST', headers: {'Content-Type': 'application/x-www-form-urlencoded'}, body: body.toString() })
            .then(function(r){ return r.json(); })
            .then(function(data){
                if (data.success) {
                    alert('✅ ' + data.data.msg);
                    document.querySelectorAll('.vm2-cb-row').forEach(function(cb){ cb.checked = false; });
                    selectAll.checked = false;
                    updateBar();
                } else {
                    alert('❌ Erro: ' + (data.data ? data.data.msg : 'Desconhecido'));
                }
            })
            .catch(function(){ alert('❌ Erro de rede.'); })
            .finally(function(){
                btn.disabled = false;
                btn.textContent = module === 'aquecer' ? '🔥 Adicionar a Aquecer' : '📅 Fila Por Data';
            });
        }
        document.getElementById('vm2BulkAquecer').addEventListener('click', function(){ bulkAction('aquecer'); });
        document.getElementById('vm2BulkBydate').addEventListener('click', function(){ bulkAction('bydate'); });
    })();
    </script>
    </div>
    <?php
}


// AJAX — Detalhe do Contato
add_action( 'wp_ajax_vm2_contact_detail', 'vm2_ajax_contact_detail' );
function vm2_ajax_contact_detail() {
    check_ajax_referer( 'vm2_contact_detail', 'nonce' );
    if ( ! current_user_can( 'manage_options' ) ) wp_die();

    global $wpdb;
    $kommo_id = absint( $_POST['kommo_id'] ?? 0 );
    if ( ! $kommo_id ) wp_send_json_error();

    $lead = $wpdb->get_row( $wpdb->prepare(
        "SELECT *, data_evento as ev_date FROM {$wpdb->prefix}vm_kommo_leads WHERE kommo_id = %d LIMIT 1",
        $kommo_id
    ) );
    if ( ! $lead ) wp_send_json_error( ['msg'=>'Lead não encontrado'] );

    // WA sends
    $wa_logs = $wpdb->get_results( $wpdb->prepare(
        "SELECT * FROM {$wpdb->prefix}vm_warmup_log WHERE lead_id = %d ORDER BY sent_at DESC LIMIT 20",
        $kommo_id
    ) );
    $wa_count = count( $wa_logs );

    // WooCommerce orders by phone
    $phone_clean = preg_replace( '/\D/', '', $lead->phone ?? '' );
    $wc_orders   = [];
    if ( $phone_clean && strlen($phone_clean) >= 8 ) {
        $phone_suffix = substr( $phone_clean, -9 );
        // Try HPOS first (wc_orders + wc_orders_addresses)
        $wc_table = $wpdb->prefix . 'wc_orders';
        if ( $wpdb->get_var("SHOW TABLES LIKE '$wc_table'") === $wc_table ) {
            $wc_orders = $wpdb->get_results( $wpdb->prepare(
                "SELECT o.id, o.status, o.total_amount, o.date_created_gmt, oa.phone
                 FROM {$wpdb->prefix}wc_orders o
                 LEFT JOIN {$wpdb->prefix}wc_orders_addresses oa ON oa.order_id = o.id AND oa.address_type = 'billing'
                 WHERE oa.phone LIKE %s
                 ORDER BY o.date_created_gmt DESC LIMIT 10",
                '%' . $phone_suffix
            ) );
        }
        // Fallback: postmeta (legacy)
        if ( empty($wc_orders) ) {
            $wc_orders = $wpdb->get_results( $wpdb->prepare(
                "SELECT p.ID as id, p.post_status as status, pm2.meta_value as total_amount, p.post_date as date_created_gmt
                 FROM {$wpdb->prefix}posts p
                 JOIN {$wpdb->prefix}postmeta pm ON pm.post_id = p.ID AND pm.meta_key = '_billing_phone' AND pm.meta_value LIKE %s
                 LEFT JOIN {$wpdb->prefix}postmeta pm2 ON pm2.post_id = p.ID AND pm2.meta_key = '_order_total'
                 WHERE p.post_type = 'shop_order'
                 ORDER BY p.post_date DESC LIMIT 10",
                '%' . $phone_suffix
            ) );
        }
    }

    $score    = vm2_lead_score( $lead, $wa_count );
    $ev_date  = $lead->ev_date ?? '';
    $ev_fmt   = $ev_date ? ( strtotime($ev_date) ? date('d/m/Y', strtotime($ev_date)) : $ev_date ) : '—';
    $created  = $lead->created_at_kommo ?? $lead->last_synced ?? '';
    $nut_stat = $lead->nurturing_status ?? 'pending';
    $kommo_url = 'https://rleitemartins.kommo.com/leads/detail/' . $lead->kommo_id;
    $phone_wa  = preg_replace('/\D/','',$lead->phone??'');

    // [v1.5.93] Email do contato (vm2_contacts)
    $contact_email = '';
    if ( $phone_wa ) {
        $ct_row = $wpdb->get_row($wpdb->prepare(
            "SELECT email FROM {$wpdb->prefix}vm2_contacts WHERE phone = %s LIMIT 1",
            $phone_wa
        ));
        $contact_email = $ct_row->email ?? '';
    }

    $ltv = 0;
    foreach ($wc_orders as $ord) { $ltv += (float)$ord->total_amount; }

    ob_start();
    ?>
    <div class="vm2-detail-grid">
        <div class="vm2-field"><label>Score</label><?php echo vm2_score_badge($score); ?></div>
        <div class="vm2-field"><label>Estágio</label><?php echo vm2_stage_label($lead->status_id); ?></div>
        <div class="vm2-field"><label>Data do Evento</label><?php echo esc_html($ev_fmt); ?></div>
        <div class="vm2-field"><label>Nurturing</label><code style="font-size:11px"><?php echo esc_html($nut_stat); ?></code></div>
        <div class="vm2-field"><label>Kommo ID</label><span style="font-size:12px;color:#57606a"><?php echo esc_html($lead->kommo_id); ?></span></div>
        <div class="vm2-field"><label>Lead criado</label><span style="font-size:12px;color:#57606a"><?php echo $created ? vm2_local_date('d/m/Y', $created) : '—'; ?></span></div>
        <div class="vm2-field" style="grid-column:span 2">
            <label>📧 Email</label>
            <?php if ($contact_email): ?>
            <span style="font-size:12px;color:#2271b1"><?php echo esc_html($contact_email); ?></span>
            <?php else: ?>
            <span style="color:#bbb;font-size:11px">— não capturado</span>
            <?php endif; ?>
        </div>
        <?php if ($ltv > 0): ?>
        <div class="vm2-field" style="grid-column:span 2"><label>LTV (WooCommerce)</label><strong style="color:#2e7d32">R$ <?php echo number_format($ltv,2,',','.'); ?></strong><?php echo ' — ' . count($wc_orders) . ' pedido(s)'; ?></div>
        <?php endif; ?>
    </div>

    <div class="vm2-timeline">
        <h4>📋 Timeline</h4>

        <?php if ($created): ?>
        <div class="vm2-tl-item">
            <div class="vm2-tl-icon">📥</div>
            <div class="vm2-tl-content">
                <div class="vm2-tl-title">Lead criado no Kommo</div>
                <div class="vm2-tl-time"><?php echo vm2_local_date('d/m/Y H:i', $created); ?></div>
            </div>
        </div>
        <?php endif; ?>

        <?php foreach ($wc_orders as $ord):
            $status_icon = in_array($ord->status, ['wc-processing','processing','wc-signing-pending','signing-pending','wc-contract-signed','contract-signed']) ? '✅' : ( in_array($ord->status,['wc-completed','completed']) ? '🏆' : '🛒' );
            $total_fmt   = number_format((float)$ord->total_amount, 2, ',', '.');
            $order_date  = vm2_local_date('d/m/Y H:i', $ord->date_created_gmt);
        ?>
        <div class="vm2-tl-item">
            <div class="vm2-tl-icon"><?php echo $status_icon; ?></div>
            <div class="vm2-tl-content">
                <div class="vm2-tl-title">Pedido #<?php echo esc_html($ord->id); ?> — R$ <?php echo $total_fmt; ?></div>
                <div class="vm2-tl-time"><?php echo $order_date; ?> · <?php echo esc_html($ord->status); ?></div>
            </div>
        </div>
        <?php endforeach; ?>

        <?php foreach ($wa_logs as $wa):
            $grp_labels = ['d1'=>'D+1','d7'=>'D+7','d15'=>'D+15','d30'=>'D+30','hot'=>'HOT','event_week'=>'Esta Semana','event_quinzena'=>'Quinzena','event_mes'=>'Mês','event_past'=>'Passado'];
            $grp_label  = $grp_labels[$wa->group_key] ?? esc_html($wa->group_key ?? 'Aquecer');
            $msg_short  = mb_substr($wa->message ?? '', 0, 60);
            if (mb_strlen($wa->message??'') > 60) $msg_short .= '…';
        ?>
        <div class="vm2-tl-item">
            <div class="vm2-tl-icon">📨</div>
            <div class="vm2-tl-content">
                <div class="vm2-tl-title">WA enviado — <?php echo $grp_label; ?></div>
                <div class="vm2-tl-time"><?php echo vm2_local_date('d/m/Y H:i', $wa->sent_at); ?></div>
                <?php if ($msg_short): ?>
                <div style="font-size:11px;color:#57606a;margin-top:2px;font-style:italic">"<?php echo esc_html($msg_short); ?>"</div>
                <?php endif; ?>
            </div>
        </div>
        <?php endforeach; ?>

        <?php if ( empty($wa_logs) && empty($wc_orders) && !$created ): ?>
        <p style="color:#57606a;font-size:13px">Nenhuma interação registrada ainda.</p>
        <?php endif; ?>
    </div>
    <?php
    $html = ob_get_clean();

    $actions_html = '';
    $actions_html .= '<a class="vm2-btn-kommo" href="' . esc_url($kommo_url) . '" target="_blank">🔗 Kommo</a>';
    if ($phone_wa) {
        $actions_html .= '<a class="vm2-btn-wa" href="https://wa.me/' . esc_attr($phone_wa) . '" target="_blank">💬 WhatsApp</a>';
    }
    if ($contact_email) {
        $actions_html .= '<a class="vm2-btn-sm" href="mailto:' . esc_attr($contact_email) . '" style="background:#0079d3" target="_blank">📧 Email</a>';
    }

    wp_send_json_success(['html'=>$html,'actions'=>$actions_html]);
}


// ============================================================
// MODULE: Automações (8 tabs)
// ============================================================

// ─── Helper: Test Send Box ────────────────────────────────────────────────
function vm2_render_test_box( $box_id, $channel_key, $default_msg = '', $default_template = '' ) {
    $nonce    = wp_create_nonce( 'vm2_test_send' );
    $channels = vm2_channels();
    $is_waba  = isset($channels[$channel_key]) && $channels[$channel_key]['type'] === 'waba';
    ?>
    <div style="background:#f0f7ff;border:1px dashed #0079d3;border-radius:8px;padding:12px 14px;margin-top:14px">
        <strong style="font-size:13px;color:#0079d3">🧪 Testar Envio</strong>
        <div style="display:flex;gap:10px;align-items:flex-end;flex-wrap:wrap;margin-top:8px">
            <div style="flex:0 0 180px;min-width:140px">
                <label style="font-size:12px;display:block;margin-bottom:3px;font-weight:600">📱 Celular destino</label>
                <input type="text" id="vm2tb_<?php echo esc_attr($box_id); ?>_phone"
                       placeholder="5511999887766"
                       style="width:100%;padding:6px 8px;border:1px solid #b0c4d8;border-radius:6px;font-size:13px">
            </div>
            <?php if ($is_waba): ?>
            <div style="flex:2;min-width:180px">
                <label style="font-size:12px;display:block;margin-bottom:3px;font-weight:600">📋 Template WABA</label>
                <select id="vm2tb_<?php echo esc_attr($box_id); ?>_tmpl"
                        style="width:100%;padding:6px 8px;border:1px solid #b0c4d8;border-radius:6px;font-size:13px">
                    <?php echo vm2_waba_template_options_html($default_template); ?>
                </select>
            </div>
            <?php else: ?>
            <div style="flex:2;min-width:180px">
                <label style="font-size:12px;display:block;margin-bottom:3px;font-weight:600">💬 Mensagem</label>
                <textarea id="vm2tb_<?php echo esc_attr($box_id); ?>_msg" rows="2"
                          style="width:100%;padding:6px 8px;border:1px solid #b0c4d8;border-radius:6px;font-size:12px;resize:vertical"><?php echo esc_textarea($default_msg); ?></textarea>
            </div>
            <?php endif; ?>
            <div style="flex:0 0 auto;display:flex;flex-direction:column;gap:4px">
                <button type="button"
                        onclick="vm2TestBox('<?php echo esc_js($box_id); ?>','<?php echo esc_js($channel_key); ?>','<?php echo esc_js($nonce); ?>',<?php echo $is_waba ? 'true' : 'false'; ?>)"
                        style="background:#0079d3;color:#fff;border:none;padding:8px 16px;border-radius:6px;cursor:pointer;font-size:13px;white-space:nowrap">
                    ▶️ Enviar Teste
                </button>
                <div id="vm2tb_<?php echo esc_attr($box_id); ?>_result" style="font-size:12px;min-height:16px"></div>
            </div>
        </div>
    </div>
    <?php
}

function vm2_automacoes_page() {
    global $wpdb;

    // Handle form save
    if ( isset($_POST['vm2_auto_save']) && check_admin_referer('vm2_auto_save') ) {
        $bool_opts = ['vm2_aquecer_kill','vm2_aquecer_channel',
                      'vm2_aquecer_d1_on','vm2_aquecer_d1_template','vm2_aquecer_d1_msg',
                      'vm2_aquecer_d7_on','vm2_aquecer_d7_template','vm2_aquecer_d7_msg',
                      'vm2_aquecer_d15_on','vm2_aquecer_d15_template','vm2_aquecer_d15_msg',
                      'vm2_aquecer_d30_on','vm2_aquecer_d30_template','vm2_aquecer_d30_msg',
                      'vm2_bydate_kill','vm2_bydate_channel',
                      'vm2_auto_aquecer_on','vm2_auto_aquecer_threshold',
                      'vm2_auto_aquecer_channel','vm2_auto_aquecer_template',
                      'vm2_auto_aquecer_cooldown','vm2_auto_aquecer_batch','vm2_auto_aquecer_msg',
                      'vm2_auto_aquecer_email_on','vm2_auto_aquecer_email_subject','vm2_auto_aquecer_email_body',
                      'vm2_hot_on','vm2_hot_kill','vm2_hot_channel','vm2_hot_template',
                      'vm2_hot_cooldown','vm2_hot_batch','vm2_hot_msg',
                      'vm2_hot_email_on','vm2_hot_email_subject','vm2_hot_email_body',
                       'vm2_bydate_email_on','vm2_bydate_email_subject','vm2_bydate_email_body'];
        foreach ($bool_opts as $opt) {
            update_option($opt, isset($_POST[$opt]) ? sanitize_textarea_field($_POST[$opt]) : '0');
        }
        foreach (['semana','quinzena','mes','tres_meses','seis_meses','depois','passado'] as $g) {
            foreach (['on','template','msg'] as $f) {
                $k = "vm2_bydate_{$g}_{$f}";
                update_option($k, isset($_POST[$k]) ? sanitize_textarea_field($_POST[$k]) : '0');
            }
        }
        echo '<div class="notice notice-success is-dismissible"><p>✅ Configurações salvas com sucesso.</p></div>';
    }

    $active_tab = isset($_GET['tab']) ? sanitize_key($_GET['tab']) : 'aquecer';

    // Settings
    $a_kill    = get_option('vm2_aquecer_kill', '1');
    $a_channel = get_option('vm2_aquecer_channel', 'zapi_7551');
    $bd_kill   = get_option('vm2_bydate_kill', '1');
    $bd_ch     = get_option('vm2_bydate_channel', 'zapi_7551');

    $waba_tpls = vm2_waba_templates_list();

    $steps = [
        'd1'  => ['label'=>'D+1',  'delay'=>1,  'default_tmpl'=>'vm_pos_janela_d3', 'default_msg'=>"Oi {nome}! 👋 Vi que você ainda está pesquisando atrações para sua festa. Posso te ajudar a encontrar a opção perfeita? 🎉"],
        'd7'  => ['label'=>'D+7',  'delay'=>7,  'default_tmpl'=>'5d_waba_gg939i',   'default_msg'=>"Oi {nome}! 🌟 Ainda estamos com sua data disponível. Que tal garantir agora? 👇"],
        'd15' => ['label'=>'D+15', 'delay'=>15, 'default_tmpl'=>'15d_waba_qlwlek',  'default_msg'=>"Oi {nome}! 🎪 Sua festa merece o melhor! Ainda temos disponibilidade. Vamos fechar?"],
        'd30' => ['label'=>'D+30', 'delay'=>30, 'default_tmpl'=>'30d_waba_h2turh',  'default_msg'=>"Oi {nome}! 💫 Faz um mês desde nosso último contato. Ainda posso ajudar com sua festa? 🥳"],
    ];

    // Count eligible per step from warmup_log
    $step_counts = [];
    foreach ($steps as $skey => $step) {
        $prev_d = $step['delay'] - 1;
        $next_d = $step['delay'] + 6;
        $cnt = $wpdb->get_var($wpdb->prepare(
            "SELECT COUNT(DISTINCT l.lead_id)
             FROM {$wpdb->prefix}kommo_leads l
             WHERE l.stage NOT IN ('lost','won','contratou')
               AND l.phone IS NOT NULL AND l.phone != ''
               AND NOT EXISTS (
                   SELECT 1 FROM {$wpdb->prefix}warmup_log wl
                   WHERE wl.lead_id = l.lead_id AND wl.group_key = %s
               )
               AND l.last_synced >= NOW() - INTERVAL %d DAY
               AND l.last_synced <  NOW() - INTERVAL %d DAY",
            $skey, $next_d, $prev_d
        ));
        $step_counts[$skey] = (int)$cnt;
    }

    // By-date groups
    $bd_groups = [
        'semana'     => ['label'=>'🔴 Esta semana', 'color'=>'#dc3545', 'df'=>0,    'dt'=>7,    'tmpl'=>'vm_pos_janela_d3'],
        'quinzena'   => ['label'=>'🟠 Quinzena',    'color'=>'#fd7e14', 'df'=>8,    'dt'=>14,   'tmpl'=>'5d_waba_gg939i'],
        'mes'        => ['label'=>'🟡 Mês',          'color'=>'#ffc107', 'df'=>15,   'dt'=>30,   'tmpl'=>'15d_waba_qlwlek'],
        'tres_meses' => ['label'=>'🟢 3 meses',      'color'=>'#28a745', 'df'=>31,   'dt'=>90,   'tmpl'=>'30d_waba_h2turh'],
        'seis_meses' => ['label'=>'🔵 6 meses',      'color'=>'#007bff', 'df'=>91,   'dt'=>180,  'tmpl'=>'30d_waba_h2turh'],
        'depois'     => ['label'=>'⚪ Depois',        'color'=>'#6c757d', 'df'=>181,  'dt'=>9999, 'tmpl'=>''],
        'passado'    => ['label'=>'⬛ Passado',       'color'=>'#343a40', 'df'=>-9999,'dt'=>-1,   'tmpl'=>'cartaopresente'],
    ];

    $bd_counts = [];
    foreach ($bd_groups as $gkey => $g) {
        if ($gkey === 'passado') {
            $cnt = $wpdb->get_var(
                "SELECT COUNT(*) FROM {$wpdb->prefix}kommo_leads
                 WHERE STR_TO_DATE(data_evento,'%d/%m/%Y') < CURDATE()
                   AND data_evento REGEXP '^[0-9]{2}/[0-9]{2}/[0-9]{4}$'"
            );
        } else {
            $cnt = $wpdb->get_var($wpdb->prepare(
                "SELECT COUNT(*) FROM {$wpdb->prefix}kommo_leads
                 WHERE STR_TO_DATE(data_evento,'%%d/%%m/%%Y')
                       BETWEEN CURDATE() + INTERVAL %d DAY AND CURDATE() + INTERVAL %d DAY
                   AND data_evento REGEXP '^[0-9]{2}/[0-9]{2}/[0-9]{4}$'",
                $g['df'], $g['dt']
            ));
        }
        $bd_counts[$gkey] = (int)$cnt;
    }

    // WA Recovery stats (table may not exist — suppress errors)
    $wa_kill    = get_option('vm_wa_kill_switch', '0');
    $wa_channel = get_option('vm_wa_send_channel', 'zapi_1886');
    $rec_table  = $wpdb->prefix . 'wc_cart_recovery';
    $tbl_exists = $wpdb->get_var("SHOW TABLES LIKE '$rec_table'") === $rec_table;
    $wa_total = $wa_pending = $wa_sent = $wa_recovered = 0;
    $carts = [];
    if ($tbl_exists) {
        $wa_total     = (int)$wpdb->get_var("SELECT COUNT(*) FROM $rec_table");
        $wa_pending   = (int)$wpdb->get_var("SELECT COUNT(*) FROM $rec_table WHERE status IN ('pending','captured')");
        $wa_sent      = (int)$wpdb->get_var("SELECT COUNT(*) FROM $rec_table WHERE status = 'sent'");
        $wa_recovered = (int)$wpdb->get_var("SELECT COUNT(*) FROM $rec_table WHERE status = 'recovered'");
        $carts        = $wpdb->get_results("SELECT * FROM $rec_table ORDER BY created_at DESC LIMIT 10");
    }

    // Exit-Intent stats
    $ei_shown  = (int)get_option('vm_ei_stat_shows', 0);
    $ei_clicks = (int)get_option('vm_ei_stat_clicks', 0);
    $ei_rate   = $ei_shown > 0 ? round($ei_clicks / $ei_shown * 100, 1) : 0;
    ?>
    <div class="wrap vm2-wrap">
    <h1>🤖 Automações</h1>

    <style>
    .vm2-auto-tabs{display:flex;gap:3px;margin-bottom:20px;flex-wrap:wrap;border-bottom:2px solid #e0e0e0;padding-bottom:0}
    .vm2-auto-tab{padding:8px 12px;border-radius:6px 6px 0 0;text-decoration:none;color:#57606a;font-size:13px;font-weight:500;border:1px solid transparent;border-bottom:none;position:relative;top:2px}
    .vm2-auto-tab:hover{background:#f6f8fa;color:#1d2327}
    .vm2-auto-tab.active{background:#fff;border-color:#e0e0e0;border-bottom-color:#fff;color:#1d2327;font-weight:700}
    .vm2-tab-body{display:none}.vm2-tab-body.active{display:block}
    .vm2-step-card{background:#fff;border:1px solid #e0e0e0;border-radius:10px;padding:18px;margin-bottom:14px;box-shadow:0 1px 3px rgba(0,0,0,.05)}
    .vm2-step-hdr{display:flex;align-items:center;justify-content:space-between;margin-bottom:14px;flex-wrap:wrap;gap:8px}
    .vm2-step-badge{background:#1d2327;color:#fff;padding:4px 12px;border-radius:20px;font-size:13px;font-weight:700}
    .vm2-eligible{background:#e8f4fd;color:#0066cc;padding:4px 10px;border-radius:20px;font-size:12px;font-weight:600}
    .vm2-step-grid{display:grid;grid-template-columns:1fr 1fr;gap:12px}
    @media(max-width:640px){.vm2-step-grid{grid-template-columns:1fr}}
    .vm2-ctrl-bar{background:#fff;border:1px solid #e0e0e0;border-radius:10px;padding:12px 18px;margin-bottom:18px;display:flex;align-items:center;gap:16px;flex-wrap:wrap}
    .vm2-ctrl-bar label{font-size:13px;color:#57606a;font-weight:500;display:flex;align-items:center;gap:6px}
    .vm2-ctrl-bar select{font-size:13px}
    .vm2-ks-on{display:inline-block;background:#fef2f2;color:#dc2626;border:1px solid #fca5a5;padding:3px 10px;border-radius:20px;font-size:12px;font-weight:700}
    .vm2-ks-off{display:inline-block;background:#f0fdf4;color:#16a34a;border:1px solid #86efac;padding:3px 10px;border-radius:20px;font-size:12px;font-weight:700}
    .vm2-bd-grid{display:grid;grid-template-columns:repeat(auto-fill,minmax(260px,1fr));gap:12px}
    .vm2-bd-card{background:#fff;border-left:4px solid #ccc;border-radius:8px;padding:14px;box-shadow:0 1px 3px rgba(0,0,0,.05);cursor:pointer;transition:all .15s ease}
    .vm2-bd-card:hover{transform:translateY(-2px);box-shadow:0 4px 12px rgba(0,0,0,.1)}
    .vm2-bd-lbl{font-weight:700;font-size:14px;margin-bottom:8px;display:flex;justify-content:space-between;align-items:center}
    .vm2-bd-n{font-size:26px;font-weight:800;margin-bottom:6px}
    .vm2-stat-row{display:grid;grid-template-columns:repeat(4,1fr);gap:12px;margin-bottom:20px}
    @media(max-width:600px){.vm2-stat-row{grid-template-columns:repeat(2,1fr)}}
    .vm2-stat-mini{background:#fff;border:1px solid #e0e0e0;border-radius:8px;padding:12px;text-align:center;cursor:pointer;transition:all .15s ease}
    .vm2-stat-mini:hover{transform:translateY(-2px);box-shadow:0 4px 12px rgba(0,0,0,.1);border-color:#0073aa}
    .vm2-stat-mini .n{font-size:24px;font-weight:800;color:#1d2327}
    .vm2-stat-mini .l{font-size:11px;color:#57606a;margin-top:2px}
    .vm2-placeholder{background:#f6f8fa;border:2px dashed #d0d7de;border-radius:10px;padding:50px;text-align:center;color:#57606a}
    .vm2-placeholder h3{font-size:18px;color:#1d2327;margin-bottom:8px}
    .vm2-fld-lbl{font-size:11px;color:#57606a;display:block;margin-bottom:3px;font-weight:500}
    /* ── KPI cards usados nas tabs Carrinho e Exit-Intent ── */
    .vm2-kpis{display:grid;grid-template-columns:repeat(auto-fit,minmax(160px,1fr));gap:12px;margin-bottom:20px}
    .vm2-kpi{background:#fff;border:1px solid #ddd;border-radius:10px;padding:18px 20px;box-shadow:0 1px 3px rgba(0,0,0,.06);cursor:pointer;transition:all .15s ease}
    .vm2-kpi:hover{transform:translateY(-2px);box-shadow:0 4px 14px rgba(0,0,0,.13);border-color:#0073aa}
    .vm2-kpi .label{font-size:11px;color:#888;text-transform:uppercase;letter-spacing:.5px;margin-bottom:8px;font-weight:600}
    .vm2-kpi .value{font-size:28px;font-weight:700;color:#1a1a1a;line-height:1}
    .vm2-kpi .delta{font-size:12px;margin-top:8px}
    .vm2-kpi .delta.up{color:#27ae60}.vm2-kpi .delta.down{color:#e74c3c}.vm2-kpi .delta.neutral{color:#999}
    /* ── Card / Grid layout ── */
    .vm2-grid2{display:grid;grid-template-columns:repeat(auto-fit,minmax(320px,1fr));gap:16px;margin-bottom:16px}
    .vm2-card{background:#fff;border:1px solid #ddd;border-radius:10px;padding:20px;box-shadow:0 1px 3px rgba(0,0,0,.05)}
    .vm2-card h3{margin:0 0 16px;font-size:15px;color:#1d2327;font-weight:700;display:flex;align-items:center;gap:6px}
    /* ── Buttons ── */
    .vm2-btn{display:inline-flex;align-items:center;gap:6px;padding:8px 18px;border-radius:6px;border:none;cursor:pointer;font-size:13px;font-weight:600;transition:all .15s;text-decoration:none}
    .vm2-btn-primary{background:#2271b1;color:#fff}.vm2-btn-primary:hover{background:#135e96}
    .vm2-btn-success{background:#16a34a;color:#fff}.vm2-btn-success:hover{background:#15803d}
    .vm2-btn-danger{background:#dc2626;color:#fff}.vm2-btn-danger:hover{background:#b91c1c}
    .vm2-btn-gray{background:#f1f5f9;color:#374151;border:1px solid #e0e0e0}.vm2-btn-gray:hover{background:#e5e7eb}
    .vm2-btn-sm{padding:5px 12px;font-size:12px}
    /* ── Table ── */
    .vm2-table{width:100%;border-collapse:collapse;font-size:13px}
    .vm2-table th{background:#f6f8fa;padding:9px 12px;text-align:left;font-size:11px;text-transform:uppercase;color:#57606a;border-bottom:1px solid #e0e0e0}
    .vm2-table td{padding:10px 12px;border-bottom:1px solid #f0f0f0;vertical-align:middle}
    .vm2-table tr:hover td{background:#fafbfc}
    .vm2-badge{display:inline-block;padding:3px 10px;border-radius:20px;font-size:11px;font-weight:700}
    .vm2-badge-sent{background:#d1fae5;color:#065f46}
    .vm2-badge-pending{background:#fef3c7;color:#92400e}
    .vm2-badge-failed{background:#fee2e2;color:#991b1b}
    .vm2-badge-cancelled{background:#dbeafe;color:#1e40af}
    </style>

    <!-- Tab Navigation -->
    <div class="vm2-auto-tabs">
    <?php
    $tabs = [
        'pipeline'  => '🔁 Pipeline',
        'aquecer'   => '🔥 Aquecer D+X',
        'leads'     => '🎯 Leads HOT',
        'bydate'    => '📅 Por Data',
        'carrinho'  => '🛒 Carrinho',
        'popup'     => '💌 Popup',
        'exitintent'=> '🚪 Exit-Intent',
        'posevento' => '🎁 Pós-Evento',
        'upsell'    => '💎 Upsell',
        'pedidos'   => '🧾 Pedidos',
    ];
    foreach ($tabs as $tk => $tl) {
        $cls = ($active_tab === $tk) ? 'vm2-auto-tab active' : 'vm2-auto-tab';
        $url = add_query_arg(['page'=>'vm2-automacoes','tab'=>$tk], admin_url('admin.php'));
        echo '<a href="' . esc_url($url) . '" class="' . $cls . '">' . $tl . '</a>';
    }
    ?>
    </div>

    <!-- ===== TAB: PIPELINE ===== -->
    <div class="vm2-tab-body <?php echo $active_tab === 'pipeline' ? 'active' : ''; ?>">
        <?php vm2_render_pipeline_tab(); ?>
    </div>

    <form method="post" action="">
    <?php wp_nonce_field('vm2_auto_save'); ?>
    <input type="hidden" name="vm2_auto_save" value="1">

    <!-- ===== TAB: AQUECER D+X ===== -->
    <div class="vm2-tab-body <?php echo $active_tab === 'aquecer' ? 'active' : ''; ?>">

        <div class="vm2-ctrl-bar">
            <label><strong>🔥 Aquecer D+X</strong></label>
            <label>Kill Switch:
                <select name="vm2_aquecer_kill">
                    <option value="1" <?php selected($a_kill,'1'); ?>>🔴 PARADO</option>
                    <option value="0" <?php selected($a_kill,'0'); ?>>🟢 ATIVO</option>
                </select>
            </label>
            <label>Canal:
                <select id="vm2-aq-ch-sel" name="vm2_aquecer_channel" onchange="vm2StepChannelSwitch('aq', this.value)">
                    <?php echo vm2_channel_options_html( $a_channel ); ?>
                </select>
            </label>
            <?php echo $a_kill === '1' ? '<span class="vm2-ks-on">🔴 PAUSADO</span>' : '<span class="vm2-ks-off">🟢 ATIVO</span>'; ?>
        </div>

        <div id="vm2-aq-steps">
        <?php foreach ($steps as $skey => $step):
            $s_on   = get_option("vm2_aquecer_{$skey}_on", '0');
            $s_tmpl = get_option("vm2_aquecer_{$skey}_template", $step['default_tmpl']);
            $s_msg  = get_option("vm2_aquecer_{$skey}_msg", $step['default_msg']);
            $cnt    = $step_counts[$skey];
        ?>
        <div class="vm2-step-card">
            <div class="vm2-step-hdr">
                <div style="display:flex;align-items:center;gap:10px">
                    <span class="vm2-step-badge"><?php echo esc_html($step['label']); ?></span>
                    <span style="color:#57606a;font-size:13px"><?php echo $step['delay']; ?> dia<?php echo $step['delay']>1?'s':''; ?> após último contato</span>
                </div>
                <div style="display:flex;align-items:center;gap:10px">
                    <span class="vm2-eligible"><?php echo $cnt; ?> elegíveis</span>
                    <label style="font-size:13px;display:flex;align-items:center;gap:5px">
                        <input type="checkbox" name="vm2_aquecer_<?php echo $skey; ?>_on" value="1" <?php checked($s_on,'1'); ?>>
                        Ativo
                    </label>
                </div>
            </div>
            <div class="vm2-step-grid">
                <div class="vm2-col-waba">
                    <span class="vm2-fld-lbl">📋 Template WABA</span>
                    <select name="vm2_aquecer_<?php echo $skey; ?>_template" style="width:100%">
                        <?php echo vm2_waba_template_options_html( $s_tmpl ); ?>
                    </select>
                </div>
                <div class="vm2-col-zapi">
                    <span class="vm2-fld-lbl">💬 Texto Z-API <small>(vars: {nome}, {telefone})</small></span>
                    <textarea name="vm2_aquecer_<?php echo $skey; ?>_msg" style="width:100%;height:72px;resize:vertical;font-size:12px"><?php echo esc_textarea($s_msg); ?></textarea>
                </div>
            </div>
            <?php if ($cnt > 0): ?>
            <div style="margin-top:10px;text-align:right">
                <a href="#" onclick="alert('Função de envio em desenvolvimento — Fase 5b.');return false;"
                   style="background:#0079d3;color:#fff;padding:6px 14px;border-radius:6px;text-decoration:none;font-size:13px">
                    ▶️ Executar agora (<?php echo $cnt; ?>)
                </a>
            </div>
            <?php endif; ?>
        </div>
        <?php endforeach; ?>
        </div><!-- /vm2-aq-steps -->

        <?php vm2_render_test_box( 'aquecer', $a_channel, get_option('vm2_aquecer_d1_msg', 'Oi {nome}! 👋 Vi que você ainda está pesquisando atrações para sua festa. Posso te ajudar?'), get_option('vm2_aquecer_d1_template','') ); ?>

        <!-- [v1.5.93] EMAIL PARALELO -->
        <?php
        $aq_email_on   = get_option('vm2_aquecer_email_on', '0');
        $aq_email_subj = get_option('vm2_aquecer_email_subject', 'Ainda pensando na festa? A gente pode ajudar 🎉');
        $aq_email_body = get_option('vm2_aquecer_email_body', "Oi {nome}!\n\nVimos que você pesquisou atrações para sua festa na VivaMais Eventos. Ainda não encontrou o que procura?\n\nAcesse agora e escolha entre centenas de atrações:\nhttps://loja.vivamaiseventos.com\n\n_Equipe VivaMais Eventos_");
        $aq_email_cnt  = (int)$wpdb->get_var("SELECT COUNT(*) FROM {$wpdb->prefix}vm2_contacts WHERE email != '' AND email IS NOT NULL");
        ?>
        <div style="background:#f0f9ff;border:1px solid #bfdbfe;border-radius:10px;padding:16px 18px;margin-top:16px">
            <div style="display:flex;align-items:center;justify-content:space-between;margin-bottom:12px">
                <strong style="font-size:14px;color:#1e40af">📧 Canal Email — Paralelo ao WA</strong>
                <span style="background:#dbeafe;color:#1e40af;padding:3px 10px;border-radius:20px;font-size:12px;font-weight:600"><?php echo $aq_email_cnt; ?> contatos com email</span>
            </div>
            <p style="font-size:12px;color:#64748b;margin:0 0 14px">
                Quando ativo, envia email em paralelo ao WA para contatos que têm email. Se o contato não tem WA mas tem email, envia apenas email.
                Vars disponíveis: <code>{nome}</code>, <code>{link}</code>
            </p>
            <div style="display:flex;align-items:center;gap:10px;margin-bottom:14px">
                <label style="font-weight:600;font-size:13px">Status:</label>
                <select name="vm2_aquecer_email_on" style="padding:6px 10px;border:1px solid #d0d7de;border-radius:6px">
                    <option value="0" <?php selected($aq_email_on,'0'); ?>>🔴 Desativado</option>
                    <option value="1" <?php selected($aq_email_on,'1'); ?>>🟢 Ativo</option>
                </select>
            </div>
            <div style="margin-bottom:12px">
                <label style="font-size:12px;font-weight:600;display:block;margin-bottom:4px">📝 Assunto</label>
                <input type="text" name="vm2_aquecer_email_subject" value="<?php echo esc_attr($aq_email_subj); ?>" style="width:100%;padding:7px 10px;border:1px solid #d0d7de;border-radius:6px;font-size:13px">
            </div>
            <div>
                <label style="font-size:12px;font-weight:600;display:block;margin-bottom:4px">💬 Corpo do email</label>
                <textarea name="vm2_aquecer_email_body" rows="6" style="width:100%;padding:7px 10px;border:1px solid #d0d7de;border-radius:6px;font-size:12px;font-family:monospace;resize:vertical"><?php echo esc_textarea($aq_email_body); ?></textarea>
            </div>
        </div>

        <div style="text-align:right;margin-top:8px">
            <button type="submit" class="button button-primary">💾 Salvar Configurações</button>
        </div>
    </div>

    <!-- ===== TAB: POR DATA DO EVENTO ===== -->
    <div class="vm2-tab-body <?php echo $active_tab === 'leads' ? 'active' : ''; ?>">
    <?php
    // ── Auto-Aquecer config options ──
    $aa_on        = get_option('vm2_auto_aquecer_on', '0');
    $aa_threshold = (int)get_option('vm2_auto_aquecer_threshold', '60');
    $aa_channel   = get_option('vm2_auto_aquecer_channel', 'zapi_7551');
    $aa_template  = get_option('vm2_auto_aquecer_template', '');
    $aa_cooldown  = (int)get_option('vm2_auto_aquecer_cooldown', '24');
    $aa_batch     = (int)get_option('vm2_auto_aquecer_batch', '20');
    $aa_msg       = get_option('vm2_auto_aquecer_msg', 'Oi {nome}! 👋 Vi que você se interessou em nossas atrações. Posso te ajudar a contratar?');

    // Force recalculate cache if requested
    if ( isset($_GET['vm2_recalc']) && $_GET['vm2_recalc'] === '1' ) {
        delete_transient('vm2_leads_aq_v2');
    }

    // Get leads (cached 30min)
    $leads_data  = vm2_get_leads_para_aquecer(['limit' => 300]);
    $cache_time  = get_transient('vm2_leads_aq_v2_ts');
    $calc_time   = current_time('H:i');

    // Stats
    $cnt_hot   = count(array_filter($leads_data, fn($l) => $l['level'] === 'hot'));
    $cnt_warm  = count(array_filter($leads_data, fn($l) => $l['level'] === 'warm'));
    $cnt_cold  = count(array_filter($leads_data, fn($l) => $l['level'] === 'cold'));
    $cnt_cart  = count(array_filter($leads_data, fn($l) => in_array('carrinho', $l['sources'])));
    $cnt_gal   = count(array_filter($leads_data, fn($l) => in_array('galeria', $l['sources'])));

    $filter_level = sanitize_key($_GET['vm2_lf'] ?? '');
    $base_url = add_query_arg(['page' => 'vm2-automacoes', 'tab' => 'leads'], admin_url('admin.php'));

    $channels = vm2_channels();
    $aa_is_waba = isset($channels[$aa_channel]) && $channels[$aa_channel]['type'] === 'waba';
    ?>

    <div style="display:flex;align-items:center;justify-content:space-between;flex-wrap:wrap;gap:8px;margin-bottom:14px">
        <div>
            <strong style="font-size:15px">🎯 Leads para Aquecer</strong>
            <span style="color:#57606a;font-size:12px;margin-left:8px">Calculado às <?php echo $calc_time; ?></span>
        </div>
        <a href="<?php echo esc_url(add_query_arg('vm2_recalc','1',$base_url)); ?>"
           style="background:#f0f0f0;border:1px solid #d0d0d0;padding:5px 12px;border-radius:6px;font-size:12px;text-decoration:none;color:#333">
            🔄 Recalcular
        </a>
    </div>

    <!-- KPI Cards -->
    <div style="display:grid;grid-template-columns:repeat(auto-fit,minmax(110px,1fr));gap:10px;margin-bottom:18px">
        <?php
        $cards = [
            ['🔥', $cnt_hot,  'HOT (≥60)',  'hot',      '#fff3e0','#e65100'],
            ['⚡', $cnt_warm, 'Warm (30-59)','warm',     '#fff9c4','#f57f17'],
            ['🌱', $cnt_cold, 'Cold (<30)',  'cold',     '#e8f5e9','#2e7d32'],
            ['🛒', $cnt_cart, 'Carrinho',   'carrinho', '#fce4ec','#c62828'],
            ['📸', $cnt_gal,  'Galeria',    'galeria',  '#e3f2fd','#1565c0'],
        ];
        foreach ($cards as [$icon, $cnt, $lbl, $lf, $bg, $col]):
            $is_active = $filter_level === $lf;
            $card_url = $is_active
                ? $base_url
                : add_query_arg('vm2_lf', $lf, $base_url);
        ?>
        <a href="<?php echo esc_url($card_url); ?>" style="text-decoration:none">
            <div style="background:<?php echo $is_active ? $bg : '#fff'; ?>;border:1.5px solid <?php echo $is_active ? $col : '#e0e0e0'; ?>;border-radius:10px;padding:12px 10px;text-align:center;transition:.15s;cursor:pointer">
                <div style="font-size:22px"><?php echo $icon; ?></div>
                <div style="font-size:22px;font-weight:700;color:<?php echo $col; ?>"><?php echo $cnt; ?></div>
                <div style="font-size:11px;color:#666;margin-top:2px"><?php echo $lbl; ?></div>
            </div>
        </a>
        <?php endforeach; ?>
    </div>

    <!-- Config Auto-Aquecer (collapsible) -->
    <details open style="border:1px solid #e0e0e0;border-radius:8px;padding:0;margin-bottom:16px">
        <summary style="padding:10px 14px;cursor:pointer;font-weight:600;font-size:13px;list-style:none;display:flex;align-items:center;gap:6px;background:<?php echo $aa_on === '1' ? '#e8f5e9' : '#fff8e1'; ?>;border-radius:8px">
            <span>⚙️ Auto-Aquecer</span>
            <span style="font-size:12px;font-weight:400;color:#666">— disparo automático a cada hora para leads acima do score mínimo</span>
            <span style="margin-left:auto;font-size:12px;padding:2px 8px;border-radius:10px;background:<?php echo $aa_on === '1' ? '#4caf50' : '#ff9800'; ?>;color:#fff">
                <?php echo $aa_on === '1' ? '🟢 ATIVO' : '🟡 PARADO'; ?>
            </span>
        </summary>
        <div style="padding:14px;border-top:1px solid #e0e0e0">
            <div style="display:grid;grid-template-columns:repeat(auto-fit,minmax(200px,1fr));gap:12px;align-items:end">
                <label style="font-size:13px">
                    <span style="display:block;margin-bottom:4px;font-weight:600">🔘 Status</span>
                    <select name="vm2_auto_aquecer_on" id="vm2-aa-on" style="width:100%">
                        <option value="0" <?php selected($aa_on,'0'); ?>>🔴 PARADO</option>
                        <option value="1" <?php selected($aa_on,'1'); ?>>🟢 ATIVO</option>
                    </select>
                </label>
                <label style="font-size:13px">
                    <span style="display:block;margin-bottom:4px;font-weight:600">🎯 Score mínimo</span>
                    <input type="number" name="vm2_auto_aquecer_threshold" value="<?php echo esc_attr($aa_threshold); ?>" min="1" max="100" style="width:100%;padding:6px 8px;border:1px solid #d0d0d0;border-radius:6px">
                </label>
                <label style="font-size:13px">
                    <span style="display:block;margin-bottom:4px;font-weight:600">📡 Canal</span>
                    <select name="vm2_auto_aquecer_channel" id="vm2-aa-ch" onchange="vm2StepChannelSwitch('aa',this.value)" style="width:100%">
                        <?php echo vm2_channel_options_html($aa_channel); ?>
                    </select>
                </label>
                <label style="font-size:13px">
                    <span style="display:block;margin-bottom:4px;font-weight:600">⏰ Cooldown (h entre envios)</span>
                    <input type="number" name="vm2_auto_aquecer_cooldown" value="<?php echo esc_attr($aa_cooldown); ?>" min="1" max="168" style="width:100%;padding:6px 8px;border:1px solid #d0d0d0;border-radius:6px">
                </label>
            </div>
            <div style="margin-top:10px">
                <label style="font-size:13px">
                    <span style="display:block;margin-bottom:4px;font-weight:600">📦 Batch (msgs por rodada)</span>
                    <input type="number" name="vm2_auto_aquecer_batch" value="<?php echo esc_attr($aa_batch); ?>" min="1" max="100" style="width:100%;padding:6px 8px;border:1px solid #d0d0d0;border-radius:6px">
                </label>
            </div>
            <div id="vm2-aa-waba-row" style="margin-top:10px;<?php echo $aa_is_waba ? '' : 'display:none'; ?>">
                <label style="font-size:13px">
                    <span style="display:block;margin-bottom:4px;font-weight:600">📋 Template WABA</span>
                    <select name="vm2_auto_aquecer_template" style="width:100%;max-width:420px">
                        <?php echo vm2_waba_template_options_html($aa_template); ?>
                    </select>
                </label>
            </div>
            <div id="vm2-aa-zapi-row" style="margin-top:10px;<?php echo $aa_is_waba ? 'display:none' : ''; ?>">
                <label style="font-size:13px">
                    <span style="display:block;margin-bottom:4px;font-weight:600">💬 Mensagem Z-API <small style="font-weight:400">(var: {nome})</small></span>
                    <textarea name="vm2_auto_aquecer_msg" style="width:100%;height:72px;resize:vertical;font-size:12px;border:1px solid #d0d0d0;border-radius:6px;padding:6px 8px"><?php echo esc_textarea($aa_msg); ?></textarea>
                </label>
            </div>
            <?php vm2_render_test_box( 'aa', $aa_channel, $aa_msg, $aa_template ); ?>
        <!-- [v1.5.94] EMAIL PARALELO POR DATA -->
        <?php
        $aa_email_on   = get_option('vm2_auto_aquecer_email_on', '0');
        $aa_email_subj = get_option('vm2_auto_aquecer_email_subject', 'Você tem um evento chegando! Vamos fechar as atrações? 🎉');
        $aa_email_body = get_option('vm2_auto_aquecer_email_body', "Oi {nome}!\n\nIdentificamos que você tem um evento se aproximando e ainda pode estar pesquisando atrações. Não deixe para a última hora!\n\nAcesse agora e contrate em minutos:\nhttps://loja.vivamaiseventos.com\n\n_Equipe VivaMais Eventos_");
        $aa_email_cnt  = (int)$wpdb->get_var("SELECT COUNT(*) FROM {$wpdb->prefix}vm2_contacts WHERE email != '' AND email IS NOT NULL");
        ?>
        <div style="background:#f0f9ff;border:1px solid #bfdbfe;border-radius:10px;padding:16px 18px;margin-top:16px">
            <div style="display:flex;align-items:center;justify-content:space-between;margin-bottom:12px">
                <strong style="font-size:14px;color:#1e40af">📧 Canal Email — Paralelo ao WA</strong>
                <span style="background:#dbeafe;color:#1e40af;padding:3px 10px;border-radius:20px;font-size:12px;font-weight:600"><?php echo $aa_email_cnt; ?> contatos com email</span>
            </div>
            <p style="font-size:12px;color:#64748b;margin:0 0 14px">
                Quando ativo, envia email em paralelo ao WA para contatos que têm email cadastrado.
                Vars disponíveis: <code>{nome}</code>, <code>{link}</code>
            </p>
            <div style="display:flex;align-items:center;gap:10px;margin-bottom:14px">
                <label style="font-weight:600;font-size:13px">Status:</label>
                <select name="vm2_auto_aquecer_email_on" style="padding:6px 10px;border:1px solid #d0d7de;border-radius:6px">
                    <option value="0" <?php selected($aa_email_on,'0'); ?>>🔴 Desativado</option>
                    <option value="1" <?php selected($aa_email_on,'1'); ?>>🟢 Ativo</option>
                </select>
            </div>
            <div style="margin-bottom:12px">
                <label style="font-size:12px;font-weight:600;display:block;margin-bottom:4px">📝 Assunto</label>
                <input type="text" name="vm2_auto_aquecer_email_subject" value="<?php echo esc_attr($aa_email_subj); ?>" style="width:100%;padding:7px 10px;border:1px solid #d0d7de;border-radius:6px;font-size:13px">
            </div>
            <div>
                <label style="font-size:12px;font-weight:600;display:block;margin-bottom:4px">💬 Corpo do email</label>
                <textarea name="vm2_auto_aquecer_email_body" rows="6" style="width:100%;padding:7px 10px;border:1px solid #d0d7de;border-radius:6px;font-size:12px;font-family:monospace;resize:vertical"><?php echo esc_textarea($aa_email_body); ?></textarea>
            </div>
        </div>
        </div>
    </details>

    <?php
    $hot_on       = get_option( 'vm2_hot_on',       '0' );
    $hot_kill     = get_option( 'vm2_hot_kill',     '1' );
    $hot_channel  = get_option( 'vm2_hot_channel',  'waba_5039' );
    $hot_template = get_option( 'vm2_hot_template', '' );
    $hot_msg      = get_option( 'vm2_hot_msg',
        "Oi {nome}! 👋 Aqui é da VivaMais — você tem um evento em vista?\nAinda dá tempo de fechar as atrações perfeitas. Posso ajudar! 🎉\n{link}" );
    $hot_cooldown = (int) get_option( 'vm2_hot_cooldown', '72' );
    $hot_batch    = (int) get_option( 'vm2_hot_batch',    '10' );
    $hot_is_waba  = isset( $channels[$hot_channel] ) && $channels[$hot_channel]['type'] === 'waba';
    $hot_active   = $hot_on === '1' && $hot_kill !== '1';
    ?>
    <!-- Config Auto-HOT (collapsible) -->
    <details open style="border:1px solid #e0e0e0;border-radius:8px;padding:0;margin-bottom:16px">
        <summary style="padding:10px 14px;cursor:pointer;font-weight:600;font-size:13px;list-style:none;display:flex;align-items:center;gap:6px;background:<?php echo $hot_active ? '#fff3e0' : '#fff8e1'; ?>;border-radius:8px">
            <span>🔥 Auto-HOT</span>
            <span style="font-size:12px;font-weight:400;color:#666">— envia mensagem cirúrgica para leads Incoming no Kommo (pipeline HOT)</span>
            <span style="margin-left:auto;font-size:12px;padding:2px 8px;border-radius:10px;background:<?php echo $hot_active ? '#e65100' : '#ff9800'; ?>;color:#fff">
                <?php echo $hot_active ? '🟠 ATIVO' : '🟡 PARADO'; ?>
            </span>
        </summary>
        <div style="padding:14px;border-top:1px solid #e0e0e0">
            <div style="display:grid;grid-template-columns:repeat(auto-fit,minmax(200px,1fr));gap:12px;align-items:end">
                <label style="font-size:13px">
                    <span style="display:block;margin-bottom:4px;font-weight:600">🔘 Status</span>
                    <select name="vm2_hot_on" style="width:100%">
                        <option value="0" <?php selected($hot_on,'0'); ?>>🔴 PARADO</option>
                        <option value="1" <?php selected($hot_on,'1'); ?>>🟢 ATIVO</option>
                    </select>
                </label>
                <label style="font-size:13px">
                    <span style="display:block;margin-bottom:4px;font-weight:600">🛑 Kill Switch</span>
                    <select name="vm2_hot_kill" style="width:100%">
                        <option value="1" <?php selected($hot_kill,'1'); ?>>🔴 Bloqueado</option>
                        <option value="0" <?php selected($hot_kill,'0'); ?>>🟢 Liberado</option>
                    </select>
                </label>
                <label style="font-size:13px">
                    <span style="display:block;margin-bottom:4px;font-weight:600">📡 Canal preferencial</span>
                    <select name="vm2_hot_channel" id="vm2-hot-ch" onchange="vm2StepChannelSwitch('hot',this.value)" style="width:100%">
                        <?php echo vm2_channel_options_html( $hot_channel ); ?>
                    </select>
                </label>
                <label style="font-size:13px">
                    <span style="display:block;margin-bottom:4px;font-weight:600">⏰ Cooldown (h entre envios)</span>
                    <input type="number" name="vm2_hot_cooldown" value="<?php echo esc_attr($hot_cooldown); ?>" min="1" max="336" style="width:100%;padding:6px 8px;border:1px solid #d0d0d0;border-radius:6px">
                </label>
                <label style="font-size:13px">
                    <span style="display:block;margin-bottom:4px;font-weight:600">📦 Batch (msgs/hora)</span>
                    <input type="number" name="vm2_hot_batch" value="<?php echo esc_attr($hot_batch); ?>" min="1" max="50" style="width:100%;padding:6px 8px;border:1px solid #d0d0d0;border-radius:6px">
                </label>
            </div>
            <div id="vm2-hot-waba-row" style="margin-top:10px;<?php echo $hot_is_waba ? '' : 'display:none'; ?>">
                <label style="font-size:13px">
                    <span style="display:block;margin-bottom:4px;font-weight:600">📋 Template WABA</span>
                    <select name="vm2_hot_template" style="width:100%;max-width:420px">
                        <?php echo vm2_waba_template_options_html( $hot_template ); ?>
                    </select>
                </label>
            </div>
            <div id="vm2-hot-zapi-row" style="margin-top:10px;<?php echo $hot_is_waba ? 'display:none' : ''; ?>">
                <label style="font-size:13px">
                    <span style="display:block;margin-bottom:4px;font-weight:600">💬 Mensagem <small style="font-weight:400">(vars: {nome}, {link})</small></span>
                    <textarea name="vm2_hot_msg" style="width:100%;height:80px;resize:vertical;font-size:12px;border:1px solid #d0d0d0;border-radius:6px;padding:6px 8px"><?php echo esc_textarea( $hot_msg ); ?></textarea>
                    <span style="font-size:11px;color:#888">{link} = URL rastreável para o site (UTM automático)</span>
                </label>
            </div>
            <?php vm2_render_test_box( 'hot', $hot_channel, $hot_msg, $hot_template ); ?>
        <!-- [v1.5.94] EMAIL PARALELO HOT -->
        <?php
        $hot_email_on   = get_option('vm2_hot_email_on', '0');
        $hot_email_subj = get_option('vm2_hot_email_subject', 'Você está procurando atrações para sua festa? 🎉');
        $hot_email_body = get_option('vm2_hot_email_body', "Oi {nome}!\n\nVi que você demonstrou interesse em contratar atrações para seu evento. Ainda está pesquisando?\n\nTemos centenas de opções esperando por você:\nhttps://loja.vivamaiseventos.com\n\n_Equipe VivaMais Eventos_");
        $hot_email_cnt  = (int)$wpdb->get_var("SELECT COUNT(*) FROM {$wpdb->prefix}vm2_contacts WHERE email != '' AND email IS NOT NULL");
        ?>
        <div style="background:#f0f9ff;border:1px solid #bfdbfe;border-radius:10px;padding:16px 18px;margin-top:16px">
            <div style="display:flex;align-items:center;justify-content:space-between;margin-bottom:12px">
                <strong style="font-size:14px;color:#1e40af">📧 Canal Email — Paralelo ao WA</strong>
                <span style="background:#dbeafe;color:#1e40af;padding:3px 10px;border-radius:20px;font-size:12px;font-weight:600"><?php echo $hot_email_cnt; ?> contatos com email</span>
            </div>
            <p style="font-size:12px;color:#64748b;margin:0 0 14px">
                Quando ativo, envia email em paralelo ao WA para contatos HOT que têm email cadastrado.
                Vars disponíveis: <code>{nome}</code>, <code>{link}</code>
            </p>
            <div style="display:flex;align-items:center;gap:10px;margin-bottom:14px">
                <label style="font-weight:600;font-size:13px">Status:</label>
                <select name="vm2_hot_email_on" style="padding:6px 10px;border:1px solid #d0d7de;border-radius:6px">
                    <option value="0" <?php selected($hot_email_on,'0'); ?>>🔴 Desativado</option>
                    <option value="1" <?php selected($hot_email_on,'1'); ?>>🟢 Ativo</option>
                </select>
            </div>
            <div style="margin-bottom:12px">
                <label style="font-size:12px;font-weight:600;display:block;margin-bottom:4px">📝 Assunto</label>
                <input type="text" name="vm2_hot_email_subject" value="<?php echo esc_attr($hot_email_subj); ?>" style="width:100%;padding:7px 10px;border:1px solid #d0d7de;border-radius:6px;font-size:13px">
            </div>
            <div>
                <label style="font-size:12px;font-weight:600;display:block;margin-bottom:4px">💬 Corpo do email</label>
                <textarea name="vm2_hot_email_body" rows="6" style="width:100%;padding:7px 10px;border:1px solid #d0d7de;border-radius:6px;font-size:12px;font-family:monospace;resize:vertical"><?php echo esc_textarea($hot_email_body); ?></textarea>
            </div>
        </div>
        </div>
    </details>

    <div style="text-align:right;margin-top:8px;margin-bottom:16px">
        <button type="submit" class="button button-primary">💾 Salvar Configurações</button>
    </div>

    <!-- Leads Table -->
    <?php
    // Apply filter
    $display_leads = $leads_data;
    if ( $filter_level === 'hot' )      $display_leads = array_filter($display_leads, fn($l) => $l['level'] === 'hot');
    elseif ( $filter_level === 'warm' ) $display_leads = array_filter($display_leads, fn($l) => $l['level'] === 'warm');
    elseif ( $filter_level === 'cold' ) $display_leads = array_filter($display_leads, fn($l) => $l['level'] === 'cold');
    elseif ( $filter_level === 'carrinho' ) $display_leads = array_filter($display_leads, fn($l) => in_array('carrinho', $l['sources']));
    elseif ( $filter_level === 'galeria' )  $display_leads = array_filter($display_leads, fn($l) => in_array('galeria', $l['sources']));
    $display_leads = array_values($display_leads);
    ?>

    <?php if ( $filter_level ): ?>
    <div style="margin-bottom:10px;font-size:13px;color:#333">
        Filtrando: <strong><?php echo esc_html($filter_level); ?></strong>
        — <?php echo count($display_leads); ?> leads
        <a href="<?php echo esc_url($base_url); ?>" style="margin-left:8px;color:#0079d3;font-size:12px">✕ Limpar filtro</a>
    </div>
    <?php endif; ?>

    <?php
    // ── Sort ──
    $leads_sort = sanitize_key( $_GET['vm2_ls'] ?? 'score_d' );
    usort( $display_leads, function($a, $b) use ($leads_sort) {
        switch ($leads_sort) {
            case 'score':    return $a['score'] - $b['score'];
            case 'score_d':  return $b['score'] - $a['score'];
            case 'nome':     return strcmp( $a['name'] ?? '', $b['name'] ?? '' );
            case 'nome_d':   return strcmp( $b['name'] ?? '', $a['name'] ?? '' );
            case 'evento':   return strcmp( $a['data_evento'] ?: '0', $b['data_evento'] ?: '0' );
            case 'evento_d': return strcmp( $b['data_evento'] ?: '0', $a['data_evento'] ?: '0' );
            case 'ativo':    return strcmp( $a['last_activity'] ?: '0', $b['last_activity'] ?: '0' );
            case 'ativo_d':  return strcmp( $b['last_activity'] ?: '0', $a['last_activity'] ?: '0' );
            default:         return $b['score'] - $a['score'];
        }
    });

    // ── Batch lookup: last_activity de vm2_contacts ──
    $last_act_map = [];
    if ( ! empty($display_leads) ) {
        $p11s = array_map( fn($l) => "'" . esc_sql( vm2_phone_last11($l['phone']) ) . "'", $display_leads );
        $p11s = array_unique($p11s);
        $ph_sql = implode(',', $p11s);
        $la_rows = $wpdb->get_results(
            "SELECT RIGHT(phone,11) AS p11, last_activity
             FROM {$wpdb->prefix}vm2_contacts
             WHERE RIGHT(phone,11) IN ($ph_sql)"
        );
        foreach ($la_rows as $r) $last_act_map[$r->p11] = $r->last_activity;
    }

    // ── Sort URL helpers ──
    $current_params = array_merge( $_GET ?? [], ['page' => 'vm2-automacoes', 'tab' => 'leads'] );
    $_lsu = fn($s) => esc_url( add_query_arg( array_merge($current_params, ['vm2_ls' => $s]), admin_url('admin.php') ) );
    $_larrow = function($asc, $desc) use ($leads_sort) {
        if ($leads_sort === $asc)  return ' <span style="color:#0079d3">↑</span>';
        if ($leads_sort === $desc) return ' <span style="color:#0079d3">↓</span>';
        return ' <span style="color:#ccc">↕</span>';
    };
    $th_link = 'color:inherit;text-decoration:none;white-space:nowrap';
    ?>

    <div style="overflow-x:auto">
    <table style="width:100%;border-collapse:collapse;font-size:13px">
        <thead>
            <tr style="background:#f6f8fa;border-bottom:2px solid #e0e0e0">
                <th style="padding:8px 10px;text-align:left;white-space:nowrap"><a href="<?php echo $_lsu($leads_sort==='score'?'score_d':'score'); ?>" style="<?php echo $th_link; ?>">Score<?php echo $_larrow('score','score_d'); ?></a></th>
                <th style="padding:8px 10px;text-align:left;white-space:nowrap"><a href="<?php echo $_lsu($leads_sort==='ativo'?'ativo_d':'ativo'); ?>" style="<?php echo $th_link; ?>">Última Atividade<?php echo $_larrow('ativo','ativo_d'); ?></a></th>
                <th style="padding:8px 10px;text-align:left"><a href="<?php echo $_lsu($leads_sort==='nome'?'nome_d':'nome'); ?>" style="<?php echo $th_link; ?>">Nome<?php echo $_larrow('nome','nome_d'); ?></a></th>
                <th style="padding:8px 10px;text-align:left;white-space:nowrap">Telefone</th>
                <th style="padding:8px 10px;text-align:left">Sinais</th>
                <th style="padding:8px 10px;text-align:left;white-space:nowrap"><a href="<?php echo $_lsu($leads_sort==='evento'?'evento_d':'evento'); ?>" style="<?php echo $th_link; ?>">Data Evento<?php echo $_larrow('evento','evento_d'); ?></a></th>
                <th style="padding:8px 10px;text-align:center;white-space:nowrap">Ações</th>
            </tr>
        </thead>
        <tbody>
        <?php if ( empty($display_leads) ): ?>
            <tr><td colspan="7" style="padding:24px;text-align:center;color:#888">Nenhum lead encontrado. <a href="<?php echo esc_url(add_query_arg('vm2_recalc','1',$base_url)); ?>">🔄 Recalcular</a></td></tr>
        <?php endif; ?>
        <?php foreach ( $display_leads as $lead ):
            $lvl     = $lead['level'];
            $score   = $lead['score'];
            $badgecl = $lvl === 'hot' ? 'vm2-hot' : ($lvl === 'warm' ? 'vm2-warm' : 'vm2-cold');
            $icon    = $lvl === 'hot' ? '🔥' : ($lvl === 'warm' ? '⚡' : '🌱');
            $name    = $lead['name'] ?: '—';
            $phone   = $lead['phone'];
            $p11     = $lead['p11'] ?? vm2_phone_last11($phone);
            $ev      = $lead['data_evento'] ?? '';
            $ev_fmt  = $ev ? date('d/m/y', strtotime($ev)) : '—';
            $signals = $lead['signals'] ?? [];
            $send_data = esc_attr(json_encode(['phone' => $phone, 'name' => $name]));
            $p11_lead  = vm2_phone_last11($phone);
            $la_raw    = $last_act_map[$p11_lead] ?? '';
            $la_fmt    = $la_raw ? vm2_local_date($la_raw, 'd/m/y H:i') : '—';
        ?>
        <tr style="border-bottom:1px solid #f0f0f0" class="vm2-lead-row">
            <td style="padding:8px 10px;white-space:nowrap">
                <span class="vm2-badge-score <?php echo $badgecl; ?>"><?php echo $icon . ' ' . $score; ?></span>
            </td>
            <td style="padding:8px 10px;color:#57606a;font-size:12px;white-space:nowrap"><?php echo esc_html($la_fmt); ?></td>
            <td style="padding:8px 10px;max-width:140px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap" title="<?php echo esc_attr($name); ?>">
                <?php echo esc_html($name); ?>
            </td>
            <td style="padding:8px 10px;white-space:nowrap;font-family:monospace;font-size:12px">
                <?php echo esc_html($phone); ?>
            </td>
            <td style="padding:8px 10px">
                <div style="display:flex;flex-wrap:wrap;gap:4px">
                <?php foreach ( $signals as $sig ): ?>
                    <span title="+<?php echo (int)$sig['pts']; ?> pts" style="background:#f0f0f0;border-radius:10px;padding:2px 7px;font-size:11px;white-space:nowrap">
                        <?php echo esc_html($sig['icon'] . ' ' . $sig['label']); ?>
                    </span>
                <?php endforeach; ?>
                </div>
            </td>
            <td style="padding:8px 10px;white-space:nowrap;font-size:12px"><?php echo esc_html($ev_fmt); ?></td>
            <td style="padding:8px 10px;text-align:center;white-space:nowrap">
                <a href="https://wa.me/<?php echo esc_attr($phone); ?>" target="_blank"
                   style="background:#25d366;color:#fff;padding:4px 8px;border-radius:5px;text-decoration:none;font-size:11px;display:inline-block;margin:1px">
                    💬 WA
                </a>
                <button type="button"
                    onclick="vm2SendLeadNow(this, <?php echo $send_data; ?>)"
                    style="background:#0079d3;color:#fff;border:none;padding:4px 8px;border-radius:5px;font-size:11px;cursor:pointer;margin:1px">
                    📤 Enviar
                </button>
            </td>
        </tr>
        <?php endforeach; ?>
        </tbody>
    </table>
    </div>

    <script>
    // Channel switch for auto-aquecer panel
    (function() {
        var aaChSel = document.getElementById('vm2-aa-ch');
        if (aaChSel) {
            aaChSel.addEventListener('change', function() {
                vm2StepChannelSwitch('aa', this.value);
            });
        }
    })();

    function vm2StepChannelSwitch(prefix, val) {
        var isWaba = val && val.indexOf('waba') === 0;
        var wabaRows = document.querySelectorAll('[id$="-waba-row"]');
        var zapiRows = document.querySelectorAll('[id$="-zapi-row"]');
        if (prefix === 'aa') {
            var wr = document.getElementById('vm2-aa-waba-row');
            var zr = document.getElementById('vm2-aa-zapi-row');
            if (wr) wr.style.display = isWaba ? '' : 'none';
            if (zr) zr.style.display = isWaba ? 'none' : '';
        }
    }

    function vm2SendLeadNow(btn, data) {
        var phone = data.phone;
        var name  = data.name || 'cliente';
        if (!confirm('Enviar mensagem para ' + name + ' (' + phone + ')?')) return;
        btn.disabled = true;
        btn.textContent = '⏳';
        var nonce = '<?php echo wp_create_nonce("vm2_nonce"); ?>';
        fetch(ajaxurl, {
            method: 'POST',
            headers: {'Content-Type': 'application/x-www-form-urlencoded'},
            body: 'action=vm2_send_lead_now&phone=' + encodeURIComponent(phone) + '&name=' + encodeURIComponent(name) + '&nonce=' + nonce
        })
        .then(r => r.json())
        .then(function(res) {
            if (res.success) {
                btn.textContent = '✅';
                btn.style.background = '#4caf50';
            } else {
                btn.textContent = '❌';
                btn.style.background = '#f44336';
                alert('Erro: ' + (res.data || 'falha no envio'));
            }
        })
        .catch(function() {
            btn.textContent = '❌';
            btn.disabled = false;
        });
    }
    </script>
    </div>

    <div class="vm2-tab-body <?php echo $active_tab === 'bydate' ? 'active' : ''; ?>">

        <div class="vm2-ctrl-bar">
            <label><strong>📅 Por Data do Evento</strong></label>
            <label>Kill Switch:
                <select name="vm2_bydate_kill">
                    <option value="1" <?php selected($bd_kill,'1'); ?>>🔴 PARADO</option>
                    <option value="0" <?php selected($bd_kill,'0'); ?>>🟢 ATIVO</option>
                </select>
            </label>
            <label>Canal:
                <select id="vm2-bd-ch-sel" name="vm2_bydate_channel" onchange="vm2StepChannelSwitch('bd', this.value)">
                    <?php echo vm2_channel_options_html( $bd_ch ); ?>
                </select>
            </label>
            <?php echo $bd_kill === '1' ? '<span class="vm2-ks-on">🔴 PAUSADO</span>' : '<span class="vm2-ks-off">🟢 ATIVO</span>'; ?>
        </div>

        <div class="vm2-bd-grid" id="vm2-bd-groups">
        <?php foreach ($bd_groups as $gkey => $g):
            $g_on   = get_option("vm2_bydate_{$gkey}_on", '0');
            $g_tmpl = get_option("vm2_bydate_{$gkey}_template", $g['tmpl']);
            $g_msg  = get_option("vm2_bydate_{$gkey}_msg", "Oi {nome}! 🎉 Sua festa está chegando! Precisando de mais algum serviço?");
            $cnt    = $bd_counts[$gkey];
        ?>
        <div class="vm2-bd-card" style="border-left-color:<?php echo $g['color']; ?>">
            <div class="vm2-bd-lbl">
                <?php echo $g['label']; ?>
                <label style="font-size:12px;font-weight:400">
                    <input type="checkbox" name="vm2_bydate_<?php echo $gkey; ?>_on" value="1" <?php checked($g_on,'1'); ?>>
                    Ativo
                </label>
            </div>
            <div class="vm2-bd-n" style="color:<?php echo $g['color']; ?>"><?php echo $cnt; ?></div>
            <div style="font-size:11px;color:#57606a;margin-bottom:10px">leads com data neste período</div>
            <div class="vm2-col-waba" style="margin-bottom:8px">
                <span class="vm2-fld-lbl">Template WABA</span>
                <select name="vm2_bydate_<?php echo $gkey; ?>_template" style="width:100%;font-size:12px">
                    <?php foreach ($waba_tpls as $tv => $tl): ?>
                    <option value="<?php echo esc_attr($tv); ?>" <?php selected($g_tmpl,$tv); ?>><?php echo esc_html($tl); ?></option>
                    <?php endforeach; ?>
                </select>
            </div>
            <div class="vm2-col-zapi">
                <span class="vm2-fld-lbl">Texto Z-API</span>
                <textarea name="vm2_bydate_<?php echo $gkey; ?>_msg" style="width:100%;height:54px;resize:vertical;font-size:12px"><?php echo esc_textarea($g_msg); ?></textarea>
            </div>
        </div>
        <?php endforeach; ?>
        </div>

        <?php vm2_render_test_box( 'bydate', $bd_ch, get_option('vm2_bydate_semana_msg', 'Oi {nome}! 🎉 Sua festa está chegando! Precisando de mais algum serviço?'), get_option('vm2_bydate_semana_template','') ); ?>
        <!-- [v1.5.95] EMAIL PARALELO POR DATA -->
        <?php
        $bd_email_on   = get_option('vm2_bydate_email_on', '0');
        $bd_email_subj = get_option('vm2_bydate_email_subject', 'Sua festa está chegando! Vamos fechar as atrações? 🎉');
        $bd_email_body = get_option('vm2_bydate_email_body', "Oi {nome}!\n\nSua festa está se aproximando e ainda dá tempo de garantir atrações incríveis!\n\nAcesse agora e contrate em minutos:\nhttps://loja.vivamaiseventos.com\n\n_Equipe VivaMais Eventos_");
        $bd_email_cnt  = (int)$wpdb->get_var("SELECT COUNT(*) FROM {$wpdb->prefix}vm2_contacts WHERE email != '' AND email IS NOT NULL");
        ?>
        <div style="background:#f0f9ff;border:1px solid #bfdbfe;border-radius:10px;padding:16px 18px;margin-top:16px">
            <div style="display:flex;align-items:center;justify-content:space-between;margin-bottom:12px">
                <strong style="font-size:14px;color:#1e40af">📧 Canal Email — Paralelo ao WA</strong>
                <span style="background:#dbeafe;color:#1e40af;padding:3px 10px;border-radius:20px;font-size:12px;font-weight:600"><?php echo $bd_email_cnt; ?> contatos com email</span>
            </div>
            <p style="font-size:12px;color:#64748b;margin:0 0 14px">
                Quando ativo, envia email em paralelo ao WA para contatos que têm email cadastrado.
                Vars disponíveis: <code>{nome}</code>, <code>{link}</code>
            </p>
            <div style="display:flex;align-items:center;gap:10px;margin-bottom:14px">
                <label style="font-weight:600;font-size:13px">Status:</label>
                <select name="vm2_bydate_email_on" style="padding:6px 10px;border:1px solid #d0d7de;border-radius:6px">
                    <option value="0" <?php selected($bd_email_on,'0'); ?>>🔴 Desativado</option>
                    <option value="1" <?php selected($bd_email_on,'1'); ?>>🟢 Ativo</option>
                </select>
            </div>
            <div style="margin-bottom:12px">
                <label style="font-size:12px;font-weight:600;display:block;margin-bottom:4px">📝 Assunto</label>
                <input type="text" name="vm2_bydate_email_subject" value="<?php echo esc_attr($bd_email_subj); ?>" style="width:100%;padding:7px 10px;border:1px solid #d0d7de;border-radius:6px;font-size:13px">
            </div>
            <div>
                <label style="font-size:12px;font-weight:600;display:block;margin-bottom:4px">💬 Corpo do email</label>
                <textarea name="vm2_bydate_email_body" rows="6" style="width:100%;padding:7px 10px;border:1px solid #d0d7de;border-radius:6px;font-size:12px;font-family:monospace;resize:vertical"><?php echo esc_textarea($bd_email_body); ?></textarea>
            </div>
        </div>
        <div style="margin-top:16px;text-align:right">
            <button type="submit" class="button button-primary">💾 Salvar Configurações</button>
        </div>
    </div>

    <!-- ===== TAB: CARRINHO ===== -->
    <div class="vm2-tab-body <?php echo $active_tab === 'carrinho' ? 'active' : ''; ?>">
        <?php vm2_render_carrinho_tab(); ?>
    </div>

    <!-- ===== TAB: POPUP ===== -->
    <div class="vm2-tab-body <?php echo $active_tab === 'popup' ? 'active' : ''; ?>">
    <?php
    $pp_defaults = [
        'kill_switch'  => 0,
        'banner_topo'  => '🔥 VAGAS LIMITADAS PARA ESTA DATA',
        'titulo'       => 'Garanta sua data antes que acabe! 🎉',
        'subtitulo'    => 'Informe seu WhatsApp para continuar',
        'urgencia'     => '👀 já tem gente de olho nessa data',
        'cta_text'     => '🔒 Garantir minha data →',
        'delay_sec'    => 5,
        'show_on'      => 'produto',
        'session_expiry_hours' => 24,
    ];
    $pp_saved = get_option('vm2_popup_config', []);
    if (!is_array($pp_saved)) $pp_saved = [];
    $pp = array_merge($pp_defaults, $pp_saved);
    $pp_ks    = !empty($pp['kill_switch']);
    $pp_nonce = wp_create_nonce('vm2_popup_save');
    global $wpdb;
    $pp_total = (int)$wpdb->get_var("SELECT COUNT(*) FROM {$wpdb->prefix}vm_wa_captures WHERE status IN ('sent','bought')");
    $pp_shows = (int)get_option('vm2_popup_stat_shows', 0);
    $pp_conv  = (int)get_option('vm2_popup_stat_conversions', 0);
    // Conversão usa contadores recentes (shows + conversions rastreados desde v1.1.2/v1.1.3)
    if ( $pp_shows <= 0 ) {
        $pp_rate = null;
    } else {
        $pp_rate = round($pp_conv / $pp_shows * 100, 1);
    }
    ?>

    <!-- KPI cards -->
    <div class="vm2-kpis" style="grid-template-columns:repeat(auto-fit,minmax(140px,1fr));margin-bottom:20px">
        <div class="vm2-kpi" style="border-left:4px solid #667eea">
            <div class="label">👁️ Exibições</div>
            <div class="value"><?php echo number_format($pp_shows); ?></div>
            <div class="delta neutral">popups mostrados</div>
        </div>
        <div class="vm2-kpi" style="border-left:4px solid #27ae60">
            <div class="label">📱 Cadastros</div>
            <div class="value" style="color:#27ae60"><?php echo number_format($pp_total); ?></div>
            <div class="delta neutral">WhatsApps capturados</div>
        </div>
        <div class="vm2-kpi" style="border-left:4px solid #f39c12">
            <div class="label">📊 Conversão</div>
            <div class="value" style="color:#<?php echo $pp_rate !== null ? 'f39c12' : '999'; ?>"><?php echo $pp_rate !== null ? $pp_rate . '%' : '—'; ?></div>
            <div class="delta neutral"><?php echo $pp_rate !== null ? $pp_conv . ' conversões / ' . $pp_shows . ' exibições' : 'aguardando exibições...'; ?></div>
        </div>
        <div class="vm2-kpi" style="border-left:4px solid #<?php echo $pp_ks ? 'dc3545' : '27ae60'; ?>"
             onclick="var cb=document.getElementById('vm2PpKs');cb.checked=!cb.checked;this.querySelector('.value').textContent=cb.checked?'PARADO':'ATIVO';this.querySelector('.value').style.color=cb.checked?'#dc3545':'#27ae60';this.style.borderLeftColor=cb.checked?'#dc3545':'#27ae60';"
             title="Clique para alternar kill switch" style="cursor:pointer">
            <div class="label">🛑 Status</div>
            <div class="value" style="color:#<?php echo $pp_ks ? 'dc3545' : '27ae60'; ?>;font-size:16px"><?php echo $pp_ks ? 'PARADO' : 'ATIVO'; ?></div>
            <div class="delta neutral">clique para alternar</div>
        </div>
    </div>

    <div class="vm2-grid2">
    <!-- Config -->
    <div class="vm2-card" id="vm2-pp-config">
        <h3>⚙️ Configurações — Popup Captura</h3>

        <div style="margin-bottom:14px">
            <label class="vm2-fld-lbl">🛑 Kill Switch</label>
            <label style="display:flex;align-items:center;gap:8px;cursor:pointer">
                <input type="checkbox" id="vm2PpKs" <?php echo $pp_ks ? 'checked' : ''; ?>>
                <span>Pausar exibição do popup</span>
                <span class="vm2-badge <?php echo $pp_ks ? 'badge-danger' : 'badge-success'; ?>"><?php echo $pp_ks ? 'PARADO' : 'ATIVO'; ?></span>
            </label>
        </div>

        <div style="margin-bottom:14px">
            <label class="vm2-fld-lbl">🔴 Banner topo (faixa vermelha)</label>
            <input type="text" id="vm2PpBanner" value="<?php echo esc_attr($pp['banner_topo']); ?>" style="width:100%">
        </div>

        <div style="margin-bottom:14px">
            <label class="vm2-fld-lbl">📝 Título principal</label>
            <input type="text" id="vm2PpTitulo" value="<?php echo esc_attr($pp['titulo']); ?>" style="width:100%">
        </div>

        <div style="margin-bottom:14px">
            <label class="vm2-fld-lbl">💬 Subtítulo</label>
            <input type="text" id="vm2PpSubtitulo" value="<?php echo esc_attr($pp['subtitulo']); ?>" style="width:100%">
        </div>

        <div style="margin-bottom:14px">
            <label class="vm2-fld-lbl">🔥 Texto de urgência (social proof)</label>
            <input type="text" id="vm2PpUrgencia" value="<?php echo esc_attr($pp['urgencia']); ?>" style="width:100%">
        </div>

        <div style="margin-bottom:14px">
            <label class="vm2-fld-lbl">🔘 Texto do botão CTA</label>
            <input type="text" id="vm2PpCta" value="<?php echo esc_attr($pp['cta_text']); ?>" style="width:100%">
        </div>

        <div style="display:flex;flex-wrap:wrap;gap:16px;margin-bottom:14px">
            <div style="flex:1;min-width:100px">
                <label class="vm2-fld-lbl">⏱️ Delay (segundos)</label>
                <input type="number" id="vm2PpDelay" value="<?php echo (int)$pp['delay_sec']; ?>" min="0" max="60" style="width:100%">
            </div>
            <div style="flex:2;min-width:150px">
                <label class="vm2-fld-lbl">📄 Exibir em</label>
                <select id="vm2PpShowOn" style="width:100%">
                    <option value="produto" <?php echo $pp['show_on']==='produto' ? 'selected' : ''; ?>>Páginas de produto</option>
                    <option value="todas" <?php echo $pp['show_on']==='todas' ? 'selected' : ''; ?>>Todas as páginas</option>
                    <option value="home" <?php echo $pp['show_on']==='home' ? 'selected' : ''; ?>>Apenas home</option>
                    <option value="checkout" <?php echo $pp['show_on']==='checkout' ? 'selected' : ''; ?>>Checkout</option>
                </select>
            </div>
        </div>

        <div style="margin-bottom:14px">
            <label class="vm2-fld-lbl">🔁 Reutilizar sessão por (horas)</label>
            <div style="display:flex;align-items:center;gap:10px">
                <input type="number" id="vm2PpSessionExpiry" value="<?php echo (int)($pp['session_expiry_hours'] ?? 24); ?>" min="1" max="720" style="width:100px">
                <span style="font-size:12px;color:#888">Após esse período, o popup será exibido novamente para capturar novos produtos visitados. (padrão: 24h)</span>
            </div>
        </div>

        <div style="display:flex;justify-content:flex-end;gap:8px;padding-top:10px;border-top:1px solid #e0e0e0">
            <button class="button button-primary" onclick="vm2SavePopupConfig()">💾 Salvar</button>
        </div>
        <div id="vm2-pp-msg" style="margin-top:8px;font-size:12px"></div>
    </div>

    <!-- Preview -->
    <div class="vm2-card">
        <h3>👁 Preview (design atual)</h3>
        <div style="background:rgba(0,0,0,0.07);border-radius:12px;padding:24px;display:flex;align-items:center;justify-content:center;min-height:480px;position:relative">
            <div style="background:rgba(0,0,0,0.5);border-radius:12px;position:absolute;inset:0"></div>
            <div id="vm2-pp-preview" style="position:relative;z-index:2;border-radius:16px;overflow:hidden;box-shadow:0 20px 60px rgba(0,0,0,0.5);max-width:320px;width:100%;background:linear-gradient(180deg,#1a0533 0%,#2d1052 50%,#1a0533 100%)">
                <!-- Banner topo -->
                <div id="vm2-pp-prev-banner" style="text-align:center;padding:8px 12px;color:#fff;font-weight:800;font-size:11px;letter-spacing:1px;background:linear-gradient(90deg,#ff4444,#ff6b35)">
                    <?php echo esc_html($pp['banner_topo']); ?>
                </div>
                <!-- Body -->
                <div style="padding:28px 24px;text-align:center">
                    <!-- WA Icon -->
                    <div style="display:flex;justify-content:center;margin-bottom:16px">
                        <div style="width:64px;height:64px;border-radius:50%;display:flex;align-items:center;justify-content:center;background:radial-gradient(circle,#ff6b6b 0%,#e84393 100%)">
                            <svg viewBox="0 0 24 24" fill="white" width="32" height="32"><path d="M17.472 14.382c-.297-.149-1.758-.867-2.03-.967-.273-.099-.471-.148-.67.15-.197.297-.767.966-.94 1.164-.173.199-.347.223-.644.075-.297-.15-1.255-.463-2.39-1.475-.883-.788-1.48-1.761-1.653-2.059-.173-.297-.018-.458.13-.606.134-.133.298-.347.446-.52.149-.174.198-.298.298-.497.099-.198.05-.371-.025-.52-.075-.149-.669-1.612-.916-2.207-.242-.579-.487-.5-.669-.51-.173-.008-.371-.01-.57-.01-.198 0-.52.074-.792.372-.272.297-1.04 1.016-1.04 2.479 0 1.462 1.065 2.875 1.213 3.074.149.198 2.096 3.2 5.077 4.487.709.306 1.262.489 1.694.625.712.227 1.36.195 1.871.118.571-.085 1.758-.719 2.006-1.413.248-.694.248-1.289.173-1.413-.074-.124-.272-.198-.57-.347m-5.421 7.403h-.004a9.87 9.87 0 01-5.031-1.378l-.361-.214-3.741.982.998-3.648-.235-.374a9.86 9.86 0 01-1.51-5.26c.001-5.45 4.436-9.884 9.888-9.884 2.64 0 5.122 1.03 6.988 2.898a9.825 9.825 0 012.893 6.994c-.003 5.45-4.437 9.884-9.885 9.884m8.413-18.297A11.815 11.815 0 0012.05 0C5.495 0 .16 5.335.157 11.892c0 2.096.547 4.142 1.588 5.945L.057 24l6.305-1.654a11.882 11.882 0 005.683 1.448h.005c6.554 0 11.89-5.335 11.893-11.893a11.821 11.821 0 00-3.48-8.413z"/></svg>
                        </div>
                    </div>
                    <!-- Title -->
                    <h4 id="vm2-pp-prev-titulo" style="color:#fff;font-weight:800;font-size:18px;line-height:1.3;margin-bottom:6px"><?php echo esc_html($pp['titulo']); ?></h4>
                    <p id="vm2-pp-prev-sub" style="color:#d8b4fe;font-size:13px;margin-bottom:14px"><?php echo esc_html($pp['subtitulo']); ?></p>
                    <!-- Urgência -->
                    <div id="vm2-pp-prev-urgencia" style="background:rgba(255,255,255,0.1);border:1px solid rgba(255,255,255,0.2);border-radius:50px;padding:8px 16px;color:#fff;font-size:13px;font-weight:700;margin-bottom:14px">
                        <?php echo esc_html($pp['urgencia']); ?>
                    </div>
                    <!-- Phone input — estado preenchido -->
                    <div style="border:2px solid #ffd700;border-radius:8px;overflow:hidden;margin-bottom:12px">
                        <input type="text" value="(55) 11992-5868" disabled style="width:100%;padding:12px 16px;text-align:center;color:#1a1a2e;background:#fff;border:none;font-size:15px;box-sizing:border-box;font-weight:600">
                    </div>
                    <!-- CTA — estado preenchido (laranja) -->
                    <button id="vm2-pp-prev-cta" style="width:100%;padding:14px;border-radius:8px;font-weight:800;color:#fff;font-size:15px;border:none;cursor:default;background:linear-gradient(90deg,#f97316 0%,#f43f5e 100%);letter-spacing:0.5px;text-transform:uppercase"><?php echo esc_html($pp['cta_text']); ?></button>
                    <!-- Security -->
                    <p style="color:#c4b5fd;font-size:11px;margin-top:10px">🔒 100% seguro</p>
                </div>
            </div>
        </div>
        <p style="font-size:11px;color:#888;text-align:center;margin-top:8px">Popup ativo no site — aparece após <?php echo (int)$pp['delay_sec']; ?>s em páginas de produto.</p>
    </div>
    </div><!-- .vm2-grid2 -->

    <script>
    // Live preview update
    document.addEventListener('DOMContentLoaded', function() {
        var map = {
            'vm2PpBanner':    'vm2-pp-prev-banner',
            'vm2PpTitulo':    'vm2-pp-prev-titulo',
            'vm2PpSubtitulo': 'vm2-pp-prev-sub',
            'vm2PpUrgencia':  'vm2-pp-prev-urgencia',
            'vm2PpCta':       'vm2-pp-prev-cta',
        };
        Object.keys(map).forEach(function(inputId) {
            var el = document.getElementById(inputId);
            if (el) el.addEventListener('input', function() {
                var target = document.getElementById(map[inputId]);
                if (target) target.textContent = el.value;
            });
        });
    });

    function vm2SavePopupConfig() {
        var nonce = <?php echo json_encode($pp_nonce); ?>;
        var data = {
            action: 'vm2_popup_save_config',
            nonce: nonce,
            kill_switch: document.getElementById('vm2PpKs').checked ? 1 : 0,
            banner_topo: document.getElementById('vm2PpBanner').value,
            titulo: document.getElementById('vm2PpTitulo').value,
            subtitulo: document.getElementById('vm2PpSubtitulo').value,
            urgencia: document.getElementById('vm2PpUrgencia').value,
            cta_text: document.getElementById('vm2PpCta').value,
            delay_sec: document.getElementById('vm2PpDelay').value,
            show_on: document.getElementById('vm2PpShowOn').value,
            session_expiry_hours: document.getElementById('vm2PpSessionExpiry').value,
        };
        var fd = new FormData();
        Object.keys(data).forEach(function(k) { fd.append(k, data[k]); });
        var msg = document.getElementById('vm2-pp-msg');
        msg.style.color = '#888';
        msg.textContent = 'Salvando...';
        fetch(ajaxurl, {method:'POST', body:fd})
            .then(function(r) { return r.json(); })
            .then(function(res) {
                if (res.success) {
                    msg.style.color = '#27ae60';
                    msg.textContent = '✅ ' + res.data.message;
                } else {
                    msg.style.color = '#dc3545';
                    msg.textContent = '❌ Erro ao salvar';
                }
            })
            .catch(function() {
                msg.style.color = '#dc3545';
                msg.textContent = '❌ Erro de conexão';
            });
    }
    </script>
    <?php // end tab popup ?>
    </div>

    <!-- ===== TAB: EXIT-INTENT ===== -->
    <div class="vm2-tab-body <?php echo $active_tab === 'exitintent' ? 'active' : ''; ?>">
    <?php
    $ei_defaults = [
        'kill_switch'   => 0,
        'grupo_url'     => 'https://chat.whatsapp.com/BdXPLdQqbgM80IPXVRA3eq',
        'utm_source'    => 'site',
        'utm_medium'    => 'exit_intent',
        'utm_campaign'  => 'grupo_vip',
        'title'         => 'Ei, já vai? 😢',
        'subtitle'      => 'Entre no nosso <strong>Grupo VIP de Ofertas</strong> no WhatsApp e receba promoções exclusivas!',
        'cta_text'      => 'Quero entrar no Grupo VIP! 🎉',
        'cooldown_days' => 7,
        'timer_delay'   => 60,
    ];
    $ei_saved = get_option('vm_ei_config', []);
    if (!is_array($ei_saved)) $ei_saved = [];
    $ei_cfg = array_merge($ei_defaults, $ei_saved);
    $ei_ks     = !empty($ei_cfg['kill_switch']);
    $ei_shows  = (int)get_option('vm_ei_stat_shows', 0);
    $ei_clicks = (int)get_option('vm_ei_stat_clicks', 0);
    $ei_rate   = $ei_shows > 0 ? round($ei_clicks / $ei_shows * 100, 1) : 0;
    $ei_nonce  = wp_create_nonce('vm2_ei_save');
    ?>

    <!-- KPI Cards -->
    <div class="vm2-kpis" style="grid-template-columns:repeat(auto-fit,minmax(140px,1fr))">
        <div class="vm2-kpi" style="border-left:4px solid #667eea" onclick="document.getElementById('vm2-ei-config').scrollIntoView({behavior:'smooth'})" title="Ver configurações">
            <div class="label">👁️ Exibições</div>
            <div class="value"><?php echo $ei_shows; ?></div>
            <div class="delta neutral">popups mostrados</div>
        </div>
        <div class="vm2-kpi" style="border-left:4px solid #27ae60" onclick="document.getElementById('vm2-ei-config').scrollIntoView({behavior:'smooth'})" title="Ver configurações">
            <div class="label">✅ Cliques</div>
            <div class="value" style="color:#27ae60"><?php echo $ei_clicks; ?></div>
            <div class="delta neutral">entradas no grupo</div>
        </div>
        <div class="vm2-kpi" style="border-left:4px solid #f39c12" onclick="document.getElementById('vm2-ei-config').scrollIntoView({behavior:'smooth'})" title="Ver configurações">
            <div class="label">📊 Conversão</div>
            <div class="value" style="color:#f39c12"><?php echo $ei_rate; ?>%</div>
            <div class="delta neutral">cliques / exibições</div>
        </div>
        <div class="vm2-kpi" style="border-left:4px solid #<?php echo $ei_ks ? 'dc3545' : '27ae60'; ?>"
             onclick="var cb=document.getElementById('vm2EiKs');cb.checked=!cb.checked;this.querySelector('.value').textContent=cb.checked?'PARADO':'ATIVO';this.querySelector('.value').style.color=cb.checked?'#dc3545':'#27ae60';this.style.borderLeftColor=cb.checked?'#dc3545':'#27ae60';"
             title="Clique para alternar kill switch">
            <div class="label">🛑 Status</div>
            <div class="value" style="color:#<?php echo $ei_ks ? 'dc3545' : '27ae60'; ?>;font-size:16px"><?php echo $ei_ks ? 'PARADO' : 'ATIVO'; ?></div>
            <div class="delta neutral">clique para alternar</div>
        </div>
    </div>

    <div class="vm2-grid2">
    <!-- Config -->
    <div class="vm2-card" id="vm2-ei-config">
        <h3>⚙️ Configurações</h3>
        <div style="margin-bottom:14px">
            <label class="vm2-fld-lbl">🛑 Kill Switch</label>
            <label style="display:flex;align-items:center;gap:8px;cursor:pointer">
                <input type="checkbox" id="vm2EiKs" <?php echo $ei_ks ? 'checked' : ''; ?>>
                <span>Pausar exibição do popup</span>
            </label>
        </div>
        <div style="margin-bottom:14px">
            <label class="vm2-fld-lbl">🔗 Link do Grupo VIP (WhatsApp)</label>
            <input type="text" id="vm2EiGrupoUrl" value="<?php echo esc_attr($ei_cfg['grupo_url']); ?>" style="width:100%">
        </div>
        <div style="margin-bottom:14px">
            <label class="vm2-fld-lbl">📝 Título do Popup</label>
            <input type="text" id="vm2EiTitle" value="<?php echo esc_attr($ei_cfg['title']); ?>" style="width:100%">
        </div>
        <div style="margin-bottom:14px">
            <label class="vm2-fld-lbl">💬 Subtítulo</label>
            <textarea id="vm2EiSubtitle" style="width:100%;height:60px;resize:vertical;font-size:12px"><?php echo esc_textarea($ei_cfg['subtitle']); ?></textarea>
        </div>
        <div style="margin-bottom:14px">
            <label class="vm2-fld-lbl">🖱️ Texto do Botão CTA</label>
            <input type="text" id="vm2EiCta" value="<?php echo esc_attr($ei_cfg['cta_text']); ?>" style="width:100%">
        </div>
        <div class="vm2-cfg-2col" style="display:grid;grid-template-columns:1fr 1fr;gap:10px;margin-bottom:14px">
            <div>
                <label class="vm2-fld-lbl">⏱️ Cooldown (dias)</label>
                <input type="number" id="vm2EiCooldown" value="<?php echo (int)$ei_cfg['cooldown_days']; ?>" min="0" style="width:100%">
            </div>
            <div>
                <label class="vm2-fld-lbl">⏰ Delay fallback (seg)</label>
                <input type="number" id="vm2EiTimer" value="<?php echo (int)$ei_cfg['timer_delay']; ?>" min="0" style="width:100%">
            </div>
        </div>
        <div style="text-align:right;margin-top:8px">
            <button type="button" class="button button-primary" onclick="vm2EiSave()">💾 Salvar Configurações</button>
            <span id="vm2EiMsg" style="margin-left:10px;font-size:12px;color:#27ae60"></span>
        </div>
    </div>

    <!-- Preview ao vivo -->
    <div class="vm2-card">
        <h3>👁 Preview — Exit Intent</h3>
        <div style="background:rgba(0,0,0,0.07);border-radius:12px;padding:24px;display:flex;align-items:center;justify-content:center;min-height:380px;position:relative">
            <div style="background:rgba(0,0,0,0.5);border-radius:12px;position:absolute;inset:0"></div>
            <!-- Modal preview -->
            <div id="vm2-ei-preview" style="position:relative;z-index:2;background:#fff;border-radius:16px;box-shadow:0 20px 60px rgba(0,0,0,0.5);max-width:320px;width:100%;padding:28px 24px;text-align:center">
                <!-- Emoji -->
                <div style="font-size:48px;margin-bottom:10px">🎉</div>
                <!-- Title -->
                <h4 id="vm2-ei-prev-title" style="font-size:18px;font-weight:800;color:#1a1a2e;margin-bottom:8px;line-height:1.3"><?php echo esc_html($ei_cfg['title']); ?></h4>
                <!-- Subtitle -->
                <p id="vm2-ei-prev-sub" style="font-size:13px;color:#555;margin-bottom:18px;line-height:1.5"><?php echo wp_kses($ei_cfg['subtitle'], ['strong'=>[], 'em'=>[], 'br'=>[]]); ?></p>
                <!-- CTA Button -->
                <a id="vm2-ei-prev-cta" href="#" style="display:block;padding:14px;border-radius:8px;background:#25d366;color:#fff;font-weight:800;font-size:15px;text-decoration:none;letter-spacing:0.3px" onclick="return false"><?php echo esc_html($ei_cfg['cta_text']); ?></a>
                <!-- Close hint -->
                <p style="font-size:11px;color:#aaa;margin-top:12px">× Fechar</p>
            </div>
        </div>
        <p style="font-size:11px;color:#888;text-align:center;margin-top:8px">Gatilhos: scroll 200↓+100↑ · mouseleave topo · timer <?php echo (int)$ei_cfg['timer_delay']; ?>s</p>

        <!-- UTM + Zerar (colapsados abaixo do preview) -->
        <div style="margin-top:14px;padding-top:14px;border-top:1px solid #e0e0e0">
            <label class="vm2-fld-lbl">🔗 Link completo (com UTM)</label>
            <div style="background:#f6f8fa;border:1px solid #e0e0e0;border-radius:6px;padding:8px;font-size:11px;word-break:break-all">
                <code id="vm2-ei-prev-link"><?php echo esc_html($ei_cfg['grupo_url'] . '?utm_source=' . $ei_cfg['utm_source'] . '&utm_medium=' . $ei_cfg['utm_medium'] . '&utm_campaign=' . $ei_cfg['utm_campaign']); ?></code>
            </div>
        </div>
        <div style="margin-top:14px;padding-top:14px;border-top:1px solid #e0e0e0;display:flex;align-items:center;gap:10px">
            <button type="button" class="button" onclick="vm2EiReset()" style="color:#dc3545;border-color:#dc3545">🗑️ Zerar estatísticas</button>
            <span id="vm2EiResetMsg" style="font-size:12px"></span>
        </div>
    </div>
    </div>

    <script>
    // Live preview update — Exit Intent
    document.addEventListener('DOMContentLoaded', function() {
        function vm2EiUpdatePreview() {
            var titleEl = document.getElementById('vm2EiTitle');
            var subEl   = document.getElementById('vm2EiSubtitle');
            var ctaEl   = document.getElementById('vm2EiCta');
            var urlEl   = document.getElementById('vm2EiGrupoUrl');
            if (titleEl) {
                var pt = document.getElementById('vm2-ei-prev-title');
                if (pt) pt.textContent = titleEl.value;
            }
            if (subEl) {
                var ps = document.getElementById('vm2-ei-prev-sub');
                if (ps) ps.innerHTML = subEl.value;
            }
            if (ctaEl) {
                var pc = document.getElementById('vm2-ei-prev-cta');
                if (pc) pc.textContent = ctaEl.value;
            }
            if (urlEl) {
                var pl = document.getElementById('vm2-ei-prev-link');
                var src = document.getElementById('vm2EiUtmSource');
                var med = document.getElementById('vm2EiUtmMedium');
                var cam = document.getElementById('vm2EiUtmCampaign');
                if (pl) {
                    var utmSrc = src ? src.value : 'site';
                    var utmMed = med ? med.value : 'exit_intent';
                    var utmCam = cam ? cam.value : 'grupo_vip';
                    pl.textContent = urlEl.value + '?utm_source=' + utmSrc + '&utm_medium=' + utmMed + '&utm_campaign=' + utmCam;
                }
            }
        }
        ['vm2EiTitle','vm2EiSubtitle','vm2EiCta','vm2EiGrupoUrl'].forEach(function(id) {
            var el = document.getElementById(id);
            if (el) el.addEventListener('input', vm2EiUpdatePreview);
        });
    });

    function vm2EiSave() {
        var fd = new FormData();
        fd.append('action', 'vm2_ei_save');
        fd.append('nonce', '<?php echo $ei_nonce; ?>');
        fd.append('kill_switch', document.getElementById('vm2EiKs').checked ? '1' : '0');
        fd.append('grupo_url',   document.getElementById('vm2EiGrupoUrl').value);
        fd.append('title',       document.getElementById('vm2EiTitle').value);
        fd.append('subtitle',    document.getElementById('vm2EiSubtitle').value);
        fd.append('cta_text',    document.getElementById('vm2EiCta').value);
        fd.append('cooldown_days', document.getElementById('vm2EiCooldown').value);
        fd.append('timer_delay',  document.getElementById('vm2EiTimer').value);
        var msg = document.getElementById('vm2EiMsg');
        msg.textContent = '⏳ Salvando...'; msg.style.color = '#999';
        fetch(ajaxurl, {method:'POST', body:fd})
            .then(r => r.json())
            .then(j => {
                msg.textContent = j.success ? '✅ Salvo com sucesso!' : '❌ Erro ao salvar';
                msg.style.color = j.success ? '#27ae60' : '#dc3545';
            });
    }
    function vm2EiReset() {
        if (!confirm('Zerar estatísticas de exibição e cliques?')) return;
        var fd = new FormData();
        fd.append('action', 'vm2_ei_reset_stats');
        fd.append('nonce', '<?php echo $ei_nonce; ?>');
        var msg = document.getElementById('vm2EiResetMsg');
        msg.textContent = '⏳...';
        fetch(ajaxurl, {method:'POST', body:fd})
            .then(r => r.json())
            .then(j => { if (j.success) { msg.textContent = '✅ Zerado!'; setTimeout(() => location.reload(), 1000); } });
    }
    </script>
    </div>

    <!-- ===== TAB: PÓS-EVENTO ===== -->
    <div class="vm2-tab-body <?php echo $active_tab === 'posevento' ? 'active' : ''; ?>">
        <div class="vm2-placeholder">
            <h3>🎁 Pós-Evento</h3>
            <p>Sequência automática: agradecimento → NPS → pedido de fotos → cupom recompra → indicação.</p>
            <p style="margin-top:12px"><em>Em desenvolvimento — Fase 6</em></p>
        </div>
    </div>

    <!-- ===== TAB: UPSELL ===== -->
    <div class="vm2-tab-body <?php echo $active_tab === 'upsell' ? 'active' : ''; ?>">
        <div class="vm2-placeholder">
            <h3>💎 Upsell</h3>
            <p>Pós-compra + pré-evento + cross-sell de serviços complementares.</p>
            <p style="margin-top:12px"><em>Em desenvolvimento — Fase 6</em></p>
        </div>
    </div>

    <!-- ===== TAB: PEDIDOS ===== -->
    <div class="vm2-tab-body <?php echo $active_tab === 'pedidos' ? 'active' : ''; ?>">
        <div style="text-align:center;padding:40px">
            <p style="font-size:15px;color:#57606a;margin-bottom:16px">O módulo 🛒 Pedidos possui sua própria página dedicada com configurações completas.</p>
            <a href="<?php echo esc_url(admin_url('admin.php?page=vm2-pedidos')); ?>" class="button button-primary" style="font-size:14px;padding:8px 22px">
                🛒 Ir para Módulo Pedidos →
            </a>
        </div>
    </div>

    <script>
    // ── Channel toggle: WABA vs Z-API cols em Aquecer/ByDate ──
    var vm2ChannelTypes = <?php echo json_encode( array_map( function($ch){ return $ch['type'] ?? 'zapi'; }, vm2_channels() ) ); ?>;
    function vm2StepChannelSwitch(module, slug) {
        var isWaba = (vm2ChannelTypes[slug] === 'waba');
        var wrId = module === 'aq' ? 'vm2-aq-steps' : 'vm2-bd-groups';
        var wrap = document.getElementById(wrId);
        if (!wrap) return;
        wrap.querySelectorAll('.vm2-col-waba').forEach(function(el) { el.style.display = isWaba ? '' : 'none'; });
        wrap.querySelectorAll('.vm2-col-zapi').forEach(function(el)  { el.style.display = isWaba ? 'none' : ''; });
    }
    // Init on page load
    (function(){
        var aqSel = document.getElementById('vm2-aq-ch-sel');
        if (aqSel) vm2StepChannelSwitch('aq', aqSel.value);
        var bdSel = document.getElementById('vm2-bd-ch-sel');
        if (bdSel) vm2StepChannelSwitch('bd', bdSel.value);
    })();

    // ─── vm2TestBox — generic test send for automações tabs ───
    function vm2TestBox(boxId, channelKey, nonce, isWaba) {
        var phoneEl = document.getElementById('vm2tb_' + boxId + '_phone');
        var resEl   = document.getElementById('vm2tb_' + boxId + '_result');
        var phone   = phoneEl ? phoneEl.value.replace(/\D/g, '') : '';
        if (!phone || phone.length < 10) {
            resEl.textContent = '\u274C N\u00famero inv\u00e1lido (m\u00edn 10 d\u00edgitos)';
            resEl.style.color = 'red'; return;
        }
        resEl.textContent = '\u23F3 Enviando...'; resEl.style.color = '#888';
        var fd = new FormData();
        fd.append('action',  'vm2_test_send');
        fd.append('nonce',   nonce);
        fd.append('phone',   phone);
        fd.append('channel', channelKey);
        if (isWaba) {
            var tmplEl = document.getElementById('vm2tb_' + boxId + '_tmpl');
            fd.append('template', tmplEl ? tmplEl.value : '');
            fd.append('is_waba',  '1');
        } else {
            var msgEl = document.getElementById('vm2tb_' + boxId + '_msg');
            fd.append('message', msgEl ? msgEl.value : '');
        }
        fetch(ajaxurl, { method: 'POST', body: fd })
          .then(function(r) { return r.json(); })
          .then(function(j) {
            resEl.textContent = j.success
              ? '\u2705 Enviado com sucesso!'
              : ('\u274C ' + (j.data && j.data.message ? j.data.message : 'Erro desconhecido'));
            resEl.style.color = j.success ? 'green' : 'red';
          })
          .catch(function() {
            resEl.textContent = '\u274C Falha de rede';
            resEl.style.color = 'red';
          });
    }
    </script>
    </form>
    </div>
    <?php
}


function vm2_pedidos_page() {

    // ── Restaurar padrões
    if ( isset( $_GET['restore_defaults'] ) && current_user_can( 'manage_options' ) ) {
        check_admin_referer( 'vm2_restore_defaults' );
        update_option( 'vm2_pedidos_vendas_msg',  vm2_default_msg_vendas() );
        update_option( 'vm2_pedidos_agenda_msg',  vm2_default_msg_agenda() );
        update_option( 'vm2_pedidos_cliente_msg', vm2_default_msg_cliente() );
        echo '<div class="notice notice-success"><p>↩ Mensagens restauradas para o padrão!</p></div>';
    }

    // ── Salvar
    if ( isset( $_POST['vm2_save_pedidos'] ) && check_admin_referer( 'vm2_pedidos_nonce' ) ) {
        $toggle_keys = [ 'vm2_pedidos_vendas_enabled', 'vm2_pedidos_agenda_enabled', 'vm2_pedidos_cliente_enabled', 'vm2_pedidos_cliente_copy_vendas' ];
        $text_keys   = [
            'vm2_pedidos_vendas_channel', 'vm2_pedidos_vendas_group_id', 'vm2_pedidos_vendas_msg', 'vm2_pedidos_vendas_waba_template',
            'vm2_pedidos_agenda_channel', 'vm2_pedidos_agenda_group_id', 'vm2_pedidos_agenda_msg', 'vm2_pedidos_agenda_waba_template',
            'vm2_pedidos_cliente_channel', 'vm2_pedidos_cliente_msg', 'vm2_pedidos_cliente_waba_template',
        ];
        foreach ( $toggle_keys as $k ) {
            update_option( $k, isset( $_POST[ $k ] ) ? '1' : '0' );
        }
        foreach ( $text_keys as $k ) {
            if ( isset( $_POST[ $k ] ) ) {
                update_option( $k, sanitize_textarea_field( wp_unslash( $_POST[ $k ] ) ) );
            }
        }
        echo '<div class="notice notice-success"><p>✅ Configurações salvas com sucesso!</p></div>';
    }

    $channels = vm2_channels();
    $ks       = get_option( 'vm2_kill_switch', '0' );

    $vars_info = [
        '{numero}'       => 'Número do pedido',
        '{nome}'         => 'Nome do cliente',
        '{telefone}'     => 'Telefone (com DDI 55)',
        '{email}'        => 'E-mail do cliente',
        '{valor}'        => 'Valor total',
        '{pgto}'         => 'Forma de pagamento',
        '{atracao}'      => 'Produtos/atrações',
        '{data_evento}'  => 'Data do evento (DD/MM/YYYY)',
        '{tipo_evento}'  => 'Tipo do evento',
        '{homenageado}'  => 'Homenageado(s)',
        '{assessor}'     => 'Assessor responsável',
        '{bairro}'       => 'Bairro do evento',
        '{cidade}'       => 'Cidade do evento',
        '{estado}'       => 'Estado do evento',
        '{endereco}'     => 'Endereço completo',
        '{hora_inicio}'  => 'Hora de início (YITH Booking)',
        '{hora_termino}' => 'Hora de término (YITH Booking)',
        '{duracao}'      => 'Duração em minutos',
        '{obs}'          => 'Observações do cliente',
        '{contrato}'     => 'Status contrato ClickSign',
        '{utm_source}'   => 'UTM source',
        '{utm_campaign}' => 'UTM campaign',
        '{link_admin}'   => 'Link do pedido no WP admin',
    ];

    $destinos = [
        [
            'key'             => 'vendas',
            'icon'            => '🛒',
            'title'           => 'Grupo de Vendas',
            'badge'           => 'Todos os pedidos',
            'badge_bg'        => '#27ae60',
            'desc'            => 'Resumo curto enviado ao grupo de vendas. Dispara para qualquer status de pagamento assim que o pedido é criado.',
            'has_group'       => true,
            'default_channel' => 'zapi_7551',
            'default_group'   => '120363425785358764-group',
            'default_msg_fn'  => 'vm2_default_msg_vendas',
        ],
        [
            'key'             => 'agenda',
            'icon'            => '📅',
            'title'           => 'Grupo Agenda de Eventos',
            'badge'           => 'Apenas status: Processing (pago)',
            'badge_bg'        => '#2980b9',
            'desc'            => 'Ficha completa do evento. Disparada apenas quando o pedido entra em status "Processing" (pagamento confirmado).',
            'has_group'       => true,
            'default_channel' => 'zapi_7551',
            'default_group'   => '120363419180214481-group',
            'default_msg_fn'  => 'vm2_default_msg_agenda',
        ],
        [
            'key'             => 'cliente',
            'icon'            => '👤',
            'title'           => 'Cliente (WhatsApp direto)',
            'badge'           => 'OFF por padrão — ative após validar os grupos',
            'badge_bg'        => '#c0392b',
            'desc'            => 'Mensagem enviada diretamente ao WhatsApp do cliente. Mantida OFF por padrão até o fluxo ser validado nos grupos.',
            'has_group'       => false,
            'default_channel' => 'zapi_1886',
            'default_group'   => '',
            'default_msg_fn'  => 'vm2_default_msg_cliente',
        ],
    ];

    ?>
    <div class="wrap">
        <h1>🛒 Notificação de Pedidos</h1>
        <p style="color:#666;margin-bottom:0">Configure os 3 destinos de notificação ao receber um novo pedido WooCommerce. Cada destino é independente.</p>

        <?php if ( $ks === '1' ) : ?>
        <div class="notice notice-error" style="margin-top:12px"><p>🔴 <strong>Kill Switch Global ATIVO</strong> — nenhuma mensagem está saindo. <a href="?page=vm2-settings">Desativar →</a></p></div>
        <?php endif; ?>

        <form method="post" style="margin-top:16px">
            <?php wp_nonce_field( 'vm2_pedidos_nonce' ); ?>

            <?php foreach ( $destinos as $d ) :
                $enabled  = get_option( "vm2_pedidos_{$d['key']}_enabled",  $d['key'] === 'cliente' ? '0' : '1' );
                $channel  = get_option( "vm2_pedidos_{$d['key']}_channel",  $d['default_channel'] );
                $group_id = get_option( "vm2_pedidos_{$d['key']}_group_id", $d['default_group'] );
                $fn       = $d['default_msg_fn'];
                $msg      = get_option( "vm2_pedidos_{$d['key']}_msg",      $fn() );
                $border   = $enabled === '1' ? '#27ae60' : '#e74c3c';
            ?>
            <div style="background:#fff;border:1px solid #ddd;border-left:4px solid <?php echo $border; ?>;border-radius:8px;padding:22px;margin:18px 0">

                <!-- Header -->
                <div style="display:flex;align-items:center;gap:12px;margin-bottom:14px;flex-wrap:wrap">
                    <span style="font-size:26px"><?php echo $d['icon']; ?></span>
                    <div>
                        <strong style="font-size:15px"><?php echo $d['title']; ?></strong>
                        <span style="background:<?php echo $d['badge_bg']; ?>;color:#fff;padding:2px 9px;border-radius:12px;font-size:11px;margin-left:8px"><?php echo $d['badge']; ?></span>
                    </div>
                    <label style="margin-left:auto;display:flex;align-items:center;gap:7px;cursor:pointer;white-space:nowrap">
                        <input type="checkbox" name="vm2_pedidos_<?php echo $d['key']; ?>_enabled" value="1" <?php checked( $enabled, '1' ); ?> style="width:18px;height:18px">
                        <strong style="color:<?php echo $enabled === '1' ? '#27ae60' : '#c0392b'; ?>"><?php echo $enabled === '1' ? '🟢 ON' : '🔴 OFF'; ?></strong>
                    </label>
                </div>

                <p style="color:#666;font-size:13px;margin:0 0 16px 0"><?php echo $d['desc']; ?></p>

                <!-- Configs -->
                <table class="form-table" style="margin:0">
                    <tr>
                        <th style="width:150px;padding:8px 0;font-size:13px">Canal de envio</th>
                        <td style="padding:8px 0">
                            <select name="vm2_pedidos_<?php echo $d['key']; ?>_channel" style="width:280px"
                                onchange="vm2PedChannelSwitch('<?php echo $d['key']; ?>', this.value)">
                                <?php foreach ( $channels as $ck => $ch ) : ?>
                                <option value="<?php echo esc_attr( $ck ); ?>" <?php selected( $channel, $ck ); ?>><?php echo esc_html( $ch['label'] ); ?></option>
                                <?php endforeach; ?>
                            </select>
                        </td>
                    </tr>
                    <tr id="vm2-ped-tpl-<?php echo $d['key']; ?>" style="display:none">
                        <th style="width:150px;padding:8px 0;font-size:13px">📋 Template WABA</th>
                        <td style="padding:8px 0">
                            <select name="vm2_pedidos_<?php echo $d['key']; ?>_waba_template" style="width:380px">
                                <?php echo vm2_waba_template_options_html( get_option("vm2_pedidos_{$d['key']}_waba_template", '') ); ?>
                            </select>
                            <p class="description">Usado apenas quando o canal selecionado for WABA.</p>
                        </td>
                    </tr>
                    <?php if ( $d['has_group'] ) : ?>
                    <tr>
                        <th style="padding:8px 0;font-size:13px">ID do Grupo WA</th>
                        <td style="padding:8px 0">
                            <input type="text" name="vm2_pedidos_<?php echo $d['key']; ?>_group_id"
                                   value="<?php echo esc_attr( $group_id ); ?>"
                                   style="width:370px;font-family:monospace;font-size:12px"
                                   placeholder="ex: 120363425785358764-group">
                            <p class="description">Formato: <code>XXXXXXXXXXXXXXX-group</code></p>
                        </td>
                    </tr>
                    <?php endif; ?>
                    <?php if ( $d['key'] === 'cliente' ) :
                        $copy_vendas = get_option( 'vm2_pedidos_cliente_copy_vendas', '0' );
                    ?>
                    <tr>
                        <th style="padding:8px 0;font-size:13px">📋 Cópia ao grupo de vendas</th>
                        <td style="padding:8px 0">
                            <label style="display:flex;align-items:center;gap:8px;cursor:pointer">
                                <input type="checkbox" name="vm2_pedidos_cliente_copy_vendas" value="1"
                                       <?php checked( $copy_vendas, '1' ); ?>
                                       style="width:18px;height:18px">
                                <span style="font-size:13px">Enviar cópia ao grupo de vendas após o cliente receber o comunicado</span>
                            </label>
                            <p class="description" style="margin-top:6px">
                                Quando ativado, o grupo de vendas recebe uma confirmação com a mensagem que foi enviada ao cliente.
                                Usa o canal e grupo configurados em <strong>🛒 Grupo de Vendas</strong> acima.
                            </p>
                        </td>
                    </tr>
                    <?php endif; ?>
                    <tr id="vm2-ped-msg-<?php echo $d['key']; ?>">
                        <th style="padding:8px 0;font-size:13px;vertical-align:top;padding-top:12px">💬 Mensagem</th>
                        <td style="padding:8px 0">
                            <textarea id="msg_<?php echo $d['key']; ?>" name="vm2_pedidos_<?php echo $d['key']; ?>_msg"
                                      rows="11" style="width:100%;font-family:monospace;font-size:12px;line-height:1.5"><?php echo esc_textarea( $msg ); ?></textarea>
                        </td>
                    </tr>
                </table>

                <!-- Variáveis -->
                <details style="margin-top:8px">
                    <summary style="cursor:pointer;color:#2980b9;font-size:13px;user-select:none">📋 Variáveis disponíveis (clique para ver)</summary>
                    <div style="background:#f8f9fa;padding:12px;border-radius:4px;margin-top:8px;display:flex;flex-wrap:wrap;gap:6px">
                        <?php foreach ( $vars_info as $var => $desc ) : ?>
                        <span onclick="vm2InsertVar('<?php echo $d['key']; ?>','<?php echo $var; ?>')"
                              title="<?php echo esc_attr( $desc ); ?>"
                              style="background:#fff;border:1px solid #ddd;padding:3px 8px;border-radius:4px;font-size:11px;font-family:monospace;cursor:pointer;user-select:none"
                              title="Clique para inserir"><?php echo esc_html( $var ); ?></span>
                        <?php endforeach; ?>
                    </div>
                    <p class="description" style="margin-top:6px">Clique em uma variável para inserir na mensagem na posição do cursor.</p>
                </details>

                <!-- Bloco de Teste -->
                <div style="background:#fffde7;border:1px solid #f9a825;border-radius:6px;padding:16px;margin-top:16px">
                    <strong style="font-size:13px">🧪 Enviar mensagem de teste</strong>
                    <p style="font-size:12px;color:#666;margin:4px 0 12px 0">Envia a mensagem atual (não salva) para um número de teste, substituindo as variáveis com dados do pedido de referência.</p>
                    <div style="display:flex;gap:12px;flex-wrap:wrap;align-items:flex-end">
                        <div>
                            <label style="font-size:12px;font-weight:600;display:block;margin-bottom:4px">📱 Número de teste</label>
                            <input type="text" id="test_phone_<?php echo $d['key']; ?>" value="5511988137551"
                                   style="width:190px;font-family:monospace;font-size:13px" placeholder="5511999...">
                        </div>
                        <div>
                            <label style="font-size:12px;font-weight:600;display:block;margin-bottom:4px">🛒 Pedido de referência (ID)</label>
                            <input type="number" id="test_order_<?php echo $d['key']; ?>" value="4371" style="width:100px;font-size:13px">
                        </div>
                        <div style="display:flex;align-items:center;gap:10px">
                            <button type="button"
                                    onclick="vm2SendTest('<?php echo $d['key']; ?>')"
                                    style="background:#f39c12;color:#fff;border:none;padding:9px 20px;border-radius:6px;cursor:pointer;font-weight:bold;font-size:13px">
                                ▶ Enviar Teste
                            </button>
                            <span id="test_result_<?php echo $d['key']; ?>" style="font-size:13px"></span>
                        </div>
                    </div>
                    <p style="font-size:11px;color:#888;margin:10px 0 0 0">
                        Canal que será usado: <strong><?php echo esc_html( $channels[ $channel ]['label'] ?? $channel ); ?></strong>
                        <?php if ( $d['has_group'] ) : ?> · Destino: <strong>número de teste</strong> (não o grupo) <?php endif; ?>
                    </p>
                </div>

            </div>
            <?php endforeach; ?>

            <!-- Botões -->
            <div style="display:flex;gap:12px;align-items:center;margin-top:8px;flex-wrap:wrap">
                <button type="submit" name="vm2_save_pedidos" class="button button-primary button-large">💾 Salvar todas as configurações</button>
                <a href="<?php echo wp_nonce_url( '?page=vm2-pedidos&restore_defaults=1', 'vm2_restore_defaults' ); ?>"
                   class="button"
                   onclick="return confirm('Restaurar todas as mensagens para o padrão original?')">↩ Restaurar padrões</a>
            </div>

        </form>
    </div>

    <script>
    function vm2InsertVar(destino, varName) {
        var ta = document.getElementById('msg_' + destino);
        if (!ta) return;
        var start = ta.selectionStart;
        var end   = ta.selectionEnd;
        ta.value  = ta.value.substring(0, start) + varName + ta.value.substring(end);
        ta.selectionStart = ta.selectionEnd = start + varName.length;
        ta.focus();
    }

    function vm2SendTest(destino) {
        var phone   = document.getElementById('test_phone_' + destino).value.trim();
        var orderId = document.getElementById('test_order_' + destino).value.trim();
        var resultEl = document.getElementById('test_result_' + destino);
        var msgEl    = document.getElementById('msg_' + destino);
        var channelEl = document.querySelector('select[name="vm2_pedidos_' + destino + '_channel"]');

        if (!phone || phone.replace(/\D/g,'').length < 10) {
            resultEl.textContent = '❌ Número inválido';
            resultEl.style.color = 'red';
            return;
        }

        resultEl.textContent = '⏳ Enviando...';
        resultEl.style.color = '#888';

        var fd = new FormData();
        fd.append('action',   'vm2_test_send');
        fd.append('nonce',    '<?php echo wp_create_nonce( 'vm2_test_send' ); ?>');
        fd.append('destino',  destino);
        fd.append('phone',    phone);
        fd.append('order_id', orderId);
        fd.append('message',  msgEl ? msgEl.value : '');
        fd.append('channel',  channelEl ? channelEl.value : 'zapi_7551');

        fetch(ajaxurl, { method: 'POST', body: fd })
            .then(function(r) { return r.json(); })
            .then(function(json) {
                if (json.success) {
                    resultEl.textContent = '✅ Enviado com sucesso!';
                    resultEl.style.color = 'green';
                } else {
                    resultEl.textContent = '❌ ' + (json.data && json.data.message ? json.data.message : 'Erro desconhecido');
                    resultEl.style.color = 'red';
                }
            })
            .catch(function() {
                resultEl.textContent = '❌ Falha de rede';
                resultEl.style.color = 'red';
            });
    }

    // ─── vm2TestBox — generic test send for automações tabs ───
    function vm2TestBox(boxId, channelKey, nonce, isWaba) {
        var phoneEl = document.getElementById('vm2tb_' + boxId + '_phone');
        var resEl   = document.getElementById('vm2tb_' + boxId + '_result');
        var phone   = phoneEl ? phoneEl.value.replace(/\D/g, '') : '';
        if (!phone || phone.length < 10) {
            resEl.textContent = '\u274C N\u00famero inv\u00e1lido (m\u00edn 10 d\u00edgitos)';
            resEl.style.color = 'red'; return;
        }
        resEl.textContent = '\u23F3 Enviando...'; resEl.style.color = '#888';
        var fd = new FormData();
        fd.append('action',  'vm2_test_send');
        fd.append('nonce',   nonce);
        fd.append('phone',   phone);
        fd.append('channel', channelKey);
        if (isWaba) {
            var tmplEl = document.getElementById('vm2tb_' + boxId + '_tmpl');
            fd.append('template', tmplEl ? tmplEl.value : '');
            fd.append('is_waba',  '1');
        } else {
            var msgEl = document.getElementById('vm2tb_' + boxId + '_msg');
            fd.append('message', msgEl ? msgEl.value : '');
        }
        fetch(ajaxurl, { method: 'POST', body: fd })
          .then(function(r) { return r.json(); })
          .then(function(j) {
            resEl.textContent = j.success
              ? '\u2705 Enviado com sucesso!'
              : ('\u274C ' + (j.data && j.data.message ? j.data.message : 'Erro desconhecido'));
            resEl.style.color = j.success ? 'green' : 'red';
          })
          .catch(function() {
            resEl.textContent = '\u274C Falha de rede';
            resEl.style.color = 'red';
          });
    }
    </script>
    <?php
}

// ─────────────────────────────────────────────────────────────
// GRUPO PROMO PAGE (wrapper V2 — lê/grava as mesmas vm_gp_* options)
// ─────────────────────────────────────────────────────────────
function vm2_grupo_promo_page() {
    if ( ! current_user_can('manage_options') ) return;

    $saved = false;
    if ( isset($_POST['vm2_gp_save']) && check_admin_referer('vm2_gp_save') ) {
        update_option( 'vm_gp_group_id',            sanitize_text_field($_POST['vm_gp_group_id'] ?? '') );
        update_option( 'vm_gp_kill_switch',         isset($_POST['vm_gp_kill_switch']) ? '1' : '0' );
        update_option( 'vm_gp_delay_seconds',       intval($_POST['vm_gp_delay_seconds'] ?? 30) );
        update_option( 'vm_gp_welcome_kill',        isset($_POST['vm_gp_welcome_kill']) ? '1' : '0' );
        update_option( 'vm_gp_silence_from',        intval($_POST['vm_gp_silence_from'] ?? 8) );
        update_option( 'vm_gp_silence_until',       intval($_POST['vm_gp_silence_until'] ?? 22) );
        update_option( 'vm_gp_promo_kill',          isset($_POST['vm_gp_promo_kill']) ? '1' : '0' );
        update_option( 'vm_gp_promo_silence_from',  intval($_POST['vm_gp_promo_silence_from'] ?? 9) );
        update_option( 'vm_gp_promo_silence_until', intval($_POST['vm_gp_promo_silence_until'] ?? 22) );
        $saved = true;
    }

    // Lê valores atuais
    $group_id       = get_option('vm_gp_group_id', '');
    $kill_switch    = get_option('vm_gp_kill_switch', '0') === '1';
    $delay          = intval(get_option('vm_gp_delay_seconds', 30));
    $wel_kill       = get_option('vm_gp_welcome_kill', '0') === '1';
    $wel_from       = intval(get_option('vm_gp_silence_from', 8));
    $wel_until      = intval(get_option('vm_gp_silence_until', 22));
    $promo_kill     = get_option('vm_gp_promo_kill', '0') === '1';
    $promo_from     = intval(get_option('vm_gp_promo_silence_from', 9));
    $promo_until    = intval(get_option('vm_gp_promo_silence_until', 22));

    // Status ao vivo
    $tz  = new DateTimeZone('America/Sao_Paulo');
    $now = new DateTime('now', $tz);
    $h   = (int) $now->format('G');

    $wel_active   = ! $kill_switch && ! $wel_kill && $h >= $wel_from && $h < $wel_until;
    $promo_active = ! $kill_switch && ! $promo_kill && $h >= $promo_from && $h < $promo_until;

    function vm2_gp_status_badge( $active ) {
        if ($active) return '<span style="background:#27ae60;color:#fff;padding:3px 10px;border-radius:20px;font-size:12px;font-weight:600">✅ ATIVO</span>';
        return '<span style="background:#e74c3c;color:#fff;padding:3px 10px;border-radius:20px;font-size:12px;font-weight:600">🔴 SILENCIADO</span>';
    }
    ?>
    <div class="wrap vm2-wrap">
        <h1 style="display:flex;align-items:center;gap:8px;margin-bottom:20px">
            <span style="font-size:26px">💬</span>
            <span>Grupo Promo</span>
            <span class="vm2-version-badge" style="font-size:12px;background:#8e44ad;color:#fff;padding:2px 8px;border-radius:10px;margin-left:4px">v1.0</span>
        </h1>

        <?php if ($saved): ?>
        <div class="notice notice-success is-dismissible" style="margin-bottom:16px"><p>✅ Configurações salvas!</p></div>
        <?php endif; ?>

        <?php if ($kill_switch): ?>
        <div class="notice notice-error" style="margin-bottom:16px">
            <p><strong>🔴 Kill Switch ATIVO</strong> — todos os envios do Grupo Promo estão pausados.</p>
        </div>
        <?php endif; ?>

        <form method="POST">
            <?php wp_nonce_field('vm2_gp_save'); ?>
            <input type="hidden" name="vm2_gp_save" value="1">

            <!-- STATUS AO VIVO -->
            <div class="vm2-card" style="margin-bottom:20px;background:#f8f9fa;border:1px solid #dee2e6">
                <h3 style="margin:0 0 12px;font-size:15px">📡 Status agora (<?php echo $now->format('H:i'); ?>)</h3>
                <div style="display:flex;gap:20px;flex-wrap:wrap">
                    <div style="display:flex;align-items:center;gap:8px">
                        <span style="font-size:13px;color:#555">👋 Boas-vindas:</span>
                        <?php echo vm2_gp_status_badge($wel_active); ?>
                    </div>
                    <div style="display:flex;align-items:center;gap:8px">
                        <span style="font-size:13px;color:#555">🔥 Promos:</span>
                        <?php echo vm2_gp_status_badge($promo_active); ?>
                    </div>
                </div>
            </div>

            <!-- CONFIGURAÇÕES GERAIS -->
            <div class="vm2-card" style="margin-bottom:20px">
                <h3 style="margin:0 0 16px;font-size:16px;display:flex;align-items:center;gap:6px">
                    <span>⚙️</span> Configurações Gerais
                </h3>
                <table class="form-table" style="max-width:600px">
                    <tr>
                        <th style="width:200px;padding:10px 0">
                            <label style="font-size:13px;font-weight:600">🆔 ID do Grupo WhatsApp</label>
                        </th>
                        <td style="padding:8px 0">
                            <input type="text" name="vm_gp_group_id" value="<?php echo esc_attr($group_id); ?>"
                                   style="width:100%;max-width:380px" placeholder="Ex: 120363422642785659-group">
                            <p class="description">ID do grupo WA para envio de promos e boas-vindas.</p>
                        </td>
                    </tr>
                    <tr>
                        <th style="padding:10px 0">
                            <label style="font-size:13px;font-weight:600">🔴 Kill Switch Geral</label>
                        </th>
                        <td style="padding:8px 0">
                            <label style="display:flex;align-items:center;gap:8px;cursor:pointer">
                                <input type="checkbox" name="vm_gp_kill_switch" value="1" <?php checked($kill_switch); ?>>
                                <span>Pausar <strong>TODOS</strong> os envios (boas-vindas + promos)</span>
                            </label>
                        </td>
                    </tr>
                    <tr>
                        <th style="padding:10px 0">
                            <label style="font-size:13px;font-weight:600">⏱️ Delay entre mensagens</label>
                        </th>
                        <td style="padding:8px 0">
                            <div style="display:flex;align-items:center;gap:8px">
                                <input type="number" name="vm_gp_delay_seconds" value="<?php echo esc_attr($delay); ?>"
                                       min="5" max="300" style="width:80px">
                                <span style="font-size:13px;color:#555">segundos</span>
                            </div>
                            <p class="description">Pausa entre envios consecutivos para evitar spam.</p>
                        </td>
                    </tr>
                </table>
            </div>

            <!-- ANTI-SPAM BOAS-VINDAS -->
            <div class="vm2-card" style="margin-bottom:20px;border-left:4px solid #f39c12">
                <h3 style="margin:0 0 4px;font-size:16px;display:flex;align-items:center;gap:6px">
                    <span>👋</span> Anti-Spam — Boas-Vindas
                </h3>
                <p style="margin:0 0 16px;color:#777;font-size:13px">Controla quando a mensagem de boas-vindas para novos membros pode ser enviada.</p>
                <table class="form-table" style="max-width:600px">
                    <tr>
                        <th style="width:200px;padding:10px 0">
                            <label style="font-size:13px;font-weight:600">⏸️ Pausar Boas-Vindas</label>
                        </th>
                        <td style="padding:8px 0">
                            <label style="display:flex;align-items:center;gap:8px;cursor:pointer">
                                <input type="checkbox" name="vm_gp_welcome_kill" value="1" <?php checked($wel_kill); ?>>
                                <span>Desativar envio de boas-vindas temporariamente</span>
                            </label>
                        </td>
                    </tr>
                    <tr>
                        <th style="padding:10px 0">
                            <label style="font-size:13px;font-weight:600">🔇 Silêncio — não enviar antes de</label>
                        </th>
                        <td style="padding:8px 0">
                            <div style="display:flex;align-items:center;gap:8px">
                                <input type="number" name="vm_gp_silence_from" value="<?php echo esc_attr($wel_from); ?>"
                                       min="0" max="23" style="width:70px">
                                <span style="font-size:13px;color:#555">h</span>
                            </div>
                        </td>
                    </tr>
                    <tr>
                        <th style="padding:10px 0">
                            <label style="font-size:13px;font-weight:600">🔇 Silêncio — não enviar a partir de</label>
                        </th>
                        <td style="padding:8px 0">
                            <div style="display:flex;align-items:center;gap:8px">
                                <input type="number" name="vm_gp_silence_until" value="<?php echo esc_attr($wel_until); ?>"
                                       min="0" max="23" style="width:70px">
                                <span style="font-size:13px;color:#555">h</span>
                            </div>
                            <p class="description">Boas-vindas enviadas apenas entre <?php echo $wel_from; ?>h e <?php echo $wel_until; ?>h.</p>
                        </td>
                    </tr>
                </table>
            </div>

            <!-- ANTI-SPAM PROMOS -->
            <div class="vm2-card" style="margin-bottom:20px;border-left:4px solid #e74c3c">
                <h3 style="margin:0 0 4px;font-size:16px;display:flex;align-items:center;gap:6px">
                    <span>🔥</span> Anti-Spam — Promos
                </h3>
                <p style="margin:0 0 16px;color:#777;font-size:13px">Janela de envio das promos automáticas para o grupo.</p>
                <table class="form-table" style="max-width:600px">
                    <tr>
                        <th style="width:200px;padding:10px 0">
                            <label style="font-size:13px;font-weight:600">⏸️ Pausar Promos</label>
                        </th>
                        <td style="padding:8px 0">
                            <label style="display:flex;align-items:center;gap:8px;cursor:pointer">
                                <input type="checkbox" name="vm_gp_promo_kill" value="1" <?php checked($promo_kill); ?>>
                                <span>Desativar envio de promos temporariamente</span>
                            </label>
                        </td>
                    </tr>
                    <tr>
                        <th style="padding:10px 0">
                            <label style="font-size:13px;font-weight:600">🕐 Janela — não enviar antes de</label>
                        </th>
                        <td style="padding:8px 0">
                            <div style="display:flex;align-items:center;gap:8px">
                                <input type="number" name="vm_gp_promo_silence_from" value="<?php echo esc_attr($promo_from); ?>"
                                       min="0" max="23" style="width:70px">
                                <span style="font-size:13px;color:#555">h</span>
                            </div>
                        </td>
                    </tr>
                    <tr>
                        <th style="padding:10px 0">
                            <label style="font-size:13px;font-weight:600">🕐 Janela — não enviar a partir de</label>
                        </th>
                        <td style="padding:8px 0">
                            <div style="display:flex;align-items:center;gap:8px">
                                <input type="number" name="vm_gp_promo_silence_until" value="<?php echo esc_attr($promo_until); ?>"
                                       min="0" max="23" style="width:70px">
                                <span style="font-size:13px;color:#555">h</span>
                            </div>
                            <p class="description">Promos automáticas só disparam dentro dessa janela.</p>
                        </td>
                    </tr>
                </table>
            </div>

            <button type="submit" class="button button-primary" style="font-size:14px;padding:8px 20px">
                💾 Salvar Configurações
            </button>
        </form>

        <div style="margin-top:20px;padding:12px 16px;background:#fff3cd;border:1px solid #ffc107;border-radius:6px;font-size:13px;color:#856404">
            💡 <strong>Nota:</strong> Esta página gerencia as mesmas configurações do plugin <em>VivaMais — Grupo Promo Admin</em>.
            As alterações aqui refletem imediatamente no comportamento do grupo.
        </div>
    </div>
    <?php
}

// ─────────────────────────────────────────────────────────────
// SETTINGS PAGE
// ─────────────────────────────────────────────────────────────

// ═══════════════════════════════════════════════════════════════════
// 💬 WA RECOVERY — Gestão completa integrada no V2
// ═══════════════════════════════════════════════════════════════════
function vm2_render_carrinho_tab() {
    global $wpdb;
    $table = $wpdb->prefix . 'vm_wa_captures';

    // Verificar se tabela existe
    if ($wpdb->get_var("SHOW TABLES LIKE '$table'") !== $table) {
        echo '<div style="background:#fff3cd;border:1px solid #ffc107;padding:20px;border-radius:10px;margin:20px 0">';
        echo '<h3 style="margin:0 0 8px">⚠️ Plugin WA Recovery não encontrado</h3>';
        echo '<p style="margin:0">Ative o plugin <strong>VivaMais WA Cart Recovery</strong> para usar este módulo.</p>';
        echo '</div>';
        return;
    }

    $filter = isset($_GET['vm2_wa_status']) ? sanitize_text_field($_GET['vm2_wa_status']) : 'today';
    $today_date = current_time('Y-m-d'); // usa timezone do WordPress (Brasil, GMT-3)
    if ($filter === 'today') {
        $where = $wpdb->prepare(" WHERE DATE(captured_at) = %s", $today_date);
    } elseif ($filter !== 'all') {
        $where = $wpdb->prepare(" WHERE status=%s", $filter);
    } else {
        $where = '';
    }
    $rows   = $wpdb->get_results("SELECT * FROM {$table}{$where} ORDER BY captured_at DESC LIMIT 300");

    $total     = (int)$wpdb->get_var("SELECT COUNT(*) FROM $table");
    $today_cnt = (int)$wpdb->get_var($wpdb->prepare("SELECT COUNT(*) FROM $table WHERE DATE(captured_at) = %s", $today_date));
    $sent      = (int)$wpdb->get_var("SELECT COUNT(*) FROM $table WHERE status='sent'");
    $failed    = (int)$wpdb->get_var("SELECT COUNT(*) FROM $table WHERE status='failed'");
    $pending   = (int)$wpdb->get_var("SELECT COUNT(*) FROM $table WHERE status='pending'");
    $cancelled = (int)$wpdb->get_var("SELECT COUNT(*) FROM $table WHERE status='cancelled'");
    $expired   = (int)$wpdb->get_var("SELECT COUNT(*) FROM $table WHERE status='expired'");
    $dnd_skip  = (int)$wpdb->get_var("SELECT COUNT(*) FROM $table WHERE status='dnd_skip'");

    $val_pending   = (float)($wpdb->get_var("SELECT SUM(cart_total) FROM $table WHERE status='pending'") ?: 0);
    $val_sent      = (float)($wpdb->get_var("SELECT SUM(cart_total) FROM $table WHERE status='sent'") ?: 0);
    $val_cancelled = (float)($wpdb->get_var("SELECT SUM(cart_total) FROM $table WHERE status='cancelled'") ?: 0);

    // Config
    $channel     = get_option('vm_wa_send_channel', 'zapi_1886');
    $kill_switch = (bool)get_option('vm_wa_kill_switch', 0);
    $batch_size  = (int)get_option('vm_wa_batch_size', 20);
    $quiet_start = (int)get_option('vm_wa_quiet_start', 8);
    $quiet_end   = (int)get_option('vm_wa_quiet_end', 20);
    $interval    = (int)get_option('vm_wa_interval_sec', 3);
    $custom_msg  = get_option('vm_wa_recovery_message', '');

    $nonce     = wp_create_nonce('vm_wa_resend');
    $cfg_nonce = wp_create_nonce('vm2_wa_config');
    $base_url  = admin_url('admin.php?page=vm2-automacoes&tab=carrinho');
    $is_waba   = isset( vm2_channels()[$channel] ) && ( vm2_channels()[$channel]['type'] ?? 'zapi' ) === 'waba';
    $wa_tpl    = get_option( 'vm_wa_waba_template', 'recupera_carrinho_woo' );

    $channel_labels = vm2_channel_labels();
    $channel_label  = $channel_labels[$channel] ?? $channel;

    $taxa_envio = $total > 0 ? round(($sent / $total) * 100) : 0;
    $taxa_conv  = $sent  > 0 ? round(($cancelled / $sent) * 100) : 0;

    ?>
    <style>
    /* ── Carrinho mobile-first ── */
    .vm2-wa-cfg-grid {
        display: grid;
        grid-template-columns: 1fr 1fr;
        gap: 12px;
        margin-bottom: 14px;
    }
    @media (max-width: 600px) {
        .vm2-wa-cfg-grid { grid-template-columns: 1fr; }
    }
    /* Tabela: esconder colunas secundárias no mobile */
    @media (max-width: 640px) {
        .vm2-wa-table th:nth-child(1),
        .vm2-wa-table td:nth-child(1),
        .vm2-wa-table th:nth-child(7),
        .vm2-wa-table td:nth-child(7),
        .vm2-wa-table th:nth-child(9),
        .vm2-wa-table td:nth-child(9),
        .vm2-wa-table th:nth-child(10),
        .vm2-wa-table td:nth-child(10) { display: none; }
        .vm2-wa-table { font-size: 11px; }
        .vm2-wa-table th, .vm2-wa-table td { padding: 6px 8px !important; }
    }
    </style>
    <?php if ($kill_switch): ?>
    <div style="background:#dc3545;color:#fff;padding:12px 20px;border-radius:10px;margin:0 0 16px;font-size:14px">
        🛑 <strong>ENVIOS PARADOS</strong> — Kill switch ativo. Desative em ⚙️ Configurações abaixo.
    </div>
    <?php endif; ?>

    <!-- ── KPI Cards ── -->
    <div class="vm2-kpis" style="grid-template-columns:repeat(auto-fit,minmax(160px,1fr))">
        <div class="vm2-kpi" onclick="vm2WaFilter('all')" style="border-left:4px solid #34495e">
            <div class="label">📦 Total Capturas</div>
            <div class="value"><?php echo $total; ?></div>
            <div class="delta neutral">todos os registros</div>
        </div>
        <div class="vm2-kpi" onclick="vm2WaFilter('sent')" style="border-left:4px solid #27ae60">
            <div class="label">✅ Enviados</div>
            <div class="value" style="color:#27ae60"><?php echo $sent; ?></div>
            <div class="delta neutral">R$ <?php echo number_format($val_sent,2,',','.'); ?></div>
        </div>
        <div class="vm2-kpi" onclick="vm2WaFilter('pending')" style="border-left:4px solid #e67e22">
            <div class="label">⏳ Pendentes</div>
            <div class="value" style="color:#e67e22"><?php echo $pending; ?></div>
            <div class="delta neutral">R$ <?php echo number_format($val_pending,2,',','.'); ?></div>
        </div>
        <div class="vm2-kpi" onclick="vm2WaFilter('failed')" style="border-left:4px solid #c0392b">
            <div class="label">❌ Falhou</div>
            <div class="value" style="color:#c0392b"><?php echo $failed; ?></div>
            <div class="delta neutral">erros de envio</div>
        </div>
        <div class="vm2-kpi" onclick="vm2WaFilter('cancelled')" style="border-left:4px solid #27ae60">
            <div class="label">🛒 Convertidos</div>
            <div class="value" style="color:#27ae60"><?php echo $cancelled; ?></div>
            <div class="delta neutral">R$ <?php echo number_format($val_cancelled,2,',','.'); ?></div>
        </div>
        <div class="vm2-kpi" style="border-left:4px solid #9b59b6;cursor:default">
            <div class="label">📊 Taxa de Envio</div>
            <div class="value" style="color:#9b59b6"><?php echo $taxa_envio; ?>%</div>
            <div class="delta neutral">enviados / total</div>
        </div>
        <div class="vm2-kpi" style="border-left:4px solid #f39c12;cursor:default">
            <div class="label">🎯 Taxa Conversão</div>
            <div class="value" style="color:#f39c12"><?php echo $taxa_conv; ?>%</div>
            <div class="delta neutral">compraram após envio</div>
        </div>
    </div>

    <div class="vm2-grid2">

    <!-- ── Config ── -->
    <div class="vm2-card">
        <h3>⚙️ Configurações</h3>

        <div style="margin-bottom:14px">
            <div class="vm2-section-label">📡 Canal de Envio</div>
            <?php echo vm2_channel_radio_html( 'vm2_wa_channel', $channel ); ?>
        </div>
        <div id="vm2-wa-tpl-row" style="margin-top:10px;<?php echo $is_waba ? '' : 'display:none'; ?>">
            <div class="vm2-section-label">📋 Template WABA</div>
            <select id="vm2-wa-tpl-sel" style="width:100%;max-width:420px;padding:6px 8px;border:1px solid #ddd;border-radius:6px">
                <?php echo vm2_waba_template_options_html( $wa_tpl ); ?>
            </select>
        </div>

        <div class="vm2-wa-cfg-grid">
            <div>
                <div class="vm2-section-label">🛑 Kill Switch</div>
                <label style="cursor:pointer;font-size:13px;display:flex;align-items:center;gap:6px">
                    <input type="checkbox" id="vm2-wa-ks" <?php checked($kill_switch); ?>>
                    Pausar todos os envios
                </label>
            </div>
            <div>
                <div class="vm2-section-label">📦 Msgs por lote</div>
                <input type="number" id="vm2-wa-batch" value="<?php echo $batch_size; ?>" min="1" max="100"
                       style="width:70px;padding:4px 8px;border:1px solid #ddd;border-radius:6px">
            </div>
            <div>
                <div class="vm2-section-label">🔇 Silêncio a partir das</div>
                <input type="number" id="vm2-wa-qstart" value="<?php echo $quiet_start; ?>" min="0" max="23"
                       style="width:60px;padding:4px 8px;border:1px solid #ddd;border-radius:6px">h
            </div>
            <div>
                <div class="vm2-section-label">🔇 Silêncio até</div>
                <input type="number" id="vm2-wa-qend" value="<?php echo $quiet_end; ?>" min="0" max="23"
                       style="width:60px;padding:4px 8px;border:1px solid #ddd;border-radius:6px">h
            </div>
            <div>
                <div class="vm2-section-label">⏱ Intervalo entre envios</div>
                <input type="number" id="vm2-wa-interval" value="<?php echo $interval; ?>" min="0" max="60"
                       style="width:60px;padding:4px 8px;border:1px solid #ddd;border-radius:6px"> seg
            </div>
        </div>

        <button class="button button-primary" onclick="vm2WaSaveConfig()" id="vm2-wa-save-cfg-btn">
            💾 Salvar Configurações
        </button>
        <span id="vm2-wa-cfg-status" style="margin-left:10px;font-size:13px"></span>
    </div>

    <!-- ── Mensagem ── -->
    <div id="vm2-wa-msg-card" style="<?php echo $is_waba ? 'display:none' : ''; ?>">
    <div class="vm2-card">
        <h3>✏️ Mensagem de Recuperação</h3>
        <p style="color:#888;font-size:12px;margin:0 0 8px">
            Placeholders: <code>{nome}</code> <code>{produto}</code> <code>{valor}</code> <code>{link}</code>
        </p>
        <?php
        $default_msg = "Oi {nome}! Aqui é da VivaMais Eventos 🎉\n\nVi que você se interessou por *{produto}* mas não finalizou a reserva.\n\nPosso te ajudar a concluir? Sua vaga ainda está disponível! 🎊\n\n👉 Finalize aqui: {link}\n\nAtendimento: https://wa.me/5511947771886";
        ?>
        <textarea id="vm2-wa-msg" rows="8"
                  style="width:100%;font-size:13px;font-family:monospace;border:1px solid #ddd;border-radius:6px;padding:8px"
                  placeholder="<?php echo esc_attr($default_msg); ?>"><?php echo esc_textarea($custom_msg); ?></textarea>
        <div style="margin-top:8px;display:flex;align-items:center;gap:10px">
            <button class="button button-primary" onclick="vm2WaSaveMsg()" id="vm2-wa-save-msg-btn">💾 Salvar Mensagem</button>
            <span id="vm2-wa-msg-status" style="font-size:13px"></span>
        </div>
    </div><!-- vm2-card -->
    </div><!-- vm2-wa-msg-card -->
    </div><!-- /grid2 -->

    <!-- ── Tabs filtro ── -->
    <div style="display:flex;flex-wrap:wrap;gap:4px;margin:16px 0 12px;border-bottom:2px solid #eee;padding-bottom:8px">
        <?php
        $tabs = [
            'today'     => "📅 Hoje ({$today_cnt})",
            'all'       => "Todos ({$total})",
            'sent'      => "✅ Enviados ({$sent})",
            'pending'   => "⏳ Pendentes ({$pending})",
            'failed'    => "❌ Falhou ({$failed})",
            'cancelled' => "🛒 Compraram ({$cancelled})",
            'expired'   => "⏱ Expirados ({$expired})",
            'dnd_skip'  => "🚫 DND ({$dnd_skip})",
        ];
        foreach ($tabs as $key => $label):
            $active = $filter === $key ? 'background:#0073aa;color:#fff;border-color:#0073aa' : 'background:#f5f5f5;color:#555;border-color:#ddd';
        ?>
        <a href="<?php echo $base_url; ?>&vm2_wa_status=<?php echo $key; ?>"
           style="<?php echo $active; ?>;padding:6px 14px;border-radius:20px;text-decoration:none;font-size:12px;border:1px solid;transition:all .15s">
            <?php echo $label; ?>
        </a>
        <?php endforeach; ?>
    </div>

    <!-- ── Tabela ── -->
    <div class="vm2-card" style="padding:0">
        <div style="overflow-x:auto;-webkit-overflow-scrolling:touch">
        <table class="vm2-wa-table" style="width:100%;border-collapse:collapse;font-size:12px">
            <thead>
                <tr id="vm2-cart-thead" style="background:#f8f9fa;border-bottom:2px solid #eee;cursor:pointer;user-select:none">
                    <th data-col="0" data-dir="desc" style="padding:10px 12px;text-align:left;white-space:nowrap">⏰ Acessou <span class="vm2-sort-icon">▼</span></th>
                    <th data-col="1" style="padding:10px 12px;text-align:left;white-space:nowrap"># <span class="vm2-sort-icon"></span></th>
                    <th data-col="2" style="padding:10px 12px;text-align:left;white-space:nowrap">Telefone <span class="vm2-sort-icon"></span></th>
                    <th data-col="3" style="padding:10px 12px;text-align:left">Nome <span class="vm2-sort-icon"></span></th>
                    <th data-col="4" style="padding:10px 12px;text-align:left">Produto <span class="vm2-sort-icon"></span></th>
                    <th data-col="5" style="padding:10px 12px;text-align:right;white-space:nowrap">Valor <span class="vm2-sort-icon"></span></th>
                    <th data-col="6" style="padding:10px 12px;text-align:center;white-space:nowrap">🔗 URL <span class="vm2-sort-icon"></span></th>
                    <th data-col="7" style="padding:10px 12px;text-align:center;white-space:nowrap">📤 Enviado <span class="vm2-sort-icon"></span></th>
                    <th data-col="8" style="padding:10px 12px;text-align:center">Status <span class="vm2-sort-icon"></span></th>
                    <th data-col="9" style="padding:10px 12px;text-align:center">Pedido <span class="vm2-sort-icon"></span></th>
                    <th data-col="10" style="padding:10px 12px;text-align:left">Resposta API <span class="vm2-sort-icon"></span></th>
                    <th data-col="11" style="padding:10px 12px;text-align:center">Ação <span class="vm2-sort-icon"></span></th>
                </tr>
            </thead>
            <tbody>
            <?php
            $status_cfg = [
                'sent'      => ['#27ae60', '✅ Enviado'],
                'pending'   => ['#e67e22', '⏳ Pendente'],
                'failed'    => ['#c0392b', '❌ Falhou'],
                'cancelled' => ['#27ae60', '🛒 Comprou'],
                'expired'   => ['#95a5a6', '⏱ Expirado'],
                'dnd_skip'  => ['#9b59b6', '🚫 DND'],
            ];
            if (empty($rows)):
            ?>
            <tr><td colspan="12" style="padding:40px;text-align:center;color:#aaa">
                Nenhum registro encontrado para este filtro.
            </td></tr>
            <?php else: foreach ($rows as $r):
                [$sc, $sl] = $status_cfg[$r->status] ?? ['#555', $r->status];
                $tempo = '—';
                if ($r->sent_at && $r->captured_at) {
                    $diff = strtotime($r->sent_at) - strtotime($r->captured_at);
                    $tempo = $diff < 60 ? "{$diff}s" : round($diff/60) . 'min';
                }
                $api_short = '—';
                $api_title = '';
                if ($r->api_response) {
                    $decoded = json_decode($r->api_response, true);
                    if (isset($decoded['messages'][0]['id'])) {
                        $api_short = '✅ …' . substr($decoded['messages'][0]['id'], -10);
                    } elseif (isset($decoded['error']['message'])) {
                        $api_short = '❌ ' . substr($decoded['error']['message'], 0, 40);
                    } elseif (strlen($r->api_response) < 60) {
                        $api_short = $r->api_response;
                    } else {
                        $api_short = substr($r->api_response, 0, 50) . '…';
                    }
                    $api_title = esc_attr($r->api_response);
                }
                $order_link = '—';
                if ($r->order_id) {
                    $order_link = '<a href="' . admin_url("post.php?post={$r->order_id}&action=edit") . '" target="_blank" style="color:#0073aa">#' . esc_html($r->order_id) . '</a>';
                }
                $btn = '';
                if (in_array($r->status, ['failed','pending','dnd_skip'])) {
                    $btn = "<button class='button button-small vm2-resend-btn' data-id='{$r->id}' data-nonce='{$nonce}' style='font-size:11px'>🔁</button>";
                }
                $valor = $r->cart_total ? 'R$ ' . number_format((float)$r->cart_total, 2, ',', '.') : '—';
                $zebra = $r->id % 2 === 0 ? 'background:#fafafa' : 'background:#fff';
            ?>
            <tr style="<?php echo $zebra; ?>;border-bottom:1px solid #f0f0f0">
                <td style="padding:8px 12px;white-space:nowrap;color:#555" title="<?php echo esc_attr($r->captured_at); ?>" data-val="<?php echo esc_attr($r->captured_at); ?>">
                <?php
                $ts = strtotime($r->captured_at);
                $today_ts = strtotime(current_time('Y-m-d'));
                if ($ts >= $today_ts && $ts < $today_ts + 86400) {
                    echo '<span style="color:#888;font-size:10px;display:block;line-height:1">Hoje</span>' . date('H:i', $ts);
                } else {
                    echo date('d/m', $ts) . '<span style="color:#aaa;font-size:10px;margin-left:2px">' . date('H:i', $ts) . '</span>';
                }
                ?>
                </td>
                <td style="padding:8px 12px;color:#999" data-val="<?php echo $r->id; ?>"><?php echo $r->id; ?></td>
                <td style="padding:8px 12px;white-space:nowrap;font-weight:500"><?php echo esc_html($r->phone); ?></td>
                <td style="padding:8px 12px"><?php echo esc_html($r->name ?: '—'); ?></td>
                <td style="padding:8px 12px;max-width:180px;overflow:hidden;white-space:nowrap" title="<?php echo esc_attr($r->product_name); ?>"><?php echo esc_html($r->product_name ?: '—'); ?></td>
                <td style="padding:8px 12px;text-align:right;font-weight:600;white-space:nowrap" data-val="<?php echo $r->cart_total ? (float)$r->cart_total : 0; ?>"><?php echo $valor; ?></td>
                <td style="padding:8px 12px;text-align:center">
                    <?php
                    $link_url = !empty($r->page_url) ? $r->page_url : (!empty($r->cart_url) ? home_url($r->cart_url) : '');
                    if ($link_url):
                    ?><a href="<?php echo esc_url($link_url); ?>" target="_blank" style="color:#0073aa;font-size:11px" title="<?php echo esc_attr($link_url); ?>">🔗</a><?php
                    else: ?>—<?php endif; ?>
                </td>

                <td style="padding:8px 12px;text-align:center;white-space:nowrap" data-val="<?php echo $r->sent_at ? esc_attr($r->sent_at) : '0000-00-00 00:00:00'; ?>">
                <?php if ($r->sent_at): ?>
                    <span style="font-weight:600;font-size:12px"><?php echo date('H:i', strtotime($r->sent_at)); ?></span>
                    <span style="color:#aaa;font-size:10px;display:block;line-height:1">(+<?php echo $tempo; ?>)</span>
                <?php else: ?>
                    <span style="color:#aaa">—</span>
                <?php endif; ?>
                </td>
                <td style="padding:8px 12px;text-align:center">
                    <span style="background:<?php echo $sc; ?>;color:#fff;padding:3px 10px;border-radius:12px;font-size:11px;font-weight:600;white-space:nowrap">
                        <?php echo $sl; ?>
                    </span>
                </td>
                <td style="padding:8px 12px;text-align:center"><?php echo $order_link; ?></td>
                <td style="padding:8px 12px;max-width:160px;overflow:hidden;white-space:nowrap;font-size:11px;color:#666"
                    title="<?php echo $api_title; ?>"><?php echo esc_html($api_short); ?></td>
                <td style="padding:8px 12px;text-align:center"><?php echo $btn; ?></td>
            </tr>
            <?php endforeach; endif; ?>
            </tbody>
        </table>
        </div>
    </div>

    <script>
    // ── Sort da tabela Carrinho ──
    (function(){
      var thead = document.getElementById('vm2-cart-thead');
      if(!thead) return;
      var table = thead.closest('table');
      thead.querySelectorAll('th[data-col]').forEach(function(th){
        th.style.cursor='pointer';
        th.addEventListener('click', function(){
          var col = parseInt(th.getAttribute('data-col'));
          var dir = th.getAttribute('data-dir')==='asc'?'desc':'asc';
          thead.querySelectorAll('.vm2-sort-icon').forEach(function(s){s.textContent='';});
          th.querySelector('.vm2-sort-icon').textContent = dir==='asc'?'▲':'▼';
          thead.querySelectorAll('th').forEach(function(t){t.removeAttribute('data-dir');});
          th.setAttribute('data-dir', dir);
          var tbody = table.querySelector('tbody');
          var rows = Array.from(tbody.querySelectorAll('tr'));
          rows.sort(function(a,b){
            var cellA = a.querySelectorAll('td')[col];
            var cellB = b.querySelectorAll('td')[col];
            if(!cellA||!cellB) return 0;
            var va = (cellA.getAttribute('data-val')||cellA.textContent).trim();
            var vb = (cellB.getAttribute('data-val')||cellB.textContent).trim();
            var fa = parseFloat(va.replace(/[^0-9.\-]/g,'')), fb = parseFloat(vb.replace(/[^0-9.\-]/g,''));
            var cmp = (!isNaN(fa)&&!isNaN(fb)) ? fa-fb : va.localeCompare(vb,'pt',{numeric:true,sensitivity:'base'});
            return dir==='asc'?cmp:-cmp;
          });
          rows.forEach(function(r){tbody.appendChild(r);});
        });
      });
      // sort inicial: col 0 (⏰ Acessou) desc
      setTimeout(function(){
        var th0 = thead.querySelector('th[data-col="0"]');
        if(th0){ th0.setAttribute('data-dir','asc'); th0.click(); }
      }, 80);
    })();

    // ── Filtro por card KPI ──
    function vm2WaFilter(status) {
        var base = <?php echo json_encode($base_url); ?>;
        window.location.href = base + '&vm2_wa_status=' + status;
    }

    // ── Reenviar ──
    document.querySelectorAll('.vm2-resend-btn').forEach(function(btn) {
        btn.addEventListener('click', function() {
            var id    = this.dataset.id;
            var nonce = this.dataset.nonce;
            var el    = this;
            el.disabled = true;
            el.textContent = '⏳';
            fetch(ajaxurl, {
                method: 'POST',
                headers: {'Content-Type':'application/x-www-form-urlencoded'},
                body: 'action=vm2_wa_resend&id=' + id + '&nonce=' + nonce
            })
            .then(function(r) { return r.json(); })
            .then(function(data) {
                if (data.success) {
                    el.textContent = '✅';
                    el.style.background = '#27ae60';
                    el.style.color = '#fff';
                    el.style.borderColor = '#27ae60';
                } else {
                    el.textContent = '❌';
                    el.disabled = false;
                    alert(data.data);
                }
            });
        });
    });

    // ── Salvar mensagem ──
    function vm2WaSaveMsg() {
        var btn    = document.getElementById('vm2-wa-save-msg-btn');
        var status = document.getElementById('vm2-wa-msg-status');
        var msg    = document.getElementById('vm2-wa-msg').value;
        btn.disabled = true;
        status.textContent = '⏳ Salvando…';
        fetch(ajaxurl, {
            method: 'POST',
            headers: {'Content-Type':'application/x-www-form-urlencoded'},
            body: 'action=vm_wa_save_recovery_msg&message=' + encodeURIComponent(msg) + '&nonce=<?php echo esc_js($nonce); ?>'
        })
        .then(function(r) { return r.json(); })
        .then(function(data) {
            btn.disabled = false;
            status.textContent = data.success ? '✅ Salvo!' : '❌ Erro';
            setTimeout(function() { status.textContent = ''; }, 3000);
        });
    }

    // ── Salvar config ──
    function vm2WaChannelSwitch(slug) {
        var types = <?php echo json_encode( array_map( function($ch){ return $ch['type'] ?? 'zapi'; }, vm2_channels() ) ); ?>;
        var isWaba = (types[slug] === 'waba');
        var tplRow = document.getElementById('vm2-wa-tpl-row');
        var msgCard = document.getElementById('vm2-wa-msg-card');
        if (tplRow)  tplRow.style.display  = isWaba ? '' : 'none';
        if (msgCard) msgCard.style.display = isWaba ? 'none' : '';
    }
    (function(){
        var radios = document.querySelectorAll('input[name=vm2_wa_channel]');
        radios.forEach(function(r){ r.addEventListener('change', function(){ vm2WaChannelSwitch(this.value); }); });
    })();

    function vm2WaSaveConfig() {
        var btn    = document.getElementById('vm2-wa-save-cfg-btn');
        var status = document.getElementById('vm2-wa-cfg-status');
        btn.disabled = true;
        status.textContent = '⏳ Salvando…';
        var ch = document.querySelector('input[name=vm2_wa_channel]:checked').value;
        var ks = document.getElementById('vm2-wa-ks').checked ? '1' : '0';
        var bs = document.getElementById('vm2-wa-batch').value;
        var qs = document.getElementById('vm2-wa-qstart').value;
        var qe = document.getElementById('vm2-wa-qend').value;
        var iv = document.getElementById('vm2-wa-interval').value;
        var tplSel = document.getElementById('vm2-wa-tpl-sel');
        var tpl = tplSel ? tplSel.value : '';
        var body = 'action=vm2_wa_save_config&nonce=<?php echo esc_js($cfg_nonce); ?>'
                 + '&vm_wa_send_channel=' + encodeURIComponent(ch) + '&vm_wa_kill_switch=' + ks
                 + '&vm_wa_batch_size=' + bs + '&vm_wa_quiet_start=' + qs
                 + '&vm_wa_quiet_end='  + qe + '&vm_wa_interval_sec=' + iv
                 + '&vm_wa_waba_template=' + encodeURIComponent(tpl);
        fetch(ajaxurl, {
            method: 'POST',
            headers: {'Content-Type':'application/x-www-form-urlencoded'},
            body: body
        })
        .then(function(r) { return r.json(); })
        .then(function(data) {
            btn.disabled = false;
            status.textContent = data.success ? '✅ Salvo!' : '❌ Erro: ' + data.data;
            if (data.success) { setTimeout(function() { location.reload(); }, 800); }
        });
    }
    </script>
    </div>
    <?php
}

// ─── 📊 Promos Dashboard ──────────────────────────────────────────────────────
function vm2_promos_page() {
    global $wpdb;
    $tbl_log    = $wpdb->prefix . 'vm_whatsapp_log';
    $tbl_clicks = $wpdb->prefix . 'vivamais_promo_clicks';
    $tbl_disc   = 'wz_active_discounts'; // prefixo fixo do plugin banner

    $tab = sanitize_text_field( $_GET['tab'] ?? 'dashboard' );

    // ── Salvar Config Banner ─────────────────────────────────────────────────
    if ( $tab === 'banner' && isset( $_POST['vm2_save_banner'] ) && check_admin_referer( 'vm2_banner_nonce' ) ) {
        $bool_fields = ['vm_banner_enabled','vm_banner_animacao','vm_banner_mostrar_imagem','vm_promo_multi_enabled'];
        $all_fields  = ['vm_banner_enabled','vm_banner_position','vm_banner_hora_inicio','vm_banner_hora_fim',
                        'vm_banner_cta_text','vm_banner_animacao','vm_banner_cor_mini','vm_banner_cor_mega',
                        'vm_banner_mostrar_imagem','vm_banner_prefixo_mini','vm_banner_prefixo_mega',
                        'vm_promo_multi_enabled','vm_promo_max_carousel','vm_promo_carousel_interval','vm_promo_carousel_order'];
        foreach ( $all_fields as $f ) {
            $val = in_array($f, $bool_fields) ? (isset($_POST[$f]) ? '1' : '0') : sanitize_text_field( $_POST[$f] ?? '' );
            update_option( $f, $val );
        }
        echo '<div class="notice notice-success is-dismissible"><p>✅ Configurações do banner salvas!</p></div>';
    }

    // ── Disparar nova promo ──────────────────────────────────────────────────
    $disparar_msg = '';
    if ( $tab === 'disparar' && isset( $_POST['vm2_disparar'] ) && check_admin_referer( 'vm2_disparar_nonce' ) ) {
        $product_id  = intval( $_POST['product_id'] ?? 0 );
        $discount    = intval( $_POST['discount_percent'] ?? 0 );
        $duracao     = intval( $_POST['duracao_horas'] ?? 3 );
        $is_mega     = isset( $_POST['is_mega_promo'] ) ? true : false;
        $send_wa     = isset( $_POST['send_whatsapp'] ) ? true : false;
        if ( $product_id > 0 && $discount > 0 ) {
            // Lógica direta (sem REST call ao plugin deletado)
            $product = function_exists('wc_get_product') ? wc_get_product($product_id) : null;
            if ( ! $product ) {
                $disparar_msg = '<div class="notice notice-error"><p>❌ Produto não encontrado.</p></div>';
            } else {
                $product_name   = $product->get_name();
                $regular_price  = floatval( $product->get_regular_price() );
                $sale_price_new = $regular_price > 0 ? round( $regular_price * (1 - $discount / 100), 2 ) : 0;

                // Aplicar preço promocional no WooCommerce
                if ( $regular_price > 0 ) {
                    $product->set_sale_price( $sale_price_new );
                    $product->set_date_on_sale_from( null );
                    $product->set_date_on_sale_to( null );
                    $product->save();
                }

                // Registrar em vm_whatsapp_log
                $wpdb->insert( $tbl_log, [
                    'product_id'       => $product_id,
                    'product_name'     => $product_name,
                    'discount_percent' => $discount,
                    'is_mega_promo'    => $is_mega ? 1 : 0,
                    'sent_at'          => current_time('mysql'),
                    'clicks'           => 0,
                ], ['%d','%s','%d','%d','%s','%d'] );

                // Registrar em wz_active_discounts (para o vm-promo-banner)
                if ( $wpdb->get_var("SHOW TABLES LIKE '{$tbl_disc}'") ) {
                    // v1.5.18: cupom ÚNICO por produto, restrito ao produto, expiração exata
                    $coupon_code = strtoupper( 'PROMO' . $discount . 'OFF-' . $product_id );
                    $expires_ts  = strtotime( "+{$duracao} hours" );

                    // Deletar cupom anterior com mesmo código se existir
                    $existing_coupon = get_page_by_title( $coupon_code, OBJECT, 'shop_coupon' );
                    if ( $existing_coupon ) {
                        wp_delete_post( $existing_coupon->ID, true );
                    }

                    // Criar cupom novo via WC_Coupon (garante product_ids + expiração correta)
                    $wc_coupon = new \WC_Coupon();
                    $wc_coupon->set_code( $coupon_code );
                    $wc_coupon->set_discount_type( 'percent' );
                    $wc_coupon->set_amount( $discount );
                    $wc_coupon->set_product_ids( [ $product_id ] );
                    $wc_coupon->set_date_expires( $expires_ts );
                    $wc_coupon->set_individual_use( false );
                    $wc_coupon->set_usage_limit( 0 ); // ilimitado
                    $wc_coupon->save();

                    $cols = [ 'product_id'=>$product_id, 'product_name'=>$product_name,
                              'discount_percent'=>$discount, 'is_mega_promo'=>$is_mega?1:0,
                              'applied_at'=>current_time('mysql') ];
                    // Colunas opcionais — inserir apenas se existirem
                    $existing_cols = $wpdb->get_col("SHOW COLUMNS FROM {$tbl_disc}");
                    if ( in_array('original_price', $existing_cols) ) $cols['original_price'] = $regular_price;
                    if ( in_array('sale_price',     $existing_cols) ) $cols['sale_price']     = $sale_price_new;
                    if ( in_array('duracao_horas',  $existing_cols) ) $cols['duracao_horas']  = $duracao;
                    if ( in_array('expires_at',     $existing_cols) ) {
                        $cols['expires_at'] = date('Y-m-d H:i:s', strtotime("+{$duracao} hours"));
                    }
                    if ( in_array('coupon_code',    $existing_cols) ) $cols['coupon_code']    = $coupon_code;
                    $wpdb->insert( $tbl_disc, $cols );
                }

                $disparar_msg = '<div class="notice notice-success"><p>✅ Promo disparada! <strong>' . esc_html($product_name) . '</strong> com <strong>' . $discount . '% OFF</strong> por ' . $duracao . 'h.</p></div>';
            }
        } else {
            $disparar_msg = '<div class="notice notice-warning"><p>⚠️ Preencha produto e desconto.</p></div>';
        }
    }

    // ── KPIs para Dashboard ──────────────────────────────────────────────────
    $period = sanitize_text_field( $_GET['period'] ?? '30d' );
    $tipo   = sanitize_text_field( $_GET['tipo']   ?? 'all' );
    $filter_card = sanitize_text_field( $_GET['filter_card'] ?? '' );

    $days = match($period) { '7d'=>7, '90d'=>90, 'all'=>3650, default=>30 };
    $date_from = date('Y-m-d H:i:s', strtotime("-{$days} days"));

    $where_tipo = '';
    if ( $tipo === 'mega' ) $where_tipo = ' AND is_mega_promo=1';
    elseif ( $tipo === 'mini' ) $where_tipo = ' AND is_mega_promo=0';

    $total_envios  = (int) $wpdb->get_var($wpdb->prepare("SELECT COUNT(*) FROM {$tbl_log} WHERE sent_at>=%s{$where_tipo}", $date_from));
    $total_clicks  = (int) $wpdb->get_var($wpdb->prepare("SELECT COALESCE(SUM(clicks),0) FROM {$tbl_log} WHERE sent_at>=%s{$where_tipo}", $date_from));
    $total_mega    = (int) $wpdb->get_var($wpdb->prepare("SELECT COUNT(*) FROM {$tbl_log} WHERE sent_at>=%s AND is_mega_promo=1", $date_from));
    $total_mini    = $total_envios - $total_mega;
    $ctr_medio     = $total_envios > 0 ? round($total_clicks / $total_envios * 100, 1) : 0;
    $sem_clicks    = (int) $wpdb->get_var($wpdb->prepare("SELECT COUNT(*) FROM {$tbl_log} WHERE sent_at>=%s AND clicks=0{$where_tipo}", $date_from));
    $melhor_prod   = $wpdb->get_row($wpdb->prepare("SELECT product_name, SUM(clicks) as tc FROM {$tbl_log} WHERE sent_at>=%s{$where_tipo} GROUP BY product_id ORDER BY tc DESC LIMIT 1", $date_from));

    // Promos ativas — v1.5.15 multi-promo
    $promos_ativas = [];
    if ( $wpdb->get_var("SHOW TABLES LIKE '{$tbl_disc}'") ) {
        $promos_ativas = $wpdb->get_results("SELECT * FROM {$tbl_disc} WHERE reverted_at IS NULL AND (expires_at IS NULL OR expires_at = '0000-00-00 00:00:00' OR expires_at > NOW()) ORDER BY applied_at DESC");
    }
    $promo_ativa = !empty($promos_ativas) ? $promos_ativas[0] : null; // backward compat para banner preview

    // Produtos WooCommerce para select
    $produtos = get_posts(['post_type'=>'product','numberposts'=>200,'post_status'=>'publish','orderby'=>'title','order'=>'ASC']);

    $base_url = admin_url('admin.php?page=vm2-promos');
    ?>
    <div class="wrap" style="max-width:1200px;">
      <style>
      .vm2p-grid2{display:grid;grid-template-columns:1fr;gap:20px;align-items:start;}
      @media(min-width:900px){.vm2p-grid2{grid-template-columns:minmax(0,1.5fr) minmax(0,1fr);}}
      .vm2p-grid2-eq{display:grid;grid-template-columns:1fr;gap:20px;align-items:start;}
      @media(min-width:900px){.vm2p-grid2-eq{grid-template-columns:minmax(0,1fr) minmax(0,340px);}}
      .vm2p-kpis{display:grid;grid-template-columns:repeat(auto-fit,minmax(130px,1fr));gap:12px;margin-bottom:24px;}
      .vm2p-filtros{display:flex;flex-wrap:wrap;gap:10px;margin-bottom:16px;align-items:center;}
      .vm2p-filtros label{font-weight:600;}
      .vm2p-filtros select,.vm2p-filtros input{max-width:100%;}
      .vm2p-form-wide input[type=text],.vm2p-form-wide select,.vm2p-form-wide input[type=number]{max-width:100%;box-sizing:border-box;}
      @media(max-width:600px){
        .vm2p-form-wide .form-table th,.vm2p-form-wide .form-table td{display:block;width:100%;padding:4px 0;}
        .vm2p-form-wide .form-table th{padding-top:12px;font-size:.85em;color:#64748b;}
        .vm2p-form-wide td[style*="display:flex"]{flex-wrap:wrap;}
        .nav-tab-wrapper{overflow-x:auto;white-space:nowrap;display:block;}
      }
      .vm2p-promo-card{background:#fef3c7;border:2px solid #d97706;border-radius:10px;padding:12px 16px;margin-bottom:8px;display:flex;align-items:center;justify-content:space-between;flex-wrap:wrap;gap:10px;}
      .vm2p-tabwrap{overflow-x:auto;}
      </style>

      <h1 style="display:flex;align-items:center;gap:10px;margin-bottom:4px;">
        📊 Promos &amp; Banner
      </h1>

      <?php if ($disparar_msg) echo $disparar_msg; ?>

      <!-- Tabs nav -->
      <nav class="nav-tab-wrapper" style="margin-bottom:20px;overflow-x:auto;white-space:nowrap;display:block;">
        <?php
        $tabs = ['dashboard'=>'📊 Dashboard','disparar'=>'🚀 Disparar Promo','historico'=>'📋 Histórico WA','banner'=>'⚙️ Config Banner'];
        foreach ($tabs as $t=>$label):
            $cls = $tab===$t ? 'nav-tab-active' : '';
        ?>
        <a href="<?php echo esc_url($base_url.'&tab='.$t); ?>" class="nav-tab <?php echo $cls; ?>"><?php echo $label; ?></a>
        <?php endforeach; ?>
      </nav>

      <?php if ($tab === 'dashboard'): ?>
      <!-- ═══════════ TAB: DASHBOARD ═══════════ -->

      <!-- Filtros -->
      <form method="get" style="display:flex;flex-wrap:wrap;gap:10px;margin-bottom:16px;align-items:center;">
        <input type="hidden" name="page" value="vm2-promos">
        <input type="hidden" name="tab" value="dashboard">
        <label style="font-weight:600;">Período:
          <select name="period" onchange="this.form.submit()">
            <?php foreach(['7d'=>'7 dias','30d'=>'30 dias','90d'=>'90 dias','all'=>'Tudo'] as $v=>$l): ?>
            <option value="<?php echo $v; ?>" <?php selected($period,$v); ?>><?php echo $l; ?></option>
            <?php endforeach; ?>
          </select>
        </label>
        <label style="font-weight:600;">Tipo:
          <select name="tipo" onchange="this.form.submit()">
            <option value="all" <?php selected($tipo,'all'); ?>>Todos</option>
            <option value="mega" <?php selected($tipo,'mega'); ?>>Mega Promo</option>
            <option value="mini" <?php selected($tipo,'mini'); ?>>Mini Promo</option>
          </select>
        </label>
      </form>

      <!-- Promos ativas — v1.5.15 multi-promo -->
      <?php if (!empty($promos_ativas)): ?>
      <div style="margin-bottom:18px;">
        <div style="font-size:.85em;font-weight:700;color:#92400e;margin-bottom:8px;">🔥 <?php echo count($promos_ativas); ?> PROMO(S) ATIVA(S) NO CARROSSEL</div>
        <?php foreach ($promos_ativas as $pa): ?>
        <div style="background:#fef3c7;border:2px solid #d97706;border-radius:10px;padding:12px 16px;margin-bottom:8px;display:flex;align-items:center;justify-content:space-between;flex-wrap:wrap;gap:10px;">
          <div style="display:flex;align-items:center;gap:8px;flex-wrap:wrap;">
            <span style="font-size:.95em;font-weight:700;color:#78350f;"><?php echo esc_html($pa->product_name ?? ''); ?></span>
            <span style="background:#d97706;color:#fff;padding:2px 10px;border-radius:20px;font-weight:700;font-size:.85em;"><?php echo esc_html($pa->discount_percent ?? ''); ?>% OFF</span>
            <?php if (!empty($pa->coupon_code)): ?>
            <span style="font-family:monospace;background:#1e293b;color:#fbbf24;padding:2px 10px;border-radius:6px;font-size:.85em;"><?php echo esc_html($pa->coupon_code); ?></span>
            <?php endif; ?>
            <?php if (!empty($pa->expires_at)): ?>
            <span style="color:#92400e;font-size:.82em;">⏰ <?php echo esc_html($pa->expires_at); ?></span>
            <?php endif; ?>
          </div>
          <a href="#" onclick="if(confirm('Encerrar esta promo?'))vm2EndPromo(<?php echo intval($pa->id); ?>); return false;"
             style="background:#dc2626;color:#fff;padding:5px 14px;border-radius:8px;text-decoration:none;font-weight:600;font-size:.82em;white-space:nowrap;">
            ⏹️ Encerrar
          </a>
        </div>
        <?php endforeach; ?>
        <a href="<?php echo esc_url($base_url.'&tab=disparar'); ?>" style="font-size:.85em;color:#7c3aed;font-weight:600;">+ Adicionar mais uma promo ao carrossel →</a>
      </div>
      <?php else: ?>
      <div style="background:#f0fdf4;border:1px solid #86efac;border-radius:8px;padding:10px 16px;margin-bottom:18px;color:#166534;">
        ✅ Nenhuma promo ativa no momento. <a href="<?php echo esc_url($base_url.'&tab=disparar'); ?>" style="color:#15803d;font-weight:600;">🚀 Disparar nova promo →</a>
      </div>
      <?php endif; ?>

      <!-- KPI Cards -->
      <div style="display:grid;grid-template-columns:repeat(auto-fit,minmax(140px,1fr));gap:14px;margin-bottom:24px;">
        <?php
        $cards = [
          ['val'=>$total_envios,'label'=>'Total Envios','icon'=>'📤','filter'=>'','color'=>'#6366f1'],
          ['val'=>$total_mega,'label'=>'Mega Promo','icon'=>'🔥','filter'=>'mega','color'=>'#d97706'],
          ['val'=>$total_mini,'label'=>'Mini Promo','icon'=>'⚡','filter'=>'mini','color'=>'#16a34a'],
          ['val'=>$total_clicks,'label'=>'Cliques','icon'=>'👆','filter'=>'','color'=>'#0891b2'],
          ['val'=>$ctr_medio.'%','label'=>'CTR Médio','icon'=>'📈','filter'=>'','color'=>'#7c3aed'],
          ['val'=>$sem_clicks,'label'=>'Sem Cliques','icon'=>'😴','filter'=>'sem_clicks','color'=>'#dc2626'],
        ];
        foreach ($cards as $c):
          $href = $c['filter'] ? esc_url($base_url.'&tab=dashboard&period='.$period.'&tipo='.$c['filter']) : '#';
          $cursor = $c['filter'] ? 'pointer' : 'default';
        ?>
        <a href="<?php echo $href; ?>" style="text-decoration:none;background:#fff;border:1px solid #e5e7eb;border-radius:12px;padding:16px 12px;text-align:center;cursor:<?php echo $cursor; ?>;transition:box-shadow .2s;" onmouseover="this.style.boxShadow='0 4px 16px rgba(0,0,0,.13)'" onmouseout="this.style.boxShadow=''">
          <div style="font-size:1.6em;"><?php echo $c['icon']; ?></div>
          <div style="font-size:1.6em;font-weight:800;color:<?php echo $c['color']; ?>;"><?php echo $c['val']; ?></div>
          <div style="font-size:.75em;color:#64748b;margin-top:2px;"><?php echo $c['label']; ?></div>
        </a>
        <?php endforeach; ?>
      </div>

      <?php if ($melhor_prod): ?>
      <div style="background:linear-gradient(135deg,#7c3aed,#6366f1);color:#fff;border-radius:10px;padding:12px 20px;margin-bottom:20px;display:flex;align-items:center;gap:12px;">
        <span style="font-size:1.8em;">🏆</span>
        <div>
          <div style="font-weight:700;font-size:.9em;opacity:.85;">MELHOR PRODUTO NO PERÍODO</div>
          <div style="font-size:1.1em;font-weight:800;"><?php echo esc_html($melhor_prod->product_name ?? ''); ?></div>
        </div>
        <div style="margin-left:auto;text-align:center;">
          <div style="font-size:1.6em;font-weight:800;"><?php echo intval($melhor_prod->tc); ?></div>
          <div style="font-size:.75em;opacity:.8;">cliques</div>
        </div>
      </div>
      <?php endif; ?>

      <!-- Top produtos -->
      <?php
      $top_prods = $wpdb->get_results($wpdb->prepare(
          "SELECT product_name, product_id, COUNT(*) as envios, COALESCE(SUM(clicks),0) as cliques,
                  ROUND(SUM(clicks)/NULLIF(COUNT(*),0)*100,1) as ctr,
                  MAX(sent_at) as ultimo
           FROM {$tbl_log} WHERE sent_at>=%s{$where_tipo}
           GROUP BY product_id ORDER BY cliques DESC LIMIT 20", $date_from));
      ?>
      <div style="background:#fff;border:1px solid #e5e7eb;border-radius:12px;overflow:hidden;">
        <div style="padding:14px 18px;border-bottom:1px solid #f1f5f9;display:flex;justify-content:space-between;align-items:center;">
          <strong style="font-size:1em;">📦 Top Produtos por Cliques</strong>
        </div>
        <div style="overflow-x:auto;">
        <table class="wp-list-table widefat fixed striped" style="min-width:500px;">
          <thead>
            <tr>
              <th style="cursor:pointer;" onclick="vm2SortTable(this,0)"># ↕</th>
              <th style="cursor:pointer;" onclick="vm2SortTable(this,1)">Produto ↕</th>
              <th style="cursor:pointer;" onclick="vm2SortTable(this,2)">Envios ↕</th>
              <th style="cursor:pointer;" onclick="vm2SortTable(this,3)">Cliques ↕</th>
              <th style="cursor:pointer;" onclick="vm2SortTable(this,4)">CTR WA ↕</th>
              <th>Último Envio</th>
            </tr>
          </thead>
          <tbody id="promos-top-tbody">
          <?php foreach ($top_prods as $i=>$r): ?>
          <tr>
            <td><?php echo $i+1; ?></td>
            <td><?php echo esc_html($r->product_name ?? ''); ?></td>
            <td><?php echo intval($r->envios); ?></td>
            <td><?php echo intval($r->cliques); ?></td>
            <td><span style="font-weight:700;color:<?php echo $r->ctr>=10?'#16a34a':($r->ctr>=5?'#d97706':'#dc2626'); ?>"><?php echo $r->ctr; ?>%</span></td>
            <td style="font-size:.85em;color:#64748b;"><?php echo esc_html($r->ultimo ?? ''); ?></td>
          </tr>
          <?php endforeach; ?>
          <?php if (empty($top_prods)): ?>
          <tr><td colspan="6" style="text-align:center;padding:20px;color:#94a3b8;">Nenhum dado encontrado.</td></tr>
          <?php endif; ?>
          </tbody>
        </table>
        </div>
      </div>

      <?php elseif ($tab === 'disparar'): ?>
      <!-- ═══════════ TAB: DISPARAR PROMO ═══════════ -->
      <div class="vm2p-grid2">
        <div style="background:#fff;border:1px solid #e5e7eb;border-radius:12px;padding:24px;">
          <h2 style="margin-top:0;font-size:1.1em;">🚀 Nova Promo</h2>
          <form method="post" class="vm2p-form-wide">
            <?php wp_nonce_field('vm2_disparar_nonce'); ?>
            <table class="form-table" style="margin-bottom:0;">
              <tr>
                <th><label for="vm2_prod">Produto *</label></th>
                <td>
                  <select name="product_id" id="vm2_prod" style="width:100%;max-width:400px;box-sizing:border-box;" required>
                    <option value="">— Selecione —</option>
                    <?php foreach($produtos as $p): ?>
                    <option value="<?php echo $p->ID; ?>"><?php echo esc_html($p->post_title); ?></option>
                    <?php endforeach; ?>
                  </select>
                </td>
              </tr>
              <tr>
                <th><label for="vm2_desc">Desconto (%) *</label></th>
                <td>
                  <input type="number" name="discount_percent" id="vm2_desc" min="1" max="99" style="width:100px;" required>
                  <span style="color:#64748b;font-size:.85em;margin-left:8px;">% de desconto</span>
                </td>
              </tr>
              <tr>
                <th><label for="vm2_dur">Duração (horas)</label></th>
                <td>
                  <input type="number" name="duracao_horas" id="vm2_dur" min="1" max="72" value="3" style="width:80px;">
                  <span style="color:#64748b;font-size:.85em;margin-left:8px;">horas até expirar</span>
                </td>
              </tr>
              <tr>
                <th>Tipo</th>
                <td>
                  <label style="margin-right:20px;cursor:pointer;">
                    <input type="checkbox" name="is_mega_promo" value="1">
                    🔥 Mega Promo (destaque especial)
                  </label>
                </td>
              </tr>
              <tr>
                <th>Enviar WA</th>
                <td>
                  <label style="cursor:pointer;">
                    <input type="checkbox" name="send_whatsapp" value="1">
                    📱 Disparar mensagem WhatsApp ao criar
                  </label>
                </td>
              </tr>
            </table>
            <div style="margin-top:20px;">
              <button type="submit" name="vm2_disparar" class="button button-primary" style="background:#7c3aed;border-color:#6d28d9;font-size:.95em;padding:6px 20px;">
                🚀 Disparar Promo
              </button>
            </div>
          </form>
        </div>

        <div>
          <!-- Promos ativas — v1.5.15 -->
          <div style="background:#fff;border:1px solid #e5e7eb;border-radius:12px;padding:20px;margin-bottom:16px;">
            <h3 style="margin-top:0;font-size:.95em;color:#64748b;">PROMOS ATIVAS NO CARROSSEL (<?php echo count($promos_ativas); ?>)</h3>
            <?php if (!empty($promos_ativas)): ?>
            <?php foreach ($promos_ativas as $pa): ?>
            <div style="display:flex;align-items:center;justify-content:space-between;flex-wrap:wrap;gap:8px;padding:8px 0;border-bottom:1px solid #f1f5f9;">
              <div>
                <span style="font-weight:700;color:#92400e;"><?php echo esc_html($pa->product_name ?? ''); ?></span>
                <span style="background:#d97706;color:#fff;padding:2px 10px;border-radius:20px;font-weight:700;font-size:.8em;margin-left:6px;"><?php echo esc_html($pa->discount_percent ?? ''); ?>% OFF</span>
                <?php if (!empty($pa->coupon_code)): ?><span style="font-family:monospace;background:#1e293b;color:#fbbf24;padding:2px 8px;border-radius:4px;font-size:.78em;margin-left:4px;"><?php echo esc_html($pa->coupon_code); ?></span><?php endif; ?>
              </div>
              <a href="#" onclick="if(confirm('Encerrar?'))vm2EndPromo(<?php echo intval($pa->id); ?>); return false;"
                 style="background:#dc2626;color:#fff;padding:4px 12px;border-radius:6px;text-decoration:none;font-size:.8em;font-weight:600;">⏹️</a>
            </div>
            <?php endforeach; ?>
            <div style="margin-top:10px;font-size:.82em;color:#64748b;">💡 Disparar nova promo abaixo — não encerra as anteriores.</div>
            <?php else: ?>
            <div style="color:#94a3b8;font-size:.9em;">Nenhuma promo ativa. Use o formulário abaixo para disparar a primeira.</div>
            <?php endif; ?>
          </div>

          <!-- Últimas promos -->
          <?php $ultimas = $wpdb->get_results("SELECT product_name,discount_percent,is_mega_promo,clicks,sent_at FROM {$tbl_log} ORDER BY sent_at DESC LIMIT 8"); ?>
          <div style="background:#fff;border:1px solid #e5e7eb;border-radius:12px;padding:16px;">
            <h3 style="margin-top:0;font-size:.9em;color:#64748b;">ÚLTIMAS 8 PROMOS DISPARADAS</h3>
            <?php foreach($ultimas as $u): ?>
            <div style="display:flex;justify-content:space-between;align-items:center;padding:6px 0;border-bottom:1px solid #f1f5f9;font-size:.85em;">
              <div>
                <?php if($u->is_mega_promo): ?><span style="background:#fef3c7;color:#92400e;border-radius:4px;padding:1px 6px;font-size:.8em;margin-right:4px;">MEGA</span><?php endif; ?>
                <?php echo esc_html(substr($u->product_name ?? '', 0, 30)); ?>
              </div>
              <div style="display:flex;gap:8px;align-items:center;">
                <span style="color:#7c3aed;font-weight:700;"><?php echo $u->discount_percent; ?>%</span>
                <span style="color:#64748b;">👆 <?php echo $u->clicks; ?></span>
              </div>
            </div>
            <?php endforeach; ?>
          </div>
        </div>
      </div>

      <?php elseif ($tab === 'historico'): ?>
      <!-- ═══════════ TAB: HISTÓRICO WA ═══════════ -->
      <?php
      $pg   = max(1, intval($_GET['paged'] ?? 1));
      $per  = 50;
      $off  = ($pg-1)*$per;
      $hist_tipo = sanitize_text_field($_GET['htipo'] ?? 'all');
      $h_where = '';
      if ($hist_tipo==='mega') $h_where = ' WHERE is_mega_promo=1';
      elseif ($hist_tipo==='mini') $h_where = ' WHERE is_mega_promo=0';
      $hist_total = (int)$wpdb->get_var("SELECT COUNT(*) FROM {$tbl_log}{$h_where}");
      $hist = $wpdb->get_results($wpdb->prepare("SELECT * FROM {$tbl_log}{$h_where} ORDER BY sent_at DESC LIMIT %d OFFSET %d", $per, $off));
      $pages = ceil($hist_total/$per);
      ?>
      <div style="display:flex;justify-content:space-between;align-items:center;margin-bottom:14px;flex-wrap:wrap;gap:10px;">
        <div style="font-size:.9em;color:#64748b;"><?php echo $hist_total; ?> disparos no histórico</div>
        <form method="get" style="display:flex;gap:8px;align-items:center;">
          <input type="hidden" name="page" value="vm2-promos">
          <input type="hidden" name="tab" value="historico">
          <select name="htipo" onchange="this.form.submit()">
            <option value="all" <?php selected($hist_tipo,'all'); ?>>Todos</option>
            <option value="mega" <?php selected($hist_tipo,'mega'); ?>>Mega</option>
            <option value="mini" <?php selected($hist_tipo,'mini'); ?>>Mini</option>
          </select>
        </form>
      </div>
      <div style="background:#fff;border:1px solid #e5e7eb;border-radius:12px;overflow:hidden;">
        <div style="overflow-x:auto;">
        <table class="wp-list-table widefat fixed striped" style="min-width:650px;">
          <thead>
            <tr>
              <th style="cursor:pointer;" onclick="vm2SortTable(this,0)">Data ↕</th>
              <th style="cursor:pointer;" onclick="vm2SortTable(this,1)">Produto ↕</th>
              <th style="cursor:pointer;" onclick="vm2SortTable(this,2)">Desconto ↕</th>
              <th>Tipo</th>
              <th style="cursor:pointer;" onclick="vm2SortTable(this,4)">Preço Orig ↕</th>
              <th style="cursor:pointer;" onclick="vm2SortTable(this,5)">Preço c/ Desc ↕</th>
              <th style="cursor:pointer;" onclick="vm2SortTable(this,6)">Cliques ↕</th>
              <th>Cupom</th>
            </tr>
          </thead>
          <tbody id="historico-tbody">
          <?php foreach($hist as $r): ?>
          <tr>
            <td style="font-size:.82em;color:#64748b;"><?php echo esc_html($r->sent_at); ?></td>
            <td><?php echo esc_html($r->product_name ?? ''); ?></td>
            <td style="font-weight:700;color:#7c3aed;"><?php echo $r->discount_percent; ?>%</td>
            <td><?php echo $r->is_mega_promo ? '<span style="background:#fef3c7;color:#92400e;border-radius:4px;padding:2px 8px;font-size:.8em;">🔥 MEGA</span>' : '<span style="background:#f1f5f9;color:#64748b;border-radius:4px;padding:2px 8px;font-size:.8em;">⚡ Mini</span>'; ?></td>
            <td>R$ <?php echo number_format($r->original_price ?? 0, 2, ',', '.'); ?></td>
            <td>R$ <?php echo number_format($r->discounted_price ?? 0, 2, ',', '.'); ?></td>
            <td style="font-weight:700;color:<?php echo $r->clicks>0?'#16a34a':'#dc2626'; ?>"><?php echo intval($r->clicks); ?></td>
            <td style="font-family:monospace;font-size:.8em;color:#64748b;"><?php echo esc_html($r->coupon_code ?? '-'); ?></td>
          </tr>
          <?php endforeach; ?>
          <?php if(empty($hist)): ?>
          <tr><td colspan="8" style="text-align:center;padding:20px;color:#94a3b8;">Nenhum histórico encontrado.</td></tr>
          <?php endif; ?>
          </tbody>
        </table>
        </div>
      </div>
      <?php if ($pages > 1): ?>
      <div style="margin-top:16px;display:flex;gap:8px;flex-wrap:wrap;">
        <?php for ($p=1;$p<=$pages;$p++): ?>
        <a href="<?php echo esc_url(add_query_arg(['page'=>'vm2-promos','tab'=>'historico','paged'=>$p,'htipo'=>$hist_tipo], admin_url('admin.php'))); ?>"
           style="padding:4px 12px;background:<?php echo $p===$pg?'#7c3aed':'#e5e7eb'; ?>;color:<?php echo $p===$pg?'#fff':'#334155'; ?>;border-radius:6px;text-decoration:none;font-size:.85em;">
          <?php echo $p; ?>
        </a>
        <?php endfor; ?>
      </div>
      <?php endif; ?>

      <?php elseif ($tab === 'banner'): ?>
      <!-- ═══════════ TAB: CONFIG BANNER ═══════════ -->
      <div class="vm2p-grid2-eq">
        <div style="background:#fff;border:1px solid #e5e7eb;border-radius:12px;padding:24px;">
          <h2 style="margin-top:0;font-size:1.1em;">🏷️ Configurações do Banner</h2>
          <form method="post" class="vm2p-form-wide">
            <?php wp_nonce_field('vm2_banner_nonce'); ?>
            <table class="form-table">
              <tr>
                <th><label>Status</label></th>
                <td>
                  <label style="cursor:pointer;display:flex;align-items:center;gap:8px;">
                    <input type="checkbox" name="vm_banner_enabled" value="1" <?php checked(get_option('vm_banner_enabled','1'),'1'); ?>>
                    <span>Banner habilitado no site</span>
                  </label>
                </td>
              </tr>
              <tr>
                <th><label for="banner_pos">Posição</label></th>
                <td>
                  <select name="vm_banner_position" id="banner_pos">
                    <option value="top" <?php selected(get_option('vm_banner_position','top'),'top'); ?>>Topo</option>
                    <option value="bottom" <?php selected(get_option('vm_banner_position','top'),'bottom'); ?>>Rodapé</option>
                  </select>
                </td>
              </tr>
              <tr>
                <th><label>Horário de Exibição</label></th>
                <td style="display:flex;flex-wrap:wrap;align-items:center;gap:12px;">
                  <input type="time" name="vm_banner_hora_inicio" value="<?php echo esc_attr(get_option('vm_banner_hora_inicio','08:00')); ?>" style="width:100px;">
                  <span style="color:#64748b;">até</span>
                  <input type="time" name="vm_banner_hora_fim" value="<?php echo esc_attr(get_option('vm_banner_hora_fim','22:00')); ?>" style="width:100px;">
                </td>
              </tr>
              <tr>
                <th><label for="banner_cta">Texto do Botão CTA</label></th>
                <td><input type="text" name="vm_banner_cta_text" id="banner_cta" value="<?php echo esc_attr(get_option('vm_banner_cta_text','COPIAR CUPOM')); ?>" style="width:100%;max-width:300px;"></td>
              </tr>
              <tr>
                <th><label>Animação</label></th>
                <td>
                  <label style="cursor:pointer;display:flex;align-items:center;gap:8px;">
                    <input type="checkbox" name="vm_banner_animacao" value="1" <?php checked(get_option('vm_banner_animacao','1'),'1'); ?>>
                    <span>Ativar animação no banner</span>
                  </label>
                </td>
              </tr>
              <tr>
                <th><label>Mostrar Imagem do Produto</label></th>
                <td>
                  <label style="cursor:pointer;display:flex;align-items:center;gap:8px;">
                    <input type="checkbox" name="vm_banner_mostrar_imagem" value="1" <?php checked(get_option('vm_banner_mostrar_imagem','0'),'1'); ?>>
                    <span>Exibir imagem do produto no banner</span>
                  </label>
                </td>
              </tr>
              <tr>
                <th><label for="banner_cor_mini">Cor Mini Promo</label></th>
                <td style="display:flex;align-items:center;gap:10px;">
                  <input type="color" name="vm_banner_cor_mini" id="banner_cor_mini" value="<?php echo esc_attr(get_option('vm_banner_cor_mini','#16a34a')); ?>">
                  <span style="font-size:.85em;color:#64748b;">Cor de fundo para mini promos</span>
                </td>
              </tr>
              <tr>
                <th><label for="banner_cor_mega">Cor Mega Promo</label></th>
                <td style="display:flex;align-items:center;gap:10px;">
                  <input type="color" name="vm_banner_cor_mega" id="banner_cor_mega" value="<?php echo esc_attr(get_option('vm_banner_cor_mega','#b45309')); ?>">
                  <span style="font-size:.85em;color:#64748b;">Cor de fundo para mega promos</span>
                </td>
              </tr>
              <tr>
                <th><label for="banner_pfx_mini">Prefixo Mini</label></th>
                <td><input type="text" name="vm_banner_prefixo_mini" id="banner_pfx_mini" value="<?php echo esc_attr(get_option('vm_banner_prefixo_mini','⚡ OFERTA EXCLUSIVA')); ?>" style="width:100%;max-width:280px;"></td>
              </tr>
              <tr>
                <th><label for="banner_pfx_mega">Prefixo Mega</label></th>
                <td><input type="text" name="vm_banner_prefixo_mega" id="banner_pfx_mega" value="<?php echo esc_attr(get_option('vm_banner_prefixo_mega',' MEGA PROMO')); ?>" style="width:100%;max-width:280px;"></td>
              </tr>
            </table>

            <h3 style="margin-top:24px;margin-bottom:8px;font-size:1em;color:#334155;">🎠 Carrossel Multi-Promo</h3>
            <table class="form-table">
              <tr>
                <th><label>Multi-Promo</label></th>
                <td>
                  <label style="cursor:pointer;display:flex;align-items:center;gap:8px;">
                    <input type="checkbox" name="vm_promo_multi_enabled" value="1" <?php checked(get_option('vm_promo_multi_enabled','1'),'1'); ?>>
                    <span>Exibir carrossel com múltiplas promos ativas</span>
                  </label>
                  <p class="description">Quando desativado, exibe apenas a promo mais recente.</p>
                </td>
              </tr>
              <tr>
                <th><label for="max_carousel">Máx. no Carrossel</label></th>
                <td>
                  <input type="number" name="vm_promo_max_carousel" id="max_carousel" min="1" max="20" value="<?php echo esc_attr(get_option('vm_promo_max_carousel','5')); ?>" style="width:70px;">
                  <span style="margin-left:6px;font-size:.85em;color:#64748b;">promos exibidas simultâneamente</span>
                </td>
              </tr>
              <tr>
                <th><label for="carousel_int">Intervalo (s)</label></th>
                <td>
                  <input type="number" name="vm_promo_carousel_interval" id="carousel_int" min="2" max="30" value="<?php echo esc_attr(get_option('vm_promo_carousel_interval','5')); ?>" style="width:70px;">
                  <span style="margin-left:6px;font-size:.85em;color:#64748b;">segundos entre promos no carrossel</span>
                </td>
              </tr>
              <tr>
                <th><label for="carousel_ord">Ordem</label></th>
                <td>
                  <select name="vm_promo_carousel_order" id="carousel_ord">
                    <?php $co = get_option('vm_promo_carousel_order','expires_first'); ?>
                    <option value="expires_first" <?php selected($co,'expires_first'); ?>>⏰ Expira antes</option>
                    <option value="discount_desc" <?php selected($co,'discount_desc'); ?>>💥 Maior desconto</option>
                    <option value="newest" <?php selected($co,'newest'); ?>>🆕 Mais recente</option>
                  </select>
                </td>
              </tr>
            </table>

            <div style="margin-top:10px;">
              <button type="submit" name="vm2_save_banner" class="button button-primary">💾 Salvar Configurações</button>
            </div>
          </form>
        </div>

        <!-- Preview e status -->
        <div>
          <div style="background:#fff;border:1px solid #e5e7eb;border-radius:12px;padding:20px;margin-bottom:16px;">
            <h3 style="margin-top:0;font-size:.9em;color:#64748b;">STATUS DO BANNER</h3>
            <?php
            $enabled = get_option('vm_banner_enabled','1') === '1';
            $hi = get_option('vm_banner_hora_inicio','08:00');
            $hf = get_option('vm_banner_hora_fim','22:00');
            ?>
            <div style="font-size:1.1em;font-weight:700;color:<?php echo $enabled?'#16a34a':'#dc2626'; ?>;">
              <?php echo $enabled ? '✅ Habilitado' : '⛔ Desabilitado'; ?>
            </div>
            <div style="margin-top:8px;font-size:.9em;color:#64748b;">
              ⏰ Exibição: <?php echo esc_html($hi); ?> – <?php echo esc_html($hf); ?>
            </div>
            <div style="margin-top:6px;font-size:.9em;color:#64748b;">
              📍 Posição: <?php echo get_option('vm_banner_position','top') === 'top' ? 'Topo' : 'Rodapé'; ?>
            </div>
          </div>

          <div style="background:#f8fafc;border:1px solid #e5e7eb;border-radius:12px;padding:16px;">
            <h3 style="margin-top:0;font-size:.9em;color:#64748b;">PROMO ATIVA NO BANNER</h3>
            <?php if ($promo_ativa): ?>
            <div style="background:<?php echo esc_attr(get_option('vm_banner_cor_mini','#16a34a')); ?>;color:#fff;border-radius:8px;padding:12px 16px;font-size:.9em;">
              <div style="font-size:.75em;letter-spacing:1px;font-weight:600;"><?php echo esc_html(get_option('vm_banner_prefixo_mini','⚡ OFERTA EXCLUSIVA')); ?></div>
              <div style="font-size:1.05em;font-weight:700;margin-top:4px;"><?php echo esc_html($promo_ativa->product_name ?? ''); ?> — <?php echo $promo_ativa->discount_percent; ?>% OFF</div>
              <div style="margin-top:8px;background:rgba(0,0,0,.2);display:inline-block;padding:4px 12px;border-radius:6px;cursor:pointer;font-size:.85em;">
                <?php echo esc_html(get_option('vm_banner_cta_text','COPIAR CUPOM')); ?>
              </div>
            </div>
            <?php else: ?>
            <div style="color:#94a3b8;font-size:.9em;">Nenhuma promo ativa para exibir no banner.</div>
            <?php endif; ?>
          </div>
        </div>
      </div>
      <?php endif; ?>

    </div><!-- /wrap -->

    <script>
    function vm2SortTable(th, col) {
        var tbody = th.closest('table').querySelector('tbody');
        var rows = Array.from(tbody.querySelectorAll('tr'));
        var asc = th.dataset.sort !== 'asc';
        th.dataset.sort = asc ? 'asc' : 'desc';
        rows.sort(function(a,b){
            var av = a.cells[col] ? a.cells[col].innerText.replace(/[^0-9.,%-]/g,'') : '';
            var bv = b.cells[col] ? b.cells[col].innerText.replace(/[^0-9.,%-]/g,'') : '';
            var an = parseFloat(av.replace(',','.')), bn = parseFloat(bv.replace(',','.'));
            if (!isNaN(an) && !isNaN(bn)) return asc ? an-bn : bn-an;
            return asc ? av.localeCompare(bv) : bv.localeCompare(av);
        });
        rows.forEach(function(r){ tbody.appendChild(r); });
    }
    function vm2EndPromo(id) {
        var body = id ? JSON.stringify({id:id}) : JSON.stringify({});
        fetch('<?php echo esc_js(rest_url('vm-crm-v2/v1/promos/end')); ?>', {
            method:'POST', credentials:'include',
            headers:{'Content-Type':'application/json','X-WP-Nonce':'<?php echo wp_create_nonce('wp_rest'); ?>'},
            body: body
        }).then(r=>r.json()).then(d=>{
            alert(d.success ? '✅ Promo encerrada!' : '❌ ' + (d.message||'Erro'));
            if(d.success) location.reload();
        });
    }
    </script>
<?php
}


// ============================================================
// BARRAS PROMOCIONAIS — CRM V2 (controla VivaMais Hub)
// ============================================================
function vm2_barras_page() {
    if (!current_user_can('manage_options')) return;

    // Handle save
    if ($_SERVER['REQUEST_METHOD'] === 'POST' && isset($_POST['vm2_barras_save'])) {
        check_admin_referer('vm2_barras_save');
        update_option('vmhub_coupon_bar_enabled', isset($_POST['coupon_bar_enabled']) ? 1 : 0);
        update_option('vmhub_coupon_bar_coupon',  sanitize_text_field($_POST['coupon_bar_coupon'] ?? 'PRIMEIRACOMPRA'));
        update_option('vmhub_coupon_bar_text',    sanitize_text_field($_POST['coupon_bar_text'] ?? '5% OFF'));
        update_option('vmhub_viral_bar_enabled',  isset($_POST['viral_bar_enabled']) ? 1 : 0);
        update_option('vmhub_viral_bar_actor',    sanitize_text_field($_POST['viral_bar_actor'] ?? 'Selton Melo'));
        update_option('vmhub_viral_bar_text',     sanitize_text_field($_POST['viral_bar_text'] ?? 'compartilhou nossa Carreta no TikTok'));
        update_option('vmhub_viral_bar_link',     esc_url_raw($_POST['viral_bar_link'] ?? '/carreta-viral/'));
        echo '<div class="notice notice-success"><p>✅ Barras Promocionais salvas!</p></div>';
    }

    // Read current values
    $cb_on     = get_option('vmhub_coupon_bar_enabled', 1);
    $cb_coupon = get_option('vmhub_coupon_bar_coupon', 'PRIMEIRACOMPRA');
    $cb_text   = get_option('vmhub_coupon_bar_text', '5% OFF');
    $vb_on     = get_option('vmhub_viral_bar_enabled', 1);
    $vb_actor  = get_option('vmhub_viral_bar_actor', 'Selton Melo');
    $vb_text   = get_option('vmhub_viral_bar_text', 'compartilhou nossa Carreta no TikTok');
    $vb_link   = get_option('vmhub_viral_bar_link', home_url('/carreta-viral/'));

    ?>
    <div class="wrap">
    <h1 style="display:flex;align-items:center;gap:10px">📣 Barras Promocionais
        <span style="font-size:12px;background:#e0f2fe;color:#0369a1;padding:2px 8px;border-radius:20px;font-weight:500">VivaMais Hub</span>
    </h1>
    <p style="color:#6b7280;margin-top:-6px">Controle as barras promocionais exibidas no site. Alterações são aplicadas imediatamente.</p>

    <form method="post" style="max-width:900px">
    <?php wp_nonce_field('vm2_barras_save'); ?>
    <input type="hidden" name="vm2_barras_save" value="1">

    <!-- ===== BARRA CUPOM ===== -->
    <div style="background:#fff;border:1px solid #e5e7eb;border-radius:12px;padding:24px;margin-bottom:24px">
        <div style="display:flex;align-items:center;justify-content:space-between;margin-bottom:20px">
            <div>
                <h2 style="margin:0;font-size:16px;display:flex;align-items:center;gap:8px">
                    🏷️ Barra Cupom de Desconto
                </h2>
                <p style="margin:4px 0 0;color:#6b7280;font-size:13px">Barra amarela na home e listagem de produtos</p>
            </div>
            <label style="display:flex;align-items:center;gap:8px;cursor:pointer">
                <input type="checkbox" name="coupon_bar_enabled" value="1" <?php checked($cb_on, 1); ?> id="cb_toggle"
                    style="width:18px;height:18px;cursor:pointer">
                <span style="font-weight:600;color:<?php echo $cb_on ? '#16a34a' : '#6b7280'; ?>" id="cb_status">
                    <?php echo $cb_on ? '✅ Ativa' : '⏸ Pausada'; ?>
                </span>
            </label>
        </div>

        <!-- Preview barra cupom -->
        <div id="cb_preview" style="background:#FFD700;color:#1a0a2e;padding:8px 16px;border-radius:8px;text-align:center;font-size:14px;font-weight:700;margin-bottom:20px;<?php echo $cb_on ? '' : 'opacity:0.4'; ?>">
            USE O CUPOM <span id="cb_preview_coupon" style="background:#1a0a2e;color:#FFD700;padding:2px 6px;border-radius:4px"><?php echo esc_html($cb_coupon); ?></span>
            E GANHE <span id="cb_preview_text"><?php echo esc_html($cb_text); ?></span>
        </div>

        <div style="display:grid;grid-template-columns:1fr 1fr;gap:16px">
            <div>
                <label style="display:block;font-weight:600;margin-bottom:6px;font-size:13px">Código do Cupom</label>
                <input type="text" name="coupon_bar_coupon" value="<?php echo esc_attr($cb_coupon); ?>"
                    style="width:100%;padding:8px 12px;border:1px solid #d1d5db;border-radius:8px;font-size:14px;font-family:monospace;text-transform:uppercase"
                    oninput="document.getElementById('cb_preview_coupon').textContent=this.value.toUpperCase()">
            </div>
            <div>
                <label style="display:block;font-weight:600;margin-bottom:6px;font-size:13px">Texto do Desconto</label>
                <input type="text" name="coupon_bar_text" value="<?php echo esc_attr($cb_text); ?>"
                    style="width:100%;padding:8px 12px;border:1px solid #d1d5db;border-radius:8px;font-size:14px"
                    oninput="document.getElementById('cb_preview_text').textContent=this.value">
            </div>
        </div>
    </div>

    <!-- ===== BARRA VIRAL ===== -->
    <div style="background:#fff;border:1px solid #e5e7eb;border-radius:12px;padding:24px;margin-bottom:24px">
        <div style="display:flex;align-items:center;justify-content:space-between;margin-bottom:20px">
            <div>
                <h2 style="margin:0;font-size:16px;display:flex;align-items:center;gap:8px">
                    🔴 Barra Viral (Celebridade)
                </h2>
                <p style="margin:4px 0 0;color:#6b7280;font-size:13px">Barra vermelha com menção de celebridade — topo de todas as páginas</p>
            </div>
            <label style="display:flex;align-items:center;gap:8px;cursor:pointer">
                <input type="checkbox" name="viral_bar_enabled" value="1" <?php checked($vb_on, 1); ?> id="vb_toggle"
                    style="width:18px;height:18px;cursor:pointer">
                <span style="font-weight:600;color:<?php echo $vb_on ? '#16a34a' : '#6b7280'; ?>" id="vb_status">
                    <?php echo $vb_on ? '✅ Ativa' : '⏸ Pausada'; ?>
                </span>
            </label>
        </div>

        <!-- Preview barra viral -->
        <div id="vb_preview" style="background:linear-gradient(90deg,#b30000,#d40000,#b30000);color:#fff;padding:10px 16px;border-radius:8px;text-align:center;font-size:13px;margin-bottom:20px;<?php echo $vb_on ? '' : 'opacity:0.4'; ?>">
            🔥🎵
            <a href="#" style="color:#fff;text-decoration:none">
                <span id="vb_preview_actor" style="color:#d4af37;font-weight:700"><?php echo esc_html($vb_actor); ?></span>
                <span id="vb_preview_text"> <?php echo esc_html($vb_text); ?></span>
                &mdash; <span style="color:#d4af37;font-weight:700;text-decoration:underline">ver vídeos virais ›</span>
            </a>
        </div>

        <div style="display:grid;grid-template-columns:1fr 1fr;gap:16px;margin-bottom:16px">
            <div>
                <label style="display:block;font-weight:600;margin-bottom:6px;font-size:13px">Nome da Celebridade</label>
                <input type="text" name="viral_bar_actor" value="<?php echo esc_attr($vb_actor); ?>"
                    style="width:100%;padding:8px 12px;border:1px solid #d1d5db;border-radius:8px;font-size:14px"
                    oninput="document.getElementById('vb_preview_actor').textContent=this.value">
            </div>
            <div>
                <label style="display:block;font-weight:600;margin-bottom:6px;font-size:13px">Texto da Ação</label>
                <input type="text" name="viral_bar_text" value="<?php echo esc_attr($vb_text); ?>"
                    style="width:100%;padding:8px 12px;border:1px solid #d1d5db;border-radius:8px;font-size:14px"
                    oninput="document.getElementById('vb_preview_text').textContent=' '+this.value">
            </div>
        </div>
        <div>
            <label style="display:block;font-weight:600;margin-bottom:6px;font-size:13px">Link de Destino</label>
            <input type="url" name="viral_bar_link" value="<?php echo esc_attr($vb_link); ?>"
                style="width:100%;padding:8px 12px;border:1px solid #d1d5db;border-radius:8px;font-size:14px"
                placeholder="https://loja.vivamaiseventos.com/carreta-viral/">
        </div>
    </div>

    <button type="submit" class="button button-primary" style="padding:10px 32px;font-size:15px;height:auto;border-radius:8px">
        💾 Salvar Barras
    </button>
    </form>
    </div>

    <script>
    // Toggle status label on checkbox change
    document.getElementById('cb_toggle').addEventListener('change', function() {
        document.getElementById('cb_status').textContent = this.checked ? '✅ Ativa' : '⏸ Pausada';
        document.getElementById('cb_status').style.color = this.checked ? '#16a34a' : '#6b7280';
        document.getElementById('cb_preview').style.opacity = this.checked ? '1' : '0.4';
    });
    document.getElementById('vb_toggle').addEventListener('change', function() {
        document.getElementById('vb_status').textContent = this.checked ? '✅ Ativa' : '⏸ Pausada';
        document.getElementById('vb_status').style.color = this.checked ? '#16a34a' : '#6b7280';
        document.getElementById('vb_preview').style.opacity = this.checked ? '1' : '0.4';
    });
    </script>
    <?php
}

function vm2_settings_page() {
    $notice = '';

    // ── Salvar Kill Switch Global ──────────────────────────────────────────
    if ( isset( $_POST['vm2_save_settings'] ) && check_admin_referer( 'vm2_settings_nonce' ) ) {
        update_option( 'vm2_kill_switch', isset( $_POST['vm2_kill_switch'] ) ? '1' : '0' );
        if ( isset($_POST['vm2_global_daily_limit']) ) {
            update_option( 'vm2_global_daily_limit', max(0, (int)$_POST['vm2_global_daily_limit']) );
        }
        if ( isset($_POST['vm2_contact_weekly_limit']) ) {
            update_option( 'vm2_contact_weekly_limit', max(0, (int)$_POST['vm2_contact_weekly_limit']) );
        }
        if ( isset($_POST['vm2_fin_webhook_url']) ) {
            update_option('vm2_fin_webhook_url', esc_url_raw(trim($_POST['vm2_fin_webhook_url'])));
        }
        if ( !empty($_POST['vm2_fin_sync_token']) ) {
            update_option('vm2_fin_sync_token', sanitize_text_field($_POST['vm2_fin_sync_token']));
        }
        if ( isset($_POST['vm2_agenda_webhook_url']) ) {
            update_option('vm2_agenda_webhook_url', esc_url_raw(trim($_POST['vm2_agenda_webhook_url'])));
        }
        $notice = '<div class="notice notice-success is-dismissible"><p>✅ Configurações globais salvas!</p></div>';
    }

    // ── Adicionar / Editar canal ──────────────────────────────────────────
    if ( isset( $_POST['vm2_add_channel'] ) && check_admin_referer( 'vm2_channel_nonce' ) ) {
        $slug     = sanitize_key( $_POST['ch_slug'] ?? '' );
        $edit_key = sanitize_key( $_POST['ch_edit_key'] ?? '' );
        $type     = in_array( $_POST['ch_type'] ?? '', ['zapi','waba'] ) ? $_POST['ch_type'] : 'zapi';
        $label    = sanitize_text_field( $_POST['ch_label'] ?? '' );
        $number   = sanitize_text_field( $_POST['ch_number'] ?? '' );
        $instance = sanitize_text_field( $_POST['ch_instance'] ?? '' );
        $token    = sanitize_text_field( $_POST['ch_token'] ?? '' );
        $client      = sanitize_text_field( $_POST['ch_client'] ?? '' );
        $daily_limit = max( 1, (int) ( $_POST['ch_daily_limit'] ?? 50 ) );
        if ( $slug && $label && $number ) {
            $custom = get_option( 'vm2_channel_pool', [] );
            if ( is_string( $custom ) ) $custom = json_decode( $custom, true ) ?: [];
            if ( $edit_key && $edit_key !== $slug && isset( $custom[$edit_key] ) ) {
                unset( $custom[$edit_key] );
            } elseif ( $edit_key && $edit_key === $slug ) {
                // mesma chave — apenas atualiza
            }
            // Novo canal: começa PAUSADO (proteção contra flood)
            // Edição: preserva o status existente
            $prev_status = 'paused'; // default para novos
            if ( $edit_key ) {
                $prev_status = $custom[ $edit_key ]['status'] ?? $custom[ $slug ]['status'] ?? 'active';
            }
            $new_entry = [ 'label' => $label, 'type' => $type, 'number' => $number, 'instance' => $instance, 'token' => $token, 'client' => $client, 'daily_limit' => $daily_limit, 'status' => $prev_status ];
            $custom[ $slug ] = $new_entry;
            update_option( 'vm2_channel_pool', $custom );
            $verb   = $edit_key ? 'atualizado' : 'adicionado';
            $notice = '<div class="notice notice-success is-dismissible"><p>✅ Canal <strong>' . esc_html($label) . '</strong> ' . $verb . '!</p></div>';
        } else {
            $notice = '<div class="notice notice-error is-dismissible"><p>❌ Preencha ao menos Slug, Label e Número.</p></div>';
        }
    }

    // ── Remover canal ─────────────────────────────────────────────────────
    if ( isset( $_GET['vm2_del_channel'] ) && check_admin_referer( 'vm2_del_ch' ) ) {
        $slug  = sanitize_key( $_GET['vm2_del_channel'] );
        $custom = get_option( 'vm2_channel_pool', [] );
        if ( is_string( $custom ) ) $custom = json_decode( $custom, true ) ?: [];
        if ( isset( $custom[$slug] ) ) {
            unset( $custom[$slug] );
            update_option( 'vm2_channel_pool', $custom );
            $notice = '<div class="notice notice-success is-dismissible"><p>🗑️ Canal removido.</p></div>';
        }
        wp_safe_redirect( admin_url( 'admin.php?page=vm2-settings' ) );
        exit;
    }

    // ── Toggle ativo/pausado de canal ─────────────────────────────────────
    if ( isset( $_POST['vm2_toggle_channel_status'] ) && check_admin_referer( 'vm2_settings_nonce' ) ) {
        $t_slug = sanitize_key( $_POST['vm2_toggle_slug'] ?? '' );
        $t_pool = get_option( 'vm2_channel_pool', [] );
        if ( is_string( $t_pool ) ) $t_pool = json_decode( $t_pool, true ) ?: [];
        if ( $t_slug && isset( $t_pool[ $t_slug ] ) ) {
            $cur_st = $t_pool[ $t_slug ]['status'] ?? 'active';
            $t_pool[ $t_slug ]['status'] = ( $cur_st === 'paused' ) ? 'active' : 'paused';
            update_option( 'vm2_channel_pool', $t_pool );
            $t_label = esc_html( $t_pool[ $t_slug ]['label'] ?? $t_slug );
            if ( $t_pool[ $t_slug ]['status'] === 'active' ) {
                $notice = '<div class="notice notice-success is-dismissible"><p>▶️ Canal <strong>' . $t_label . '</strong> <strong>ativado</strong> — mensagens fluem normalmente.</p></div>';
            } else {
                $notice = '<div class="notice notice-warning is-dismissible"><p>⏸ Canal <strong>' . $t_label . '</strong> <strong>pausado</strong> — nenhuma mensagem vai por este canal.</p></div>';
            }
        }
    }

    $ks       = get_option( 'vm2_kill_switch', '0' );
    $channels = vm2_channels();
    $nonce_del = wp_create_nonce( 'vm2_del_ch' );
    ?>
    <div class="wrap">
        <h1>⚙️ Configurações V2</h1>
        <?php echo $notice; ?>

        <?php /* ── Kill Switch Global ─────────────────────────────────────── */ ?>
        <form method="post">
            <?php wp_nonce_field( 'vm2_settings_nonce' ); ?>
            <div style="background:#fff;border:1px solid #ddd;border-radius:8px;padding:20px;margin:20px 0;border-left:4px solid <?php echo $ks === '1' ? '#e74c3c' : '#27ae60'; ?>">
                <h2 style="margin-top:0">🛑 Kill Switch Global V2</h2>
                <label style="display:flex;align-items:center;gap:8px;cursor:pointer;font-size:14px">
                    <input type="checkbox" name="vm2_kill_switch" value="1" <?php checked( $ks, '1' ); ?> style="width:18px;height:18px">
                    <strong>PARAR TODOS OS ENVIOS V2</strong>
                </label>
                <p class="description" style="margin-top:8px">Quando ativo, nenhuma mensagem do CRM V2 será enviada.</p>
                <p>Status: <strong style="color:<?php echo $ks === '1' ? 'red' : 'green'; ?>;font-size:15px"><?php echo $ks === '1' ? '🔴 PARADO' : '🟢 ATIVO'; ?></strong></p>
                <hr style="margin:16px 0">
                <div style="display:grid;grid-template-columns:1fr 1fr;gap:16px;margin-top:12px">
                    <label style="font-size:13px;display:block">
                        <strong>📦 Cap Global Diário (msgs/dia)</strong>
                        <br><span style="color:#6b7280;font-size:12px">Total de todos os módulos — 0 = sem limite</span>
                        <br><input type="number" name="vm2_global_daily_limit" value="<?php echo esc_attr((int)get_option('vm2_global_daily_limit',0)); ?>" min="0" max="9999" style="width:120px;margin-top:6px;padding:6px 8px;border:1px solid #ddd;border-radius:6px">
                    </label>
                    <label style="font-size:13px;display:block">
                        <strong>📅 Máx msgs/contato por 7 dias</strong>
                        <br><span style="color:#6b7280;font-size:12px">Evita spam no mesmo contato — 0 = sem limite</span>
                        <br><input type="number" name="vm2_contact_weekly_limit" value="<?php echo esc_attr((int)get_option('vm2_contact_weekly_limit',0)); ?>" min="0" max="99" style="width:120px;margin-top:6px;padding:6px 8px;border:1px solid #ddd;border-radius:6px">
                    </label>
                </div>
            </div>
            <button type="submit" name="vm2_save_settings" class="button button-primary">💾 Salvar</button>

            <!-- ── Integração Google Sheets ── -->
            <div id="fin-webhook" style="margin-top:24px;background:#fff;border:1px solid #ddd;border-radius:8px;padding:20px;border-left:4px solid #7c3aed">
                <h2 style="margin-top:0">📊 Integração Google Sheets — Financeiro</h2>
                <p style="color:#6b7280;font-size:13px;margin-bottom:16px">
                    Configure o webhook do Tasklet para sincronizar a planilha VIVAMAIS-VENDAS com o módulo Financeiro.<br>
                    <strong>Como obter a URL:</strong> No Tasklet, vá em <em>Triggers → Sincronizar Financeiro GSheets</em> e copie a Webhook URL.
                </p>
                <div style="display:grid;gap:12px;max-width:600px">
                    <div>
                        <label style="font-size:13px;font-weight:600;color:#374151;display:block;margin-bottom:4px">🔗 Webhook URL (Tasklet)</label>
                        <input type="url" name="vm2_fin_webhook_url"
                               value="<?php echo esc_attr(get_option('vm2_fin_webhook_url','')); ?>"
                               placeholder="https://webhooks.tasklet.ai/v1/public/webhook/..."
                               style="width:100%;padding:8px 12px;border:1px solid #d1d5db;border-radius:6px;font-size:13px">
                        <p class="description">URL do webhook gerado pelo Tasklet para disparar a sincronização.</p>
                    </div>
                    <div>
                        <label style="font-size:13px;font-weight:600;color:#374151;display:block;margin-bottom:4px">🔑 Token de Sincronização</label>
                        <input type="text" name="vm2_fin_sync_token"
                               value="<?php echo esc_attr(get_option('vm2_fin_sync_token','vm2fsync_9kqw3p7x')); ?>"
                               style="width:100%;padding:8px 12px;border:1px solid #d1d5db;border-radius:6px;font-size:13px;font-family:monospace">
                        <p class="description">Token Bearer que o Tasklet usa ao enviar dados. Padrão: <code>vm2fsync_9kqw3p7x</code></p>
                    </div>
                    <?php $last_sync = get_option('vm2_fin_last_sync',''); if ($last_sync): ?>
                    <div style="padding:10px;background:#f0fdf4;border-radius:6px;font-size:13px;color:#065f46">
                        ✅ Última sync: <?php echo esc_html(vm2_local_date('d/m/Y H:i', $last_sync)); ?>
                    </div>
                    <?php endif; ?>
                </div>
            </div>

            <!-- ── Integração Google Sheets — Agenda ── -->
            <div id="agenda-webhook" style="margin-top:24px;background:#fff;border:1px solid #ddd;border-radius:8px;padding:20px;border-left:4px solid #059669">
                <h2 style="margin-top:0">📅 Integração Google Sheets — Agenda</h2>
                <p style="color:#6b7280;font-size:13px;margin-bottom:16px">
                    Configure o webhook do Tasklet para sincronizar a aba <strong>VENDAS</strong> da planilha com a Agenda do CRM.<br>
                    <strong>Como obter a URL:</strong> No Tasklet, vá em <em>Triggers → Sincronizar Agenda GSheets</em> e copie a Webhook URL.
                </p>
                <div style="max-width:600px">
                    <label style="font-size:13px;font-weight:600;color:#374151;display:block;margin-bottom:4px">🔗 Webhook URL (Tasklet)</label>
                    <input type="url" name="vm2_agenda_webhook_url"
                           value="<?php echo esc_attr(get_option('vm2_agenda_webhook_url','')); ?>"
                           placeholder="https://webhooks.tasklet.ai/v1/public/webhook/..."
                           style="width:100%;padding:8px 12px;border:1px solid #d1d5db;border-radius:6px;font-size:13px">
                    <p class="description">URL do webhook gerado pelo Tasklet para disparar a sincronização da Agenda.</p>
                    <?php $ag_sync = get_option('vm2_agenda_last_sync',''); if ($ag_sync): ?>
                    <div style="padding:10px;background:#ecfdf5;border-radius:6px;font-size:13px;color:#065f46;margin-top:8px">
                        ✅ Última sync: <?php echo esc_html(date('d/m/Y H:i', strtotime($ag_sync))); ?>
                    </div>
                    <?php endif; ?>
                </div>
            </div>
        </form>

        <?php /* ── Pool de Canais ──────────────────────────────────────────── */ ?>
        <div style="background:#fff;border:1px solid #ddd;border-radius:8px;padding:24px;margin:28px 0">
            <h2 style="margin-top:0">📡 Pool de Canais de Envio</h2>
            <p class="description">Canais disponíveis em todos os módulos V2. Canais padrão não podem ser removidos.</p>

            <style>
            .vm2-channel-grid{display:grid;grid-template-columns:1fr;gap:12px;margin-bottom:20px}
            @media(min-width:600px){.vm2-channel-grid{grid-template-columns:repeat(2,1fr)}}
            @media(min-width:960px){.vm2-channel-grid{grid-template-columns:repeat(3,1fr)}}
            .vm2-channel-card{border:1px solid #ddd;border-radius:8px;padding:14px 16px;background:#fff;position:relative}
            .vm2-channel-card.locked{background:#f9f9f9}
            .vm2-channel-card .ch-badge{display:inline-block;padding:2px 8px;border-radius:20px;font-size:11px;font-weight:700;color:#fff;margin-bottom:8px}
            .vm2-channel-card .ch-badge.zapi{background:#25d366}
            .vm2-channel-card .ch-badge.waba{background:#3b82f6}
            .vm2-channel-card .ch-label{font-weight:600;font-size:14px;margin-bottom:4px}
            .vm2-channel-card .ch-slug{font-family:monospace;font-size:12px;color:#666;background:#f0f0f0;padding:2px 6px;border-radius:4px;display:inline-block;margin-bottom:6px}
            .vm2-channel-card .ch-number{font-size:13px;color:#444;margin-bottom:4px}
            .vm2-channel-card .ch-instance{font-size:11px;color:#999;word-break:break-all}
            .vm2-channel-card .ch-actions{position:absolute;top:10px;right:10px;display:flex;gap:4px}
            .vm2-channel-card .ch-del{font-size:12px}
            .vm2-channel-card .ch-locked{font-size:11px;color:#bbb}
            @media(min-width:600px){.vm2-ch-form-grid{grid-template-columns:repeat(2,1fr) !important}}
            @media(min-width:960px){.vm2-ch-form-grid{grid-template-columns:repeat(3,1fr) !important}}
            </style>
            <div class="vm2-channel-grid">
            <?php foreach ( $channels as $key => $ch ) :
                $locked     = false;
                $type       = $ch['type'] ?? 'zapi';
                $type_label = $type === 'waba' ? 'WABA' : 'Z-API';
                $ch_status  = $ch['status'] ?? 'active';
                $is_paused  = ( $ch_status === 'paused' );
                $sends_today = vm2_channel_today_count( $key );
            ?>
            <div class="vm2-channel-card<?php echo $locked ? ' locked' : ''; ?>"
                 style="<?php echo $is_paused ? 'opacity:0.75;border-left:4px solid #f59e0b' : 'border-left:4px solid #22c55e'; ?>">
                <span class="ch-badge <?php echo esc_attr($type); ?>"><?php echo esc_html($type_label); ?></span>
                <span style="font-size:11px;font-weight:700;padding:2px 7px;border-radius:10px;margin-left:4px;vertical-align:middle;<?php echo $is_paused ? 'background:#fef3c7;color:#92400e' : 'background:#dcfce7;color:#166534'; ?>">
                    <?php echo $is_paused ? '⏸ Pausado' : '▶️ Ativo'; ?>
                </span>
                <div class="ch-actions">
                <?php if ( $locked ) : ?>
                    <span class="ch-locked">🔒 padrão</span>
                    <button type="button" class="button button-small ch-edit"
                        style="padding:2px 7px;font-size:12px"
                        onclick="vm2ChEdit(<?php echo esc_attr(json_encode($key)); ?>, <?php echo esc_attr(json_encode($ch)); ?>)">✏️</button>
                <?php else : ?>
                    <form method="post" style="display:inline">
                        <?php wp_nonce_field('vm2_settings_nonce'); ?>
                        <input type="hidden" name="vm2_toggle_slug" value="<?php echo esc_attr($key); ?>">
                        <button type="submit" name="vm2_toggle_channel_status" class="button button-small"
                            style="padding:2px 7px;font-size:12px;<?php echo $is_paused ? 'color:#166534;font-weight:700' : 'color:#9a3412'; ?>"
                            title="<?php echo $is_paused ? 'Ativar canal' : 'Pausar canal'; ?>">
                            <?php echo $is_paused ? '▶️' : '⏸'; ?>
                        </button>
                    </form>
                    <button type="button" class="button button-small ch-edit"
                        style="padding:2px 7px;font-size:12px"
                        onclick="vm2ChEdit(<?php echo esc_attr(json_encode($key)); ?>, <?php echo esc_attr(json_encode($ch)); ?>)">✏️</button>
                    <a href="<?php echo esc_url( admin_url( 'admin.php?page=vm2-settings&vm2_del_channel=' . $key . '&_wpnonce=' . $nonce_del ) ); ?>"
                       onclick="return confirm('Remover canal <?php echo esc_js($key); ?>?')"
                       class="button button-small ch-del" style="color:#c0392b;padding:2px 7px;font-size:12px">🗑️</a>
                <?php endif; ?>
                </div>
                <div class="ch-label"><?php echo esc_html( $ch['label'] ); ?></div>
                <div class="ch-slug"><?php echo esc_html( $key ); ?></div>
                <div class="ch-number">📱 <?php echo esc_html( $ch['number'] ?? '—' ); ?></div>
                <div style="font-size:11px;color:#666;margin-top:3px">
                    📊 <?php echo $sends_today; ?> enviados hoje
                    <?php if ( ! empty($ch['daily_limit']) ) echo ' / ' . (int)$ch['daily_limit'] . ' limite'; ?>
                </div>
                <?php if ( ! $locked && ! empty( $ch['instance'] ) ) : ?>
                <div class="ch-instance">ID: <?php echo esc_html( substr($ch['instance'], 0, 20) . '…' ); ?></div>
                <?php endif; ?>
            </div>
            <?php endforeach; ?>
            </div>

            <?php /* ── Formulário Adicionar Canal ──────────────────────────── */ ?>
            <details id="vm2ChDetails" style="border:1px solid #ddd;border-radius:6px;padding:16px">
                <summary id="vm2ChSummary" style="cursor:pointer;font-weight:600;font-size:14px">➕ Adicionar novo canal</summary>
                <form method="post" style="margin-top:16px" id="vm2ChForm">
                    <?php wp_nonce_field( 'vm2_channel_nonce' ); ?>
                    <input type="hidden" name="ch_edit_key" id="vm2ChEditKey" value="">
                    <div style="display:grid;grid-template-columns:1fr;gap:14px;margin-bottom:16px" class="vm2-ch-form-grid">
                        <label>
                            <span style="display:block;font-size:12px;font-weight:600;margin-bottom:4px">Tipo *</span>
                            <select name="ch_type" style="width:100%">
                                <option value="zapi">📱 Z-API</option>
                                <option value="waba">🔵 WABA (Meta)</option>
                            </select>
                        </label>
                        <label>
                            <span style="display:block;font-size:12px;font-weight:600;margin-bottom:4px">Slug / Chave * <span style="font-weight:400;color:#666">(ex: zapi_novo)</span></span>
                            <input type="text" name="ch_slug" placeholder="zapi_novo" style="width:100%" required pattern="[a-z0-9_]+" title="Apenas letras minúsculas, números e _">
                        </label>
                        <label>
                            <span style="display:block;font-size:12px;font-weight:600;margin-bottom:4px">Label * <span style="font-weight:400;color:#666">(nome amigável)</span></span>
                            <input type="text" name="ch_label" placeholder="📞 VIVA 9999 (vendas)" style="width:100%" required>
                        </label>
                        <label>
                            <span style="display:block;font-size:12px;font-weight:600;margin-bottom:4px">Número * <span style="font-weight:400;color:#666">(DDI+DDD+número)</span></span>
                            <input type="text" name="ch_number" placeholder="5511999999999" style="width:100%" required>
                        </label>
                        <label>
                            <span style="display:block;font-size:12px;font-weight:600;margin-bottom:4px">Instance ID</span>
                            <input type="text" name="ch_instance" placeholder="3FXXXX..." style="width:100%">
                        </label>
                        <label>
                            <span style="display:block;font-size:12px;font-weight:600;margin-bottom:4px">Token</span>
                            <input type="text" name="ch_token" placeholder="Token Z-API" style="width:100%">
                        </label>
                        <label>
                            <span style="display:block;font-size:12px;font-weight:600;margin-bottom:4px">Client Token</span>
                            <input type="text" name="ch_client" placeholder="Client token Z-API" style="width:100%">
                        </label>
                        <label>
                            <span style="display:block;font-size:12px;font-weight:600;margin-bottom:4px">📊 Limite diário de envios</span>
                            <input type="number" name="ch_daily_limit" value="50" min="1" max="500" style="width:100%" title="Máximo de mensagens por dia neste canal">
                        </label>
                    </div>
                    <button type="submit" name="vm2_add_channel" id="vm2ChSubmit" class="button button-primary">➕ Adicionar Canal</button>
                    <button type="button" id="vm2ChCancelEdit" class="button" style="margin-left:8px;display:none" onclick="vm2ChCancelEdit()">✖ Cancelar</button>
                    <p class="description" style="margin-top:8px">⏸ Novo canal começa <strong>pausado</strong> — nenhuma mensagem flui até você clicar ▶️ para ativar. Isso evita flood em números recém-conectados.</p>
                </form>
            </details>
            <script>
            function vm2ChEdit(slug, ch) {
                var d = document.getElementById('vm2ChDetails');
                d.open = true;
                document.getElementById('vm2ChSummary').textContent = '✏️ Editar canal: ' + (ch.label || slug);
                document.getElementById('vm2ChEditKey').value = slug;
                var f = document.getElementById('vm2ChForm');
                f.querySelector('[name="ch_type"]').value    = ch.type     || 'zapi';
                f.querySelector('[name="ch_slug"]').value    = slug;
                f.querySelector('[name="ch_slug"]').removeAttribute('required'); // slug pode ser igual
                f.querySelector('[name="ch_label"]').value   = ch.label    || '';
                f.querySelector('[name="ch_number"]').value  = ch.number   || '';
                f.querySelector('[name="ch_instance"]').value= ch.instance || '';
                f.querySelector('[name="ch_token"]').value   = ch.token    || '';
                f.querySelector('[name="ch_client"]').value      = ch.client      || '';
                f.querySelector('[name="ch_daily_limit"]').value = ch.daily_limit || 50;
                document.getElementById('vm2ChSubmit').textContent = '💾 Salvar alterações';
                document.getElementById('vm2ChCancelEdit').style.display = 'inline-block';
                d.scrollIntoView({behavior:'smooth', block:'nearest'});
            }
            function vm2ChCancelEdit() {
                document.getElementById('vm2ChEditKey').value = '';
                document.getElementById('vm2ChForm').reset();
                document.getElementById('vm2ChSummary').textContent = '➕ Adicionar novo canal';
                document.getElementById('vm2ChSubmit').textContent = '➕ Adicionar Canal';
                document.getElementById('vm2ChCancelEdit').style.display = 'none';
                document.getElementById('vm2ChDetails').open = false;
            }
            </script>
        </div>
    </div>

        <?php /* ── Templates WABA ─────────────────────────────────────── */ ?>
        <div id="vm2-waba-tpls" style="background:#fff;border:1px solid #ddd;border-radius:8px;padding:24px;margin:28px 0">
            <h2 style="margin-top:0">📋 Templates WABA Aprovados</h2>
            <p class="description">Templates disponíveis em todos os módulos quando canal WABA for selecionado. Templates padrão não podem ser removidos.</p>

            <?php
            $default_wt = [
                'vm_pos_janela_d3'             => 'D+1 pós janela',
                '48h_waba_4loz4q'              => 'D+1 alternativo',
                '5d_waba_gg939i'               => 'D+5/7',
                '15d_waba_qlwlek'              => 'D+15',
                '30d_waba_h2turh'              => 'D+30',
                'cartaopresente'               => 'Vale Presente',
                'oferta_de_reconquista_vxu081' => 'Reengajamento',
                'recupera_carrinho_woo'        => 'WA Recovery',
            ];
            $custom_wt = get_option( 'vm2_waba_templates', [] );
            if ( is_string( $custom_wt ) ) $custom_wt = json_decode( $custom_wt, true ) ?: [];
            $nonce_del_wt = wp_create_nonce('vm2_del_waba_tpl');
            ?>

            <div style="overflow-x:auto">
            <table class="widefat striped" style="margin-bottom:20px;min-width:500px">
                <thead><tr>
                    <th style="width:260px">Slug técnico</th>
                    <th>Descrição</th>
                    <th style="width:100px">Tipo</th>
                    <th style="width:80px"></th>
                </tr></thead>
                <tbody>
                <?php foreach ( $default_wt as $wt_slug => $wt_desc ) : ?>
                <tr>
                    <td><code style="font-size:11px"><?php echo esc_html($wt_slug); ?></code></td>
                    <td><?php echo esc_html($wt_desc); ?></td>
                    <td><span style="background:#e8f5e9;color:#2e7d32;padding:2px 8px;border-radius:10px;font-size:11px;white-space:nowrap">🔒 Padrão</span></td>
                    <td></td>
                </tr>
                <?php endforeach; ?>
                <?php foreach ( $custom_wt as $wt_slug => $wt_desc ) : ?>
                <tr>
                    <td><code style="font-size:11px"><?php echo esc_html($wt_slug); ?></code></td>
                    <td><?php echo esc_html($wt_desc); ?></td>
                    <td><span style="background:#e3f2fd;color:#1565c0;padding:2px 8px;border-radius:10px;font-size:11px;white-space:nowrap">✨ Custom</span></td>
                    <td>
                        <a href="<?php echo esc_url( admin_url( 'admin.php?page=vm2-settings&vm2_del_waba_tpl=' . $wt_slug . '&_wpnonce=' . $nonce_del_wt ) ); ?>"
                           style="color:#e74c3c;font-size:12px;white-space:nowrap"
                           onclick="return confirm('Remover este template?')">🗑️ Remover</a>
                    </td>
                </tr>
                <?php endforeach; ?>
                </tbody>
            </table>
            </div>

            <details style="margin-top:8px">
                <summary style="cursor:pointer;color:#0073aa;font-size:13px;font-weight:600">➕ Adicionar template custom</summary>
                <form method="post" style="background:#f9f9f9;padding:16px;border-radius:6px;border:1px solid #eee;margin-top:8px">
                    <?php wp_nonce_field('vm2_waba_tpl_nonce'); ?>
                    <div style="display:flex;gap:12px;flex-wrap:wrap;align-items:flex-end">
                        <div>
                            <label style="font-size:12px;font-weight:600;display:block;margin-bottom:4px">Slug técnico</label>
                            <input type="text" name="tpl_name[]" placeholder="nome_do_template_abc" style="width:220px;font-family:monospace;font-size:12px" required>
                        </div>
                        <div>
                            <label style="font-size:12px;font-weight:600;display:block;margin-bottom:4px">Descrição amigável</label>
                            <input type="text" name="tpl_label[]" placeholder="Ex: Oferta especial D+60" style="width:240px" required>
                        </div>
                        <button type="submit" name="vm2_save_waba_tpls" class="button button-primary">➕ Adicionar</button>
                    </div>
                    <p class="description" style="margin-top:8px">⚠️ O template deve estar aprovado na Meta antes de cadastrar aqui.</p>
                </form>
            </details>
        </div>

    <?php
}

// ─────────────────────────────────────────────────────────────
// WOOCOMMERCE HOOKS
// ─────────────────────────────────────────────────────────────

// Hook 1: Todos os pedidos → Grupo Vendas
add_action( 'woocommerce_checkout_order_processed', 'vm2_notify_grupo_vendas', 20, 1 );
function vm2_notify_grupo_vendas( $order_id ) {
    if ( get_option( 'vm2_kill_switch', '0' ) === '1' ) return;
    if ( get_option( 'vm2_pedidos_vendas_enabled', '1' ) !== '1' ) return;

    $order = wc_get_order( $order_id );
    if ( ! $order ) return;

    // Guard anti-duplicata
    if ( $order->get_meta( '_vm2_notified_vendas' ) ) return;
    $order->update_meta_data( '_vm2_notified_vendas', gmdate('Y-m-d H:i:s') );
    $order->save();

    $vars    = vm2_build_order_vars( $order );
    $msg     = vm2_replace_vars( get_option( 'vm2_pedidos_vendas_msg', vm2_default_msg_vendas() ), $vars );
    $channel = get_option( 'vm2_pedidos_vendas_channel', 'zapi_7551' );
    $group   = get_option( 'vm2_pedidos_vendas_group_id', '120363425785358764-group' );

    vm2_send_zapi( $channel, $group, $msg );
}

// Hook 2: Pedido → Grupo Agenda (signing-pending, contract-signed, processing)
add_action( 'woocommerce_order_status_processing',      'vm2_notify_grupo_agenda', 20, 1 );
add_action( 'woocommerce_order_status_signing-pending', 'vm2_notify_grupo_agenda', 20, 1 );
add_action( 'woocommerce_order_status_contract-signed', 'vm2_notify_grupo_agenda', 20, 1 );
function vm2_notify_grupo_agenda( $order_id ) {
    if ( get_option( 'vm2_kill_switch', '0' ) === '1' ) return;
    if ( get_option( 'vm2_pedidos_agenda_enabled', '1' ) !== '1' ) return;

    $order = wc_get_order( $order_id );
    if ( ! $order ) return;

    // Guard anti-duplicata — só envia 1x por pedido
    if ( $order->get_meta( '_vm2_notified_agenda' ) ) return;
    $order->update_meta_data( '_vm2_notified_agenda', gmdate('Y-m-d H:i:s') );
    $order->save();

    $vars    = vm2_build_order_vars( $order );
    $msg     = vm2_replace_vars( get_option( 'vm2_pedidos_agenda_msg', vm2_default_msg_agenda() ), $vars );
    $channel = get_option( 'vm2_pedidos_agenda_channel', 'zapi_7551' );
    $group   = get_option( 'vm2_pedidos_agenda_group_id', '120363419180214481-group' );

    vm2_send_zapi( $channel, $group, $msg );
}

// Hook 3: Pedido → Cliente (WhatsApp direto)
add_action( 'woocommerce_order_status_processing',      'vm2_notify_cliente', 20, 1 );
add_action( 'woocommerce_order_status_signing-pending', 'vm2_notify_cliente', 20, 1 );
function vm2_notify_cliente( $order_id ) {
    if ( get_option( 'vm2_kill_switch', '0' ) === '1' ) return;
    if ( get_option( 'vm2_pedidos_cliente_enabled', '0' ) !== '1' ) return;

    $order = wc_get_order( $order_id );
    if ( ! $order ) return;

    // Guard anti-duplicata — só envia 1x por pedido
    if ( $order->get_meta( '_vm2_notified_cliente' ) ) return;
    $order->update_meta_data( '_vm2_notified_cliente', gmdate('Y-m-d H:i:s') );
    $order->save();

    $vars    = vm2_build_order_vars( $order );
    $telefone = $vars['{telefone}'];
    if ( ! $telefone || strlen( $telefone ) < 10 ) return;

    $msg     = vm2_replace_vars( get_option( 'vm2_pedidos_cliente_msg', vm2_default_msg_cliente() ), $vars );
    $channel = get_option( 'vm2_pedidos_cliente_channel', 'zapi_1886' );

    vm2_send_zapi( $channel, $telefone, $msg );

    // ── Cópia ao grupo de vendas ──────────────────────────────
    if ( get_option( 'vm2_pedidos_cliente_copy_vendas', '0' ) === '1' ) {
        $copy_msg  = "📋 *Comunicado enviado ao cliente*\n\n";
        $copy_msg .= "*Cliente:* {nome}\n";
        $copy_msg .= "*Pedido:* #{numero}\n\n";
        $copy_msg .= "✅ Mensagem enviada no WhatsApp:\n";
        $copy_msg .= "─────────────────────\n";
        $copy_msg .= $msg;
        $copy_channel = get_option( 'vm2_pedidos_vendas_channel', 'zapi_7551' );
        $copy_group   = get_option( 'vm2_pedidos_vendas_group_id', '120363425785358764-group' );
        vm2_send_zapi( $copy_channel, $copy_group, vm2_replace_vars( $copy_msg, $vars ) );
    }
}

// ─────────────────────────────────────────────────────────────
// BUILD ORDER VARIABLES
// ─────────────────────────────────────────────────────────────
function vm2_build_order_vars( $order ) {
    $order_id = $order->get_id();

    // Nome e telefone
    $nome     = trim( $order->get_billing_first_name() . ' ' . $order->get_billing_last_name() );
    $telefone = preg_replace( '/\D/', '', $order->get_billing_phone() );

    // Normalizar DDI — adicionar 55 se necessário
    if ( strlen( $telefone ) <= 11 ) {
        $telefone = '55' . $telefone;
    }
    // Fix duplo DDI (5555XXXXXXXXXXX)
    while ( strlen( $telefone ) > 13 && strpos( $telefone, '5555' ) === 0 ) {
        $telefone = '55' . substr( $telefone, 4 );
    }

    // Produtos
    $produtos = [];
    foreach ( $order->get_items() as $item ) {
        $produtos[] = $item->get_name();
    }

    // YITH Booking — meta está em yith_booking_data como array {from, to, duration}
    $hora_inicio  = '—';
    $hora_termino = '—';
    $duracao      = '—';
    foreach ( $order->get_items() as $item ) {
        // Tenta yith_booking_data (array aninhado)
        $bd = $item->get_meta( 'yith_booking_data' );
        if ( is_array( $bd ) && ! empty( $bd['from'] ) ) {
            $from = $bd['from'];
            $to   = isset( $bd['to'] ) ? $bd['to'] : 0;
            $tz           = new DateTimeZone( 'America/Sao_Paulo' );
            $dt_from      = new DateTime( '@' . $from );
            $dt_from->setTimezone( $tz );
            $hora_inicio  = $dt_from->format( 'H:i' );
            if ( $to ) {
                $dt_to = new DateTime( '@' . $to );
                $dt_to->setTimezone( $tz );
                $hora_termino = $dt_to->format( 'H:i' );
                $duracao      = round( ( $to - $from ) / 60 );
            }
            break;
        }
        // Fallback: meta direto from/to (legado)
        $from = $item->get_meta( 'from' );
        $to   = $item->get_meta( 'to' );
        if ( $from && $to ) {
            $tz           = new DateTimeZone( 'America/Sao_Paulo' );
            $dt_from      = new DateTime( '@' . $from );
            $dt_to        = new DateTime( '@' . $to );
            $dt_from->setTimezone( $tz );
            $dt_to->setTimezone( $tz );
            $hora_inicio  = $dt_from->format( 'H:i' );
            $hora_termino = $dt_to->format( 'H:i' );
            $duracao      = round( ( $to - $from ) / 60 );
            break;
        }
    }

    // Meta fields do checkout
    $event_date_raw = $order->get_meta( '_billing_event_date' );
    // Fallback: extrair data do timestamp YITH Booking quando _billing_event_date estiver vazio
    if ( ! $event_date_raw && ! empty( $from ) ) {
        $tz_date        = new DateTimeZone( 'America/Sao_Paulo' );
        $dt_date        = new DateTime( '@' . intval( $from ) );
        $dt_date->setTimezone( $tz_date );
        $event_date_raw = $dt_date->format( 'd/m/Y' );
    }
    $data_evento    = vm2_format_event_date( $event_date_raw );
    $tipo_evento    = $order->get_meta( '_billing_tipo_evento' )   ?: '—';
    $homenageado    = $order->get_meta( '_billing_homenageado' )   ?: '—';
    $assessor       = $order->get_meta( '_billing_assessor' )      ?: '—';

    // Endereço do evento (shipping)
    $endereco  = $order->get_shipping_address_1();
    $endereco2 = $order->get_shipping_address_2(); // nome do buffet/local
    // Monta endereço completo (addr1 + addr2 se existir)
    $endereco_full = $endereco . ( $endereco2 ? ', ' . $endereco2 : '' );
    $bairro    = $order->get_meta( '_shipping_neighborhood' ) ?: $order->get_meta( 'shipping_neighborhood' ) ?: '';
    $cidade    = $order->get_shipping_city();
    $estado    = $order->get_shipping_state();
    // Monta local completo: Bairro - Cidade/Estado
    $local_evento = trim( ( $bairro ? $bairro . ' - ' : '' ) . $cidade . '/' . $estado );

    // ClickSign
    $contrato = vm2_get_clicksign_status( $order_id );

    // UTM
    $utm_source   = $order->get_meta( '_order_utm_source' )
                ?: $order->get_meta( '_wc_order_attribution_utm_source' )
                ?: '—';
    $utm_campaign = $order->get_meta( '_order_utm_campaign' )
                ?: $order->get_meta( '_wc_order_attribution_utm_campaign' )
                ?: '—';

    return [
        '{numero}'       => $order_id,
        '{nome}'         => $nome,
        '{telefone}'     => $telefone,
        '{email}'        => $order->get_billing_email(),
        '{valor}'        => number_format( $order->get_total(), 2, ',', '.' ),
        '{pgto}'         => $order->get_payment_method_title(),
        '{atracao}'      => implode( ', ', $produtos ),
        '{data_evento}'  => $data_evento,
        '{tipo_evento}'  => $tipo_evento,
        '{homenageado}'  => $homenageado,
        '{assessor}'     => $assessor,
        '{endereco}'     => $endereco_full ?: $endereco ?: '—',
        '{endereco2}'    => $endereco2 ?: '',
        '{bairro}'       => $bairro ?: '—',
        '{cidade}'       => $cidade ?: '—',
        '{estado}'       => $estado ?: '—',
        '{local_evento}' => $local_evento ?: '—',
        '{hora_inicio}'  => $hora_inicio,
        '{hora_termino}' => $hora_termino,
        '{duracao}'      => $duracao,
        '{obs}'          => $order->get_customer_note() ?: '—',
        '{contrato}'     => $contrato,
        '{utm_source}'   => $utm_source,
        '{utm_campaign}' => $utm_campaign,
        '{link_admin}'   => admin_url( "post.php?post={$order_id}&action=edit" ),
    ];
}

function vm2_format_event_date( $raw ) {
    if ( ! $raw ) return '—';
    // DDMMYYYY → DD/MM/YYYY
    if ( preg_match( '/^(\d{2})(\d{2})(\d{4})$/', $raw, $m ) ) {
        return "{$m[1]}/{$m[2]}/{$m[3]}";
    }
    // DD/MM/YY → DD/MM/20YY
    if ( preg_match( '/^(\d{2})\/(\d{2})\/(\d{2})$/', $raw, $m ) ) {
        return "{$m[1]}/{$m[2]}/20{$m[3]}";
    }
    return $raw;
}

function vm2_get_clicksign_status( $order_id ) {
    $order = wc_get_order( $order_id );
    if ( ! $order ) return '—';
    $statuses = [];
    // Usa get_meta_data() para compatibilidade com HPOS
    foreach ( $order->get_meta_data() as $meta ) {
        $data = $meta->get_data();
        if ( strpos( $data['key'], '_clicksign_status' ) !== false ) {
            $statuses[] = strtolower( $data['value'] );
        }
    }
    // Fallback: get_post_meta para lojas sem HPOS
    if ( empty( $statuses ) ) {
        $raw = get_post_meta( $order_id, '_clicksign_status', false );
        foreach ( (array) $raw as $v ) {
            $statuses[] = strtolower( $v );
        }
    }
    if ( empty( $statuses ) ) return '—';
    $signed_values = [ 'signed', 'finalized', 'finalizado', 'completed', 'finished' ];
    foreach ( $signed_values as $sv ) {
        if ( in_array( $sv, $statuses, true ) ) return '✅ Contrato assinado';
    }
    if ( ! empty( $statuses ) ) return '⏳ Aguardando assinatura';
    return '—';
}

// ─────────────────────────────────────────────────────────────
// REPLACE VARS
// ─────────────────────────────────────────────────────────────
function vm2_replace_vars( $msg, $vars ) {
    return str_replace( array_keys( $vars ), array_values( $vars ), $msg );
}

// ─────────────────────────────────────────────────────────────
// SEND VIA Z-API
// ─────────────────────────────────────────────────────────────
function vm2_send_zapi( $channel_key, $phone, $message ) {
    $channels = vm2_channels();
    if ( ! isset( $channels[ $channel_key ] ) ) {
        vm2_log( "Canal não encontrado: {$channel_key}", 'error' );
        return false;
    }
    $ch  = $channels[ $channel_key ];
    $url = "https://api.z-api.io/instances/{$ch['instance']}/token/{$ch['token']}/send-text";

    $response = wp_remote_post( $url, [
        'headers' => [
            'Content-Type' => 'application/json',
            'Client-Token' => VM2_ZAPI_CLIENT,
        ],
        'body'    => wp_json_encode( [ 'phone' => $phone, 'message' => $message ] ),
        'timeout' => 15,
    ] );

    if ( is_wp_error( $response ) ) {
        vm2_log( "Z-API erro [{$channel_key}→{$phone}]: " . $response->get_error_message(), 'error' );
        return false;
    }

    $code = wp_remote_retrieve_response_code( $response );
    $body = wp_remote_retrieve_body( $response );
    vm2_log( "Z-API [{$channel_key}→{$phone}] HTTP {$code}: {$body}", $code === 200 ? 'info' : 'error' );
    return $code === 200;
}


// ─────────────────────────────────────────────────────────────
// HELPER — SEND WABA (Meta Graph API via pool dinâmico)
// ─────────────────────────────────────────────────────────────
function vm2_send_waba( $channel_key, $phone, $template_name, $components = [] ) {
    $channels = vm2_channels();
    if ( ! isset( $channels[ $channel_key ] ) ) {
        vm2_log( "Canal WABA não encontrado: {$channel_key}", 'error' );
        return false;
    }
    $ch       = $channels[ $channel_key ];
    $phone_id = $ch['instance'] ?? '';  // para WABA: Phone Number ID (campo instance)
    $token    = $ch['token']    ?? '';

    if ( ! $phone_id || ! $token ) {
        vm2_log( "WABA {$channel_key}: phone_id ou token não configurado", 'error' );
        return false;
    }

    $body = wp_json_encode( [
        'messaging_product' => 'whatsapp',
        'to'                => $phone,
        'type'              => 'template',
        'template'          => [
            'name'       => $template_name,
            'language'   => [ 'code' => 'pt_BR' ],
            'components' => $components,
        ],
    ] );

    $url      = "https://graph.facebook.com/v21.0/{$phone_id}/messages";
    $response = wp_remote_post( $url, [
        'headers' => [
            'Authorization' => 'Bearer ' . $token,
            'Content-Type'  => 'application/json',
        ],
        'body'    => $body,
        'timeout' => 15,
    ] );

    if ( is_wp_error( $response ) ) {
        vm2_log( "WABA erro [{$channel_key}→{$phone}]: " . $response->get_error_message(), 'error' );
        return false;
    }

    $code      = wp_remote_retrieve_response_code( $response );
    $body_resp = wp_remote_retrieve_body( $response );
    $success   = ( $code === 200 );
    vm2_log( "WABA [{$channel_key}→{$phone}] HTTP {$code}: {$body_resp}", $success ? 'info' : 'error' );
    return [ 'ok' => $success, 'code' => $code, 'body' => $body_resp ];
}

// ─────────────────────────────────────────────────────────────
// HELPER — FORMATAR TELEFONE (remove DDI 55 duplo)
// ─────────────────────────────────────────────────────────────
function vm2_format_phone( $raw ) {
    $phone = preg_replace( '/\D/', '', $raw );
    // Remove DDI 55 duplicado: 5555129741070 → 5511941070
    if ( strlen( $phone ) >= 13 && substr( $phone, 0, 4 ) === '5555' ) {
        $phone = '55' . substr( $phone, 4 );
    }
    // Adiciona DDI 55 se ausente
    if ( strlen( $phone ) >= 10 && strlen( $phone ) <= 11 ) {
        $phone = '55' . $phone;
    }
    return $phone;
}

// ─────────────────────────────────────────────────────────────
// HELPER — DATA DO EVENTO → TIMESTAMP
// ─────────────────────────────────────────────────────────────
function vm2_event_date_to_ts( $raw ) {
    if ( ! $raw ) return 0;
    // DDMMYYYY
    if ( preg_match( '/^(\d{2})(\d{2})(\d{4})$/', $raw, $m ) ) {
        return mktime( 12, 0, 0, intval($m[2]), intval($m[1]), intval($m[3]) );
    }
    // DD/MM/YY
    if ( preg_match( '/^(\d{2})\/(\d{2})\/(\d{2})$/', $raw, $m ) ) {
        return mktime( 12, 0, 0, intval($m[2]), intval($m[1]), 2000 + intval($m[3]) );
    }
    // DD/MM/YYYY
    if ( preg_match( '/^(\d{2})\/(\d{2})\/(\d{4})$/', $raw, $m ) ) {
        return mktime( 12, 0, 0, intval($m[2]), intval($m[1]), intval($m[3]) );
    }
    return 0;
}

// ─────────────────────────────────────────────────────────────
// AGENDA PAGE
// ─────────────────────────────────────────────────────────────
/**
 * Parse inline do blob da col C do GSheets.
 * Usado como fallback quando o sync não pré-parseou os campos.
 */
function vm2_parse_agenda_blob( $blob ) {
    $r = [ 'tipo' => '', 'homenageado' => '', 'local' => '', 'endereco' => '', 'assessor' => '', 'horario' => '', 'servicos' => '' ];
    if ( ! $blob ) return $r;

    $lines = array_filter( array_map( 'trim', explode( "\n", $blob ) ) );
    $lines = array_values( $lines );
    $n = count( $lines );
    $in_servicos = false;
    $servicos_arr = [];
    $capture_local_next  = false; // próxima linha será o local
    $capture_end_next    = false; // próxima linha será o endereço

    foreach ( $lines as $i => $l ) {
        // Captura de linha seguinte para local/endereço com label vazio
        if ( $capture_local_next ) { $r['local'] = $l; $capture_local_next = false; continue; }
        if ( $capture_end_next  ) { $r['endereco'] = $l; $capture_end_next  = false; continue; }

        if ( preg_match( '/servi[cç]os vivamais/i', $l ) ) { $in_servicos = true; continue; }
        if ( $in_servicos ) { $servicos_arr[] = $l; continue; }
        if ( preg_match( '/^(✅\s*)?(data do evento|data:|date)/i', $l ) ) continue;
        if ( preg_match( '/^tipo\s*(do\s*)?evento\s*:/i', $l ) ) {
            $r['tipo'] = trim( preg_replace( '/^tipo\s*(do\s*)?evento\s*:\s*/i', '', $l ) ); continue;
        }
        if ( preg_match( '/^homenageado/i', $l ) ) {
            $r['homenageado'] = trim( preg_replace( '/^homenageado[^:]*:\s*/i', '', $l ) ); continue;
        }
        if ( preg_match( '/^local\s*(do\s*evento)?\s*:/i', $l ) ) {
            $val = trim( preg_replace( '/^local\s*(do\s*evento)?\s*:\s*/i', '', $l ) );
            if ( $val ) { $r['local'] = $val; } else { $capture_local_next = true; }
            continue;
        }
        if ( preg_match( '/^endere[cç]o\s*(do\s*evento)?\s*:/i', $l ) ) {
            $val = trim( preg_replace( '/^endere[cç]o\s*(do\s*evento)?\s*:\s*/i', '', $l ) );
            if ( $val ) { $r['endereco'] = $val; } else { $capture_end_next = true; }
            continue;
        }
        if ( preg_match( '/^assessor\s*:/i', $l ) ) {
            $r['assessor'] = trim( preg_replace( '/^assessor\s*:\s*/i', '', $l ) ); continue;
        }
        if ( preg_match( '/^(horário|horario)\s*:/i', $l ) || preg_match( '/^das\s+\d{1,2}:\d{2}/i', $l ) ) {
            $r['horario'] = trim( preg_replace( '/^(horário|horario|das)\s*:?\s*/i', '', $l ) ); continue;
        }
        // Tipo implícito na primeira linha relevante
        if ( ! $r['tipo'] && preg_match( '/^(casamento|aniversári[oa]|formatura|festa\s+de|bodas|debutante|xv\s+anos|\d{1,2}\s+anos|renova[cç][aã]o|wedding|batizado|ch[aá]\s+de)/iu', $l ) ) {
            $r['tipo'] = $l;
            if ( ! $r['homenageado'] && isset( $lines[ $i + 1 ] ) ) {
                $nxt = $lines[ $i + 1 ];
                if ( ! preg_match( '/^(local|data|assessor|endere|✅|servi|horário|das\s+\d)/i', $nxt ) ) {
                    $r['homenageado'] = $nxt;
                }
            }
            continue;
        }
        // Endereço implícito — Rua, Av (com ou sem ponto), Avenida, Rodovia, etc.
        if ( ! $r['endereco'] && preg_match( '/^(rua|av[.\s]|avenida|rod[.\s]|rodovia|r\.\s|alameda|travessa|praça)/iu', $l ) ) {
            $r['endereco'] = $l; continue;
        }
    }
    $r['servicos'] = implode( "\n", $servicos_arr );
    return $r;
}

function vm2_agenda_page() {
    if ( ! current_user_can( 'manage_options' ) ) {
        wp_die( 'Sem permissão' );
    }

    // ── Handle Alertas Save ───────────────────────────────────
    if ( isset($_POST['vm2_save_agenda_alerts']) && check_admin_referer('vm2_agenda_alerts_save') ) {
        update_option('vm2_agenda_alerts_global_enabled', !empty($_POST['vm2_agenda_alerts_global_enabled']) ? 1 : 0);
        $raw_rules = ( isset($_POST['agenda_alerts']) && is_array($_POST['agenda_alerts']) ) ? $_POST['agenda_alerts'] : [];
        $rules = [];
        foreach ( $raw_rules as $r ) {
            $days = intval($r['days_before'] ?? 0);
            if ( $days <= 0 ) continue;
            $rules[] = [
                'id'          => preg_replace('/[^a-z0-9_]/', '', $r['id'] ?? '') ?: ( 'ar_' . uniqid() ),
                'name'        => sanitize_text_field($r['name'] ?? ''),
                'enabled'     => !empty($r['enabled']) ? 1 : 0,
                'days_before' => $days,
                'channel'     => sanitize_key($r['channel'] ?? 'zapi_7551'),
                'group_id'    => sanitize_text_field($r['group_id'] ?? ''),
                'message'     => sanitize_textarea_field($r['message'] ?? ''),
            ];
        }
        update_option('vm2_agenda_alerts', $rules);
        if ( ! empty($_POST['vm2_clear_alert_log']) ) {
            update_option('vm2_agenda_alerts_log', []);
        }
        echo '<div class="notice notice-success is-dismissible"><p>✅ Alertas de agenda salvos com sucesso!</p></div>';
    }

    $view   = sanitize_key( $_GET['view']   ?? 'list' );
    $month  = max( 1, min( 12, intval( $_GET['month'] ?? date('n') ) ) );
    $year   = max( 2020, min( 2030, intval( $_GET['year'] ?? date('Y') ) ) );
    $filter = sanitize_key( $_GET['filter'] ?? 'upcoming' );
    if ( $filter === 'week' ) $filter = 'week';

    // Prev/Next month
    $prev_m = $month - 1; $prev_y = $year;
    if ( $prev_m < 1 )  { $prev_m = 12; $prev_y--; }
    $next_m = $month + 1; $next_y = $year;
    if ( $next_m > 12 ) { $next_m = 1;  $next_y++; }

    $base   = admin_url( 'admin.php' );
    $prev_url = add_query_arg( [ 'page' => 'vm2-agenda', 'view' => 'calendar', 'month' => $prev_m, 'year' => $prev_y ], $base );
    $next_url = add_query_arg( [ 'page' => 'vm2-agenda', 'view' => 'calendar', 'month' => $next_m, 'year' => $next_y ], $base );
    $list_url    = add_query_arg( [ 'page' => 'vm2-agenda', 'view' => 'list' ], $base );
    $cal_url     = add_query_arg( [ 'page' => 'vm2-agenda', 'view' => 'calendar', 'month' => $month, 'year' => $year ], $base );
    $alerts_url  = add_query_arg( [ 'page' => 'vm2-agenda', 'view' => 'alertas' ], $base );

    // ── Fonte de dados: GSheets (primário) ou WooCommerce (fallback) ─────
    $today_ts = strtotime( current_time( 'Y-m-d' ) ); // usa timezone SP (America/Sao_Paulo via WP)
    $events   = [];
    $data_source = 'wc';

    $gs_events = get_option('vm2_agenda_gsheets', []);
    if ( !is_array($gs_events) ) $gs_events = json_decode($gs_events, true) ?: [];

    // IDs de datas GSheets já presentes (para deduplicar com WC)
    $gs_dates_used = [];
    $gs_ev_by_date = []; // date -> [event array indices]

    if ( !empty($gs_events) ) {
        $data_source = 'gsheets';
        foreach ( $gs_events as $row ) {
            if ( empty($row['data_festa']) ) continue;
            $parts = explode('/', $row['data_festa']);
            if ( count($parts) !== 3 ) continue;
            $ts = mktime(0, 0, 0, (int)$parts[1], (int)$parts[0], (int)$parts[2]);
            if ( !$ts ) continue;

            $days_until = intval(($ts - $today_ts) / 86400);
            if ( $days_until < 0 )       $color = '#6e7781';
            elseif ( $days_until <= 7 )  $color = '#d1242f';
            elseif ( $days_until <= 30 ) $color = '#e16f24';
            elseif ( $days_until <= 90 ) $color = '#9a6700';
            else                         $color = '#1a7f37';

            $phone_raw = preg_replace('/\D/', '', $row['whatsapp'] ?? '');
            if ( strlen($phone_raw) === 10 || strlen($phone_raw) === 11 ) $phone_raw = '55' . $phone_raw;

            // Campos parseados — vêm do sync pré-parseado ou do blob inline
            $ev_blob       = trim($row['evento_blob'] ?? '');
            $ev_prestador  = trim($row['prestador']   ?? '');
            $ev_custo      = trim($row['custo']       ?? '');
            // Se o sync já trouxe os campos parseados, usa; senão parseia o blob agora
            $ev_tipo       = trim($row['tipo']        ?? '');
            $ev_homenageado= trim($row['homenageado'] ?? '');
            $ev_local      = trim($row['local']       ?? '');
            $ev_endereco   = trim($row['endereco']    ?? '');
            $ev_assessor   = trim($row['assessor']    ?? '');
            $ev_horario    = trim($row['horario']     ?? '');
            $ev_servicos   = trim($row['servicos']    ?? '');
            // Sempre preenche campos ausentes a partir do blob (não só quando todos vazios)
            if ( $ev_blob ) {
                $parsed = vm2_parse_agenda_blob( $ev_blob );
                if ( ! $ev_tipo        ) $ev_tipo        = $parsed['tipo'];
                if ( ! $ev_homenageado ) $ev_homenageado = $parsed['homenageado'];
                if ( ! $ev_local       ) $ev_local       = $parsed['local'];
                if ( ! $ev_endereco    ) $ev_endereco    = $parsed['endereco'];
                if ( ! $ev_assessor    ) $ev_assessor    = $parsed['assessor'];
                if ( ! $ev_horario     ) $ev_horario     = $parsed['horario'];
                if ( ! $ev_servicos    ) $ev_servicos    = $parsed['servicos'];
            }
            // Título para exibição no card: tipo + homenageado
            $ev_titulo = $ev_tipo ?: ( $ev_homenageado ?: 'Evento' );

            $events[] = [
                'id'          => 'gs_' . ($row['row'] ?? uniqid()),
                'ts'          => $ts,
                'date_fmt'    => $row['data_festa'],
                'day'         => intval(date('j', $ts)),
                'month'       => intval(date('n', $ts)),
                'year'        => intval(date('Y', $ts)),
                'titulo'      => $ev_titulo,
                'tipo'        => $ev_tipo,
                'homenageado' => $ev_homenageado,
                'local'       => $ev_local,
                'endereco'    => $ev_endereco,
                'assessor'    => $ev_assessor,
                'horario'     => $ev_horario,
                'servicos'    => $ev_servicos,
                'evento_blob' => $ev_blob,
                'prestador'   => $ev_prestador,
                'phone'       => $phone_raw,
                'wa_link'     => $phone_raw ? 'https://wa.me/' . $phone_raw : '#',
                'custo'       => $ev_custo,
                'days_until'  => $days_until,
                'color'       => $color,
                'customer'    => '',
                'source'      => 'gsheets',
                'wc_order_id' => null, // filled later if matching WC order found
                // Texto de busca unificado
                'search_text' => mb_strtolower( implode( ' ', [ $ev_tipo, $ev_homenageado, $ev_local, $ev_assessor, $ev_prestador, $ev_servicos, $ev_blob ] ) ),
            ];
            // Registra data para deduplicar com WC
            $gs_dates_used[ date('Y-m-d', $ts) ] = true;
            $gs_ev_by_date[ date('Y-m-d', $ts) ][] = count($events) - 1; // track GSheets event index by date
        }
    }

    // Complementa com WooCommerce — eventos PASSADOS (realizados) que não estão no GSheets
    // (sempre ativo, não é fallback)
    $orders = function_exists('wc_get_orders') ? wc_get_orders([
            'status'  => vm2_order_statuses(),
            'limit'   => 1000,
            'type'    => 'shop_order',
            'orderby' => 'date',
            'order'   => 'DESC',
        ]) : [];
        foreach ( $orders as $order ) {
            $raw = $order->get_meta('_billing_event_date');
            if (!$raw) continue;
            $ts = vm2_event_date_to_ts($raw);
            if (!$ts) continue;
            // Deduplicar: se data já está no GSheets, pula (evita duplicatas de futuros)
            $wc_ev_date = date('Y-m-d', $ts);
            if ( isset($gs_dates_used[$wc_ev_date]) ) {
                // Injeta wc_order_id nos eventos GSheets desta data
                foreach ( ($gs_ev_by_date[$wc_ev_date] ?? []) as $gi ) {
                    if ( isset($events[$gi]) && empty($events[$gi]['wc_order_id']) ) {
                        $events[$gi]['wc_order_id'] = $order->get_id();
                    }
                }
                continue;
            }
            $items = [];
            foreach ($order->get_items() as $item) $items[] = $item->get_name();
            $days_until = intval(($ts - $today_ts) / 86400);
            if ($days_until < 0)       $color = '#6e7781';
            elseif ($days_until <= 7)  $color = '#d1242f';
            elseif ($days_until <= 30) $color = '#e16f24';
            elseif ($days_until <= 90) $color = '#9a6700';
            else                       $color = '#1a7f37';
            $phone_raw = preg_replace('/\D/', '', $order->get_billing_phone());
            if (strlen($phone_raw) <= 11) $phone_raw = '55' . $phone_raw;
            $events[] = [
                'id'          => $order->get_id(),
                'ts'          => $ts,
                'date_fmt'    => vm2_format_event_date($raw),
                'day'         => intval(date('j', $ts)),
                'month'       => intval(date('n', $ts)),
                'year'        => intval(date('Y', $ts)),
                'customer'    => trim($order->get_billing_first_name() . ' ' . $order->get_billing_last_name()),
                'phone'       => $phone_raw,
                'tipo'        => $order->get_meta('_billing_tipo_evento') ?: '—',
                'homenageado' => $order->get_meta('_billing_homenageado') ?: '',
                'assessor'    => $order->get_meta('_billing_assessor') ?: '—',
                'atracoes'    => implode(', ', $items) ?: '—',
                'prestador'   => '—',
                'cidade'      => $order->get_shipping_city() ?: $order->get_billing_city() ?: '—',
                'estado'      => $order->get_shipping_state() ?: $order->get_billing_state() ?: '—',
                'endereco'    => trim($order->get_shipping_address_1() . ($order->get_shipping_address_2() ? ', ' . $order->get_shipping_address_2() : '')) ?: '—',
                'bairro'      => $order->get_meta('_shipping_neighborhood') ?: '',
                'obs'         => $order->get_customer_note() ?: '—',
                'total'       => number_format($order->get_total(), 2, ',', '.'),
                'status'      => $order->get_status(),
                'days_until'  => $days_until,
                'color'       => $color,
                'link'        => admin_url('post.php?post=' . $order->get_id() . '&action=edit'),
                'wa_link'     => 'https://wa.me/' . $phone_raw,
                'source'      => 'wc',
                'wc_order_id' => $order->get_id(),
                'custo'       => '—', 'entrada' => '—', 'entrada_paga' => '—',
                'final_valor' => '—', 'final_paga' => '—', 'bruto_vivamais' => '—',
            ];
        }

    // ── Enriquecer eventos GSheets com wc_order_id (match por data) ─────────
    if ( function_exists( 'wc_get_orders' ) ) {
        $wc_orders_admin = wc_get_orders( [
            'limit'  => 500,
            'status' => [ 'wc-processing', 'wc-signing-pending', 'wc-contract-signed', 'wc-completed' ],
            'return' => 'objects',
        ] );
        $wc_date_map_admin = [];
        foreach ( $wc_orders_admin as $ord ) {
            $ev_date = $ord->get_meta( '_billing_event_date' );
            if ( empty( $ev_date ) ) {
                // fallback: yith booking meta
                $yb = $ord->get_meta( 'yith_booking_data' );
                if ( ! empty( $yb['_from_timestamp'] ) ) {
                    $ev_date = date( 'Y-m-d', $yb['_from_timestamp'] );
                }
            }
            if ( ! empty( $ev_date ) ) {
                // normalize to Y-m-d
                $ts_ord = strtotime( $ev_date );
                if ( $ts_ord ) {
                    $iso = date( 'Y-m-d', $ts_ord );
                    if ( ! isset( $wc_date_map_admin[ $iso ] ) ) {
                        $wc_date_map_admin[ $iso ] = $ord->get_id();
                    }
                }
            }
        }
        foreach ( $events as &$ev ) {
            if ( ! empty( $ev['wc_order_id'] ) ) continue;
            if ( ! empty( $ev['date_iso'] ) && isset( $wc_date_map_admin[ $ev['date_iso'] ] ) ) {
                $ev['wc_order_id'] = $wc_date_map_admin[ $ev['date_iso'] ];
            }
        }
        unset( $ev );
    }

    usort( $events, fn( $a, $b ) => $a['ts'] - $b['ts'] );

    if ( $filter === 'week' ) {
        $week_end_ts = strtotime('+6 days', $today_ts);
        $list_events = array_values( array_filter( $events, fn($e) => $e['ts'] >= $today_ts && $e['ts'] <= $week_end_ts ) );
    } elseif ( $filter === 'upcoming' ) {
        $list_events = array_values( array_filter( $events, fn( $e ) => $e['ts'] >= $today_ts ) );
    } elseif ( $filter === 'last7' ) {
        // Lê da aba VENDAS (sem filtro), sincronizado via sync-last7
        $l7_raw = (array) get_option( 'vm2_agenda_last7', [] );
        $list_events = [];
        foreach ( $l7_raw as $row ) {
            if ( empty( $row['data_festa'] ) ) continue;
            $lparts = explode( '/', $row['data_festa'] );
            if ( count( $lparts ) !== 3 ) continue;
            $lts = mktime( 0, 0, 0, (int) $lparts[1], (int) $lparts[0], (int) $lparts[2] );
            if ( ! $lts ) continue;
            $l_days  = intval( ( $lts - $today_ts ) / 86400 );
            $l_phone = preg_replace( '/\D/', '', $row['whatsapp'] ?? '' );
            if ( strlen( $l_phone ) === 10 || strlen( $l_phone ) === 11 ) $l_phone = '55' . $l_phone;
            $l_blob  = trim( $row['evento_blob'] ?? '' );
            $l_tipo  = trim( $row['tipo']        ?? '' );
            $l_homn  = trim( $row['homenageado'] ?? '' );
            $l_locl  = trim( $row['local']       ?? '' );
            $l_addr  = trim( $row['endereco']    ?? '' );
            $l_ases  = trim( $row['assessor']    ?? '' );
            $l_hora  = trim( $row['horario']     ?? '' );
            $l_serv  = trim( $row['servicos']    ?? '' );
            $l_pres  = trim( $row['prestador']   ?? '' );
            $l_cust  = trim( $row['custo']       ?? '' );
            if ( $l_blob ) {
                $lp = vm2_parse_agenda_blob( $l_blob );
                if ( ! $l_tipo ) $l_tipo = $lp['tipo'];
                if ( ! $l_homn ) $l_homn = $lp['homenageado'];
                if ( ! $l_locl ) $l_locl = $lp['local'];
                if ( ! $l_addr ) $l_addr = $lp['endereco'];
                if ( ! $l_ases ) $l_ases = $lp['assessor'];
                if ( ! $l_hora ) $l_hora = $lp['horario'];
                if ( ! $l_serv ) $l_serv = $lp['servicos'];
            }
            $l_titulo = $l_tipo ?: ( $l_homn ?: 'Evento' );
            $list_events[] = [
                'id'          => 'l7_' . ( $row['row'] ?? uniqid() ),
                'ts'          => $lts,
                'date_fmt'    => $row['data_festa'],
                'day'         => intval( date( 'j', $lts ) ),
                'month'       => intval( date( 'n', $lts ) ),
                'year'        => intval( date( 'Y', $lts ) ),
                'titulo'      => $l_titulo,
                'tipo'        => $l_tipo,
                'homenageado' => $l_homn,
                'local'       => $l_locl,
                'endereco'    => $l_addr,
                'assessor'    => $l_ases,
                'horario'     => $l_hora,
                'servicos'    => $l_serv,
                'evento_blob' => $l_blob,
                'prestador'   => $l_pres,
                'phone'       => $l_phone,
                'wa_link'     => $l_phone ? 'https://wa.me/' . $l_phone : '#',
                'custo'       => $l_cust,
                'days_until'  => $l_days,
                'color'       => '#6e7781',
                'customer'    => '',
                'source'      => 'gsheets',
                'wc_order_id' => null,
                'atracoes'    => $l_serv ?: $l_titulo,
                'search_text' => mb_strtolower( implode( ' ', [ $l_tipo, $l_homn, $l_locl, $l_ases, $l_pres, $l_serv, $l_blob ] ) ),
            ];
        }
        $list_events = array_values( array_reverse( $list_events ) ); // mais recente primeiro
    } elseif ( $filter === 'past' ) {
        $list_events = array_values( array_reverse( array_filter( $events, fn( $e ) => $e['ts'] < $today_ts ) ) );
    } else {
        $list_events = array_values( $events );
    }

    // Calendar map
    $cal_map = [];
    foreach ( $events as $e ) {
        if ( $e['month'] === $month && $e['year'] === $year ) {
            $cal_map[ $e['day'] ][] = $e;
        }
    }

    // Stats
    $total_events = count( $events );
    $upcoming_cnt = count( array_filter( $events, fn( $e ) => $e['ts'] >= $today_ts ) );
    $this_week    = count( array_filter( $events, fn( $e ) => $e['days_until'] >= 0 && $e['days_until'] <= 6 ) );
    $past_cnt     = $total_events - $upcoming_cnt;
    // Semana Anterior: vem da aba VENDAS (sem filtro), sincronizado via sync-last7
    $last7_cnt = count( (array) get_option( 'vm2_agenda_last7', [] ) );

    // ── Busca inteligente: valores únicos para dropdowns ──
    $all_atracoes_set = [];
    $all_tipos_set    = [];
    foreach ( $events as $e ) {
        foreach ( explode( ', ', $e['atracoes'] ) as $at ) {
            $at = trim( $at );
            if ( $at && $at !== '—' ) $all_atracoes_set[ $at ] = true;
        }
        if ( $e['tipo'] && $e['tipo'] !== '—' ) $all_tipos_set[ $e['tipo'] ] = true;
    }
    ksort( $all_atracoes_set );
    ksort( $all_tipos_set );

    $last_sync_ag       = get_option('vm2_agenda_last_sync', '');
    $sync_nonce_ag      = wp_create_nonce('vm2_agenda_sync');
    $ag_webhook_set     = !empty(get_option('vm2_agenda_webhook_url', ''));
    $ag_sync_status_url = rest_url('vm-crm-v2/v1/agenda/sync-status');

    $month_names = [ '', 'Janeiro', 'Fevereiro', 'Março', 'Abril', 'Maio', 'Junho', 'Julho', 'Agosto', 'Setembro', 'Outubro', 'Novembro', 'Dezembro' ];
    $month_abbr  = [ '', 'JAN', 'FEV', 'MAR', 'ABR', 'MAI', 'JUN', 'JUL', 'AGO', 'SET', 'OUT', 'NOV', 'DEZ' ];

    ?>
    <div class="wrap vm2-agenda-wrap">
    <style>
    .vm2-agenda-wrap{max-width:1200px}
    .vm2-agenda-header{display:flex;align-items:center;justify-content:space-between;margin-bottom:16px;flex-wrap:wrap;gap:8px}
    .vm2-view-toggle{display:flex;gap:4px;background:#f6f8fa;border-radius:8px;padding:3px}
    .vm2-view-btn{padding:6px 14px;border-radius:6px;text-decoration:none;color:#57606a;font-size:13px;font-weight:500}
    .vm2-view-btn.active{background:#fff;color:#1d2327;box-shadow:0 1px 3px rgba(0,0,0,.15)}
    .vm2-ag-kpi{display:grid;grid-template-columns:repeat(4,1fr);gap:12px;margin-bottom:20px}
    @media(max-width:700px){.vm2-ag-kpi{grid-template-columns:repeat(2,1fr)}}
    .vm2-ag-kpi-card{background:#fff;border:1px solid #e0e0e0;border-radius:8px;padding:14px 16px;cursor:pointer;transition:all .15s ease}
    .vm2-ag-kpi-card:hover{transform:translateY(-2px);box-shadow:0 4px 14px rgba(0,0,0,.12);border-color:#0073aa}
    .vm2-ag-kpi-val{font-size:26px;font-weight:700;color:#1d2327}
    .vm2-ag-kpi-lbl{font-size:12px;color:#57606a;margin-top:2px}
    .vm2-cal{background:#fff;border:1px solid #e0e0e0;border-radius:10px;overflow:hidden}
    .vm2-cal-nav{display:flex;align-items:center;justify-content:space-between;padding:14px 20px;border-bottom:1px solid #e0e0e0}
    .vm2-cal-nav h3{margin:0;font-size:16px;font-weight:700}
    .vm2-cal-nav a{text-decoration:none;color:#1d2327;padding:4px 10px;border:1px solid #e0e0e0;border-radius:6px;font-size:13px}
    .vm2-cal-nav a:hover{background:#f6f8fa}
    .vm2-cal-grid{display:grid;grid-template-columns:repeat(7,1fr)}
    .vm2-cal-dow{text-align:center;padding:8px 0;font-size:11px;font-weight:600;color:#57606a;text-transform:uppercase;border-bottom:1px solid #e0e0e0;background:#f9f9f9}
    .vm2-cal-cell{min-height:72px;border-right:1px solid #f0f0f0;border-bottom:1px solid #f0f0f0;padding:5px;cursor:pointer;transition:background .15s}
    .vm2-cal-cell:hover{background:#f6f8fa}
    .vm2-cal-cell:nth-child(7n){border-right:none}
    .vm2-cal-cell.empty{background:#fafafa;cursor:default}
    /* ── Botão Contrato ── */
    .vm2-ev-contrato-btn{background:#f3f0ff;border:1px solid #a78bfa;color:#6d28d9;border-radius:6px;padding:5px 10px;font-size:12px;font-weight:600;cursor:pointer;white-space:nowrap;flex-shrink:0;transition:background .15s}
    .vm2-ev-contrato-btn:hover{background:#ede9fe}
    /* ── Drawer Contrato ── */
    .vm2-ct-overlay{position:fixed;inset:0;z-index:100001;display:flex;align-items:flex-end;justify-content:center;background:rgba(0,0,0,.45);opacity:0;pointer-events:none;transition:opacity .2s}
    .vm2-ct-overlay.open{opacity:1;pointer-events:all}
    .vm2-ct-panel{background:#fff;border-radius:16px 16px 0 0;width:100%;max-width:560px;max-height:88vh;overflow-y:auto;padding:20px 20px 32px;transform:translateY(40px);transition:transform .25s;box-shadow:0 -4px 30px rgba(0,0,0,.18)}
    .vm2-ct-overlay.open .vm2-ct-panel{transform:translateY(0)}
    .vm2-ct-header{display:flex;align-items:center;justify-content:space-between;margin-bottom:16px}
    .vm2-ct-title{font-size:16px;font-weight:700;color:#1d2327}
    .vm2-ct-close{background:none;border:none;font-size:22px;cursor:pointer;color:#57606a;line-height:1;padding:2px 6px}
    .vm2-ct-section{font-size:11px;font-weight:700;text-transform:uppercase;letter-spacing:.6px;color:#7c3aed;margin:12px 0 6px;padding-left:2px}
    .vm2-ct-row{display:flex;gap:8px;padding:5px 0;border-bottom:1px solid #f3f4f6;font-size:13px}
    .vm2-ct-lbl{min-width:120px;color:#57606a;flex-shrink:0;font-size:12px}
    .vm2-ct-val{color:#1d2327;font-weight:500;word-break:break-word}
    .vm2-ct-sep{border:none;border-top:2px solid #f3f4f6;margin:14px 0 6px}
    .vm2-drag-ct{width:40px;height:4px;background:#e0e0e0;border-radius:2px;margin:0 auto 14px}
    .vm2-cal-cell.today .vm2-cal-day{background:#0969da;color:#fff;border-radius:50%;width:22px;height:22px;display:flex;align-items:center;justify-content:center;font-size:12px}
    .vm2-cal-day{font-size:12px;font-weight:600;color:#1d2327;width:22px;height:22px;display:flex;align-items:center;justify-content:center}
    .vm2-cal-dot{width:7px;height:7px;border-radius:50%;display:inline-block;margin:1px}
    .vm2-cal-dots{display:flex;flex-wrap:wrap;margin-top:3px}
    .vm2-cal-more{font-size:10px;color:#57606a;margin-top:2px}
    .vm2-filter-bar{display:flex;gap:8px;margin-bottom:16px;flex-wrap:wrap;align-items:center}
    .vm2-filter-btn{padding:5px 12px;border:1px solid #e0e0e0;border-radius:20px;text-decoration:none;color:#57606a;font-size:12px;font-weight:500}
    .vm2-filter-btn.active{background:#1d2327;color:#fff;border-color:#1d2327}
    .vm2-event-list{display:flex;flex-direction:column;gap:8px}
    .vm2-ev-card{background:#fff;border:1px solid #e0e0e0;border-left:4px solid;border-radius:8px;padding:12px 16px;display:flex;align-items:center;gap:14px;cursor:pointer;transition:box-shadow .15s;flex-wrap:wrap}
    .vm2-ev-card:hover{box-shadow:0 2px 8px rgba(0,0,0,.1)}
    .vm2-ev-datebox{min-width:48px;text-align:center}
    .vm2-ev-day{font-size:22px;font-weight:700;color:#1d2327;line-height:1}
    .vm2-ev-mon{font-size:10px;color:#57606a;text-transform:uppercase}
    .vm2-ev-info{flex:1;min-width:150px}
    .vm2-ev-name{font-weight:600;font-size:14px;color:#1d2327}
    .vm2-ev-meta{font-size:12px;color:#57606a;margin-top:2px}
    .vm2-ev-badge{font-size:11px;padding:2px 8px;border-radius:20px;font-weight:500;white-space:nowrap}
    .vm2-ev-acts a{font-size:18px;text-decoration:none;margin-left:4px}
    .vm2-ev-cliente-row{display:flex;align-items:center;gap:8px;flex-wrap:wrap;margin-top:6px;padding-top:6px;border-top:1px solid #f0f0f0;width:100%;box-sizing:border-box}
    .vm2-ev-cliente-nome{font-size:12px;color:#444;font-weight:500;flex:1;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
    .vm2-ev-wa-btn{display:inline-flex;align-items:center;gap:4px;background:#25d366;color:#fff!important;font-size:11px;font-weight:700;padding:5px 12px;border-radius:20px;text-decoration:none!important;white-space:nowrap}
    .vm2-ev-wa-btn:hover{background:#128c7e}
    .vm2-time-tag{background:#e8f4fd;color:#1a6fa8;font-size:11px;font-weight:700;padding:2px 8px;border-radius:10px;border:1px solid #b8d9f0;display:inline-block}
    .vm2-modal-cliente{background:linear-gradient(135deg,#f0f9ff,#e8f4fd);border:1px solid #bfdbfe;border-radius:10px;padding:14px 16px;margin-bottom:12px;display:flex;flex-direction:column;gap:10px}
    .vm2-modal-cliente-nome{font-size:16px;font-weight:700;color:#1d2327}
    .vm2-modal-overlay{display:none;position:fixed;inset:0;background:rgba(0,0,0,.4);z-index:99999}
    .vm2-modal-overlay.open{display:flex;align-items:flex-start;justify-content:flex-end}
    .vm2-modal-panel{background:#fff;width:min(480px,95vw);height:100vh;overflow-y:auto;padding:24px;animation:vm2SlideIn .2s ease;box-sizing:border-box}
    @keyframes vm2SlideIn{from{transform:translateX(100%)}to{transform:translateX(0)}}
    .vm2-modal-close{float:right;background:none;border:none;font-size:20px;cursor:pointer;color:#57606a;padding:0}
    .vm2-modal-title{font-size:16px;font-weight:700;margin:0 0 16px;padding-right:30px}
    .vm2-modal-row{display:flex;gap:8px;margin-bottom:8px;align-items:flex-start}
    .vm2-modal-lbl{font-size:12px;color:#57606a;min-width:110px;font-weight:600;padding-top:1px}
    .vm2-modal-val{font-size:13px;color:#1d2327;flex:1}
    .vm2-modal-hr{border:none;border-top:1px solid #e0e0e0;margin:14px 0}
    .vm2-modal-acts{display:flex;gap:8px;flex-wrap:wrap}
    .vm2-mbtn{padding:8px 14px;border-radius:6px;text-decoration:none;font-size:13px;font-weight:500;border:1px solid #e0e0e0;color:#1d2327}
    .vm2-mbtn.blue{background:#0969da;color:#fff;border-color:#0969da}
    .vm2-mbtn.green{background:#1a7f37;color:#fff;border-color:#1a7f37}
    .vm2-drag-handle{display:none;width:36px;height:4px;background:#ddd;border-radius:2px;margin:0 auto 14px}
    .vm2-modal-val{word-break:break-word}
    .vm2-blob-row{margin-bottom:4px}
    .vm2-blob-lbl{font-size:10px;color:#57606a;font-weight:700;text-transform:uppercase;letter-spacing:.3px;display:block}
    .vm2-blob-val{font-size:13px;color:#1d2327}
    @keyframes vm2SlideUp{from{transform:translateY(100%)}to{transform:translateY(0)}}
    @media(max-width:640px){
        .vm2-drag-handle{display:block}
        .vm2-modal-overlay.open{align-items:flex-end;justify-content:center}
        .vm2-modal-panel{width:100vw!important;max-width:100vw!important;height:90svh;border-radius:16px 16px 0 0;padding:16px 14px 28px!important;animation:vm2SlideUp .25s ease}
        .vm2-modal-title{font-size:15px;margin-bottom:10px}
        .vm2-modal-row{flex-direction:column;gap:1px;margin-bottom:10px;border-bottom:1px solid #f0f0f0;padding-bottom:8px}
        .vm2-modal-lbl{min-width:unset!important;font-size:10px;text-transform:uppercase;letter-spacing:.3px;color:#8b949e}
        .vm2-ev-info{overflow:hidden;min-width:0;flex:1}
        .vm2-ev-name{white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
        .vm2-ev-meta .vm2-meta-line{display:block}
        .vm2-ev-acts{width:100%;margin-top:6px}
        .vm2-ag-kpi{grid-template-columns:repeat(2,1fr)!important}
        .vm2-filter-bar{gap:4px}
        .vm2-filter-btn{font-size:11px;padding:4px 10px}
    }
    .vm2-search-bar{display:flex;gap:8px;margin-bottom:12px;flex-wrap:wrap;align-items:center}
    .vm2-search-bar input[type=text]{flex:1;min-width:200px;padding:7px 14px;border:1px solid #e0e0e0;border-radius:20px;font-size:13px;outline:none;background:#fff}
    .vm2-search-bar input[type=text]:focus{border-color:#0073aa;box-shadow:0 0 0 2px rgba(0,115,170,.2)}
    .vm2-search-bar select{padding:6px 10px;border:1px solid #e0e0e0;border-radius:20px;font-size:12px;color:#57606a;background:#fff;cursor:pointer;max-width:200px}
    .vm2-search-bar .vm2-clr-btn{padding:5px 12px;border:1px solid #e0e0e0;border-radius:20px;background:#fff;color:#57606a;font-size:12px;cursor:pointer;white-space:nowrap}
    .vm2-search-bar .vm2-clr-btn:hover{background:#f6f8fa}
    #vm2AgCount{font-size:12px;color:#57606a;margin-left:auto;white-space:nowrap}
    </style>

    <div class="vm2-agenda-header">
        <h1 style="margin:0">📅 Agenda de Eventos</h1>
        <div style="display:flex;align-items:center;gap:10px;flex-wrap:wrap">
            <?php if ($ag_webhook_set): ?>
            <button id="vm2AgSyncBtn" onclick="vm2AgSync()" class="button button-secondary" style="font-size:13px">🔄 Sincronizar Planilha</button>
            <?php else: ?>
            <a href="<?php echo esc_url(admin_url('admin.php?page=vm2-settings#agenda-webhook')); ?>" class="button" style="font-size:12px;color:#d1242f;border-color:#fca5a5">⚙️ Configurar Webhook</a>
            <?php endif; ?>
            <?php if ($last_sync_ag): ?>
            <span style="font-size:12px;color:#57606a">Sync: <?php echo esc_html(vm2_local_date('d/m H:i', $last_sync_ag)); ?></span>
            <?php endif; ?>
            <?php if ($data_source === 'gsheets'): ?>
            <span style="font-size:11px;color:#059669;background:#ecfdf5;padding:2px 8px;border-radius:12px">📊 GSheets</span>
            <?php else: ?>
            <span style="font-size:11px;color:#57606a;background:#f6f8fa;padding:2px 8px;border-radius:12px">WooCommerce</span>
            <?php endif; ?>
        </div>
        <div class="vm2-view-toggle">
            <a href="<?php echo esc_url( $list_url ); ?>"    class="vm2-view-btn <?php echo $view === 'list'     ? 'active' : ''; ?>">≡ Lista</a>
            <a href="<?php echo esc_url( $cal_url ); ?>"    class="vm2-view-btn <?php echo $view === 'calendar'  ? 'active' : ''; ?>">⊞ Calendário</a>
            <a href="<?php echo esc_url( $alerts_url ); ?>" class="vm2-view-btn <?php echo $view === 'alertas'   ? 'active' : ''; ?>">🔔 Alertas</a>
        </div>
    </div>

    <div class="vm2-ag-kpi">
        <div class="vm2-ag-kpi-card" onclick="location.href='?page=vm2-agenda&filter=all'"><div class="vm2-ag-kpi-val"><?php echo $total_events; ?></div><div class="vm2-ag-kpi-lbl">Total de Eventos</div></div>
        <div class="vm2-ag-kpi-card" onclick="location.href='?page=vm2-agenda&filter=upcoming'"><div class="vm2-ag-kpi-val" style="color:#1a7f37"><?php echo $upcoming_cnt; ?></div><div class="vm2-ag-kpi-lbl">Próximos Eventos</div></div>
        <div class="vm2-ag-kpi-card" onclick="location.href='?page=vm2-agenda&filter=week'"><div class="vm2-ag-kpi-val" style="color:#d1242f"><?php echo $this_week; ?></div><div class="vm2-ag-kpi-lbl">Esta Semana</div></div>
        <div class="vm2-ag-kpi-card" onclick="location.href='?page=vm2-agenda&filter=past'"><div class="vm2-ag-kpi-val" style="color:#57606a"><?php echo $past_cnt; ?></div><div class="vm2-ag-kpi-lbl">Realizados</div></div>
        <div class="vm2-ag-kpi-card" onclick="location.href='?page=vm2-agenda&view=list&filter=last7'"><div class="vm2-ag-kpi-val" style="color:#6f42c1"><?php echo $last7_cnt; ?></div><div class="vm2-ag-kpi-lbl">Semana Anterior</div></div>
    </div>

    <?php if ( $view === 'calendar' ): ?>
    <div class="vm2-cal">
        <div class="vm2-cal-nav">
            <a href="<?php echo esc_url( $prev_url ); ?>">← <?php echo esc_html( $month_names[ $prev_m ] ); ?></a>
            <h3><?php echo esc_html( $month_names[ $month ] . ' ' . $year ); ?></h3>
            <a href="<?php echo esc_url( $next_url ); ?>"><?php echo esc_html( $month_names[ $next_m ] ); ?> →</a>
        </div>
        <div class="vm2-cal-grid">
            <?php
            foreach ( [ 'Dom','Seg','Ter','Qua','Qui','Sex','Sáb' ] as $d ) {
                echo "<div class='vm2-cal-dow'>" . esc_html( $d ) . "</div>";
            }
            $first_dow     = intval( date( 'w', mktime( 0, 0, 0, $month, 1, $year ) ) );
            $days_in_month = intval( date( 't', mktime( 0, 0, 0, $month, 1, $year ) ) );
            $today_day     = ( intval( wp_date('n') ) === $month && intval( wp_date('Y') ) === $year ) ? intval( wp_date('j') ) : -1;

            for ( $i = 0; $i < $first_dow; $i++ ) {
                echo "<div class='vm2-cal-cell empty'></div>";
            }
            for ( $d = 1; $d <= $days_in_month; $d++ ) {
                $is_today   = ( $d === $today_day ) ? ' today' : '';
                $day_events = $cal_map[ $d ] ?? [];
                echo "<div class='vm2-cal-cell$is_today' onclick='vm2CalDay(this)'>";
                echo "<div class='vm2-cal-day'>$d</div>";
                echo "<div class='vm2-cal-dots'>";
                foreach ( array_slice( $day_events, 0, 5 ) as $ev ) {
                    $c = esc_attr( $ev['color'] );
                    echo "<span class='vm2-cal-dot' style='background:$c'></span>";
                }
                echo "</div>";
                $cnt = count( $day_events );
                if ( $cnt > 0 ) {
                    echo "<div class='vm2-cal-more'>{$cnt} evento" . ( $cnt > 1 ? 's' : '' ) . "</div>";
                }
                foreach ( $day_events as $ev ) {
                    $edata = esc_attr( json_encode( $ev, JSON_UNESCAPED_UNICODE ) );
                    echo "<span class='vm2agev' data-event='$edata' style='display:none'></span>";
                }
                echo "</div>";
            }
            ?>
        </div>
    </div>
    <div style="margin-top:12px;display:flex;gap:16px;flex-wrap:wrap;font-size:12px;color:#57606a">
        <span><span style="display:inline-block;width:10px;height:10px;border-radius:50%;background:#d1242f;margin-right:4px;vertical-align:middle"></span>Esta semana</span>
        <span><span style="display:inline-block;width:10px;height:10px;border-radius:50%;background:#e16f24;margin-right:4px;vertical-align:middle"></span>Próximo mês</span>
        <span><span style="display:inline-block;width:10px;height:10px;border-radius:50%;background:#9a6700;margin-right:4px;vertical-align:middle"></span>3 meses</span>
        <span><span style="display:inline-block;width:10px;height:10px;border-radius:50%;background:#1a7f37;margin-right:4px;vertical-align:middle"></span>Futuro</span>
        <span><span style="display:inline-block;width:10px;height:10px;border-radius:50%;background:#6e7781;margin-right:4px;vertical-align:middle"></span>Realizado</span>
    </div>

    <?php else: ?>
    <?php if ( $view !== 'calendar' ): ?>
    <div class="vm2-search-bar">
        <input type="text" id="vm2AgSearch" placeholder="🔍 Buscar tipo, homenageado, local, prestador, assessor..." oninput="vm2FilterAgenda()" style="flex:1;min-width:0">
        <button class="vm2-clr-btn" onclick="vm2ClearSearch()">✕</button>
        <span id="vm2AgCount"><?php echo count( $list_events ); ?> eventos</span>
    </div>
    <?php endif; ?>

    <div class="vm2-filter-bar">
        <?php
        $filters = [ 'upcoming' => '📅 Próximos', 'week' => '📆 Esta Semana', 'last7' => '⏮️ Sem. Anterior', 'past' => '✓ Realizados', 'all' => '⊞ Todos' ];
        foreach ( $filters as $fk => $fl ) {
            $fu  = add_query_arg( [ 'page' => 'vm2-agenda', 'view' => 'list', 'filter' => $fk ], $base );
            $cls = ( $filter === $fk ) ? 'active' : '';
            echo "<a href='" . esc_url( $fu ) . "' class='vm2-filter-btn $cls'>" . esc_html( $fl ) . "</a>";
        }
        echo "<span style='margin-left:auto;font-size:12px;color:#57606a'>" . count( $list_events ) . " eventos</span>";
        ?>
    </div>
    <div class="vm2-event-list">
    <?php
    $days_pt_ag = ['Sunday'=>'Domingo','Monday'=>'Segunda','Tuesday'=>'Terça','Wednesday'=>'Quarta','Thursday'=>'Quinta','Friday'=>'Sexta','Saturday'=>'Sábado'];
    foreach ( $list_events as $e ):
        $ev_day  = date( 'd', $e['ts'] );
        $ev_mon  = $month_abbr[ intval( date( 'n', $e['ts'] ) ) ];
        $ev_dow  = $days_pt_ag[ date( 'l', $e['ts'] ) ] ?? '';
        $du      = $e['days_until'];
        if ( $du < 0 )       $badge = 'Realizado';
        elseif ( $du === 0 ) $badge = 'HOJE 🔴';
        elseif ( $du === 1 ) $badge = 'Amanhã';
        elseif ( $du <= 30 ) $badge = $du . ' dias';
        elseif ( $du <= 90 ) $badge = ceil( $du / 7 ) . ' sem';
        else                 $badge = ceil( $du / 30 ) . ' meses';
        $edata = esc_attr( json_encode( $e, JSON_UNESCAPED_UNICODE ) );
    ?>
    <?php
    $vm2_search_txt = $e['search_text'] ?? mb_strtolower( $e['titulo'] . ' ' . $e['prestador'] );
    $vm2_tipo_card  = ($e['tipo'] && $e['tipo'] !== '—') ? $e['tipo'] : ($e['titulo'] ?? '');
    if ( mb_strlen($vm2_tipo_card) > 40 ) $vm2_tipo_card = mb_substr($vm2_tipo_card, 0, 40) . '…';
    $vm2_homen_card = $e['homenageado'] ?? '';
    if ( mb_strlen($vm2_homen_card) > 35 ) $vm2_homen_card = mb_substr($vm2_homen_card, 0, 35) . '…';
    // Usa local; se vazio, usa endereço como fallback
    $vm2_local_card = ($e['local'] ?? '') ?: ($e['endereco'] ?? '');
    if ( mb_strlen($vm2_local_card) > 40 ) $vm2_local_card = mb_substr($vm2_local_card, 0, 40) . '…';
    $vm2_assessor_card = ($e['assessor'] ?? '');
    if ( mb_strlen($vm2_assessor_card) > 30 ) $vm2_assessor_card = mb_substr($vm2_assessor_card, 0, 30) . '…';
    $vm2_horario_card  = trim($e['horario'] ?? '');
    $vm2_cliente_card  = trim($e['customer'] ?? '');
    ?>
    <div class="vm2-ev-card" style="border-left-color:<?php echo esc_attr($e['color']); ?>"
         data-search="<?php echo esc_attr( $vm2_search_txt ); ?>"
         data-ev='<?php echo $edata; ?>'
         onclick='vm2OpenModal(JSON.parse(this.dataset.ev))'>
        <div class="vm2-ev-datebox">
            <div class="vm2-ev-day"><?php echo $ev_day; ?></div>
            <div class="vm2-ev-mon"><?php echo $ev_mon; ?></div>
        </div>
        <div class="vm2-ev-info">
            <?php if ($vm2_tipo_card): ?>
            <div class="vm2-ev-name"><?php echo esc_html($vm2_tipo_card); ?></div>
            <?php endif; ?>
            <?php if ($vm2_homen_card): ?>
            <div class="vm2-ev-meta" style="font-size:13px;color:#444;font-weight:500"><?php echo esc_html($vm2_homen_card); ?></div>
            <?php endif; ?>
            <div class="vm2-ev-meta">🎤 <?php echo $e['prestador'] ? esc_html($e['prestador']) : '<span style="color:#bbb;font-style:italic">sem prestador</span>'; ?></div>
            <?php if ($vm2_assessor_card && $vm2_assessor_card !== $e['prestador']): ?>
            <div class="vm2-ev-meta" style="font-size:11px;color:#57606a">🧑‍💼 <?php echo esc_html($vm2_assessor_card); ?></div>
            <?php endif; ?>
            <?php if ($vm2_local_card): ?>
            <div class="vm2-ev-meta" style="font-size:11px;color:#8b949e">📍 <?php echo esc_html($vm2_local_card); ?></div>
            <?php endif; ?>
            <?php if ($vm2_horario_card && $vm2_horario_card !== '—'): ?>
            <div class="vm2-ev-meta" style="margin-top:3px"><span class="vm2-time-tag">⏰ <?php echo esc_html($vm2_horario_card); ?></span></div>
            <?php endif; ?>
            <?php
            $vm2_serv_card = trim($e['servicos'] ?? '');
            if ($vm2_serv_card && $vm2_serv_card !== '—'):
                // Mostrar apenas primeira linha de serviços para não encher o card
                $serv_lines = array_filter(array_map('trim', explode("\n", $vm2_serv_card)));
                $serv_preview = implode(' · ', array_slice($serv_lines, 0, 3));
                if (count($serv_lines) > 3) $serv_preview .= ' …';
            ?>
            <div class="vm2-ev-meta" style="font-size:11px;color:#6366f1;margin-top:2px">⭐ <?php echo esc_html($serv_preview); ?></div>
            <?php endif; ?>
        </div>
        <div style="display:flex;flex-direction:column;align-items:flex-end;gap:4px">
            <?php if ($ev_dow): ?>
            <span style="font-size:10px;color:#57606a;font-weight:600;text-transform:uppercase;letter-spacing:.4px"><?php echo esc_html($ev_dow); ?></span>
            <?php endif; ?>
            <span class="vm2-ev-badge" style="background:<?php echo esc_attr($e['color']); ?>22;color:<?php echo esc_attr($e['color']); ?>"><?php echo esc_html($badge); ?></span>
            <?php if ($e['custo']): ?>
            <span style="font-size:11px;color:#57606a"><?php echo esc_html($e['custo']); ?></span>
            <?php endif; ?>
        </div>
        <?php if ($vm2_cliente_card || ($e['wa_link'] && $e['wa_link'] !== '#')): ?>
        <div class="vm2-ev-cliente-row" onclick="event.stopPropagation()">
            <?php if ($vm2_cliente_card): ?>
            <span class="vm2-ev-cliente-nome">👤 <?php echo esc_html($vm2_cliente_card); ?></span>
            <?php endif; ?>
            <?php if ($e['wa_link'] && $e['wa_link'] !== '#'): ?>
            <a href="<?php echo esc_url($e['wa_link']); ?>" target="_blank" class="vm2-ev-wa-btn">💬 <?php echo $vm2_cliente_card ? 'Chamar' : 'WhatsApp'; ?></a>
            <?php endif; ?>
            <?php $contrato_oid = !empty($e['wc_order_id']) ? (int)$e['wc_order_id'] : ($e['source']==='wc' && is_numeric($e['id']) ? (int)$e['id'] : 0); ?>
            <?php if ($contrato_oid): ?>
            <button class="vm2-ev-contrato-btn" onclick="vm2OpenContrato(<?php echo $contrato_oid; ?>);event.stopPropagation()">📄 Contrato</button>
            <?php endif; ?>
        </div>
        <?php endif; ?>
    </div>
    <?php endforeach; ?>
    <?php if ( empty($list_events) ): ?>
        <div style="text-align:center;padding:40px;color:#57606a;background:#fff;border-radius:8px;border:1px solid #e0e0e0">Nenhum evento encontrado.</div>
    <?php endif; ?>
    </div>
    <?php endif; ?>

    <!-- DRAWER CONTRATO -->
    <div class="vm2-ct-overlay" id="vm2ContratoOverlay" onclick="if(event.target===this)this.classList.remove('open')">
        <div class="vm2-ct-panel">
            <div class="vm2-drag-ct"></div>
            <div class="vm2-ct-header">
                <span class="vm2-ct-title">📄 Dados do Contrato</span>
                <button class="vm2-ct-close" onclick="document.getElementById('vm2ContratoOverlay').classList.remove('open')">✕</button>
            </div>
            <div id="vm2ContratoContent"></div>
        </div>
    </div>

    <!-- MODAL -->
    <div class="vm2-modal-overlay" id="vm2AgModal" onclick="if(event.target===this)this.classList.remove('open')">
        <div class="vm2-modal-panel">
            <div class="vm2-drag-handle"></div>
            <button class="vm2-modal-close" onclick="document.getElementById('vm2AgModal').classList.remove('open')">✕</button>
            <h2 class="vm2-modal-title" id="vm2AgTitle">—</h2>
            <div id="vm2AgContent"></div>
        </div>
    </div>
    <?php if ( $view === 'alertas' ):
        $ag_alerts_enabled = get_option('vm2_agenda_alerts_global_enabled', 1);
        $ag_alerts         = get_option('vm2_agenda_alerts', []);
        if ( ! is_array($ag_alerts) ) $ag_alerts = [];
        $ag_channels       = vm2_channels();
        $ag_def_msg = "🎪 *LEMBRETE DE EVENTO — {dias_antes} dias*\n\n📅 *Data:* {data} ({dia_semana})\n🎉 *Evento:* {tipo}\n👤 *Homenageado(s):* {homenageado}\n🎤 *Prestador:* {prestador}\n📍 *Local:* {local}\n🕐 *Horário:* {horario}\n💰 *Custo:* {custo}\n\n_Lembrete automático — VivaMais CRM_";
        $ag_alert_nonce = wp_create_nonce('vm2_agenda_alerts_save');
    ?>
    <div style="background:#fff;border:1px solid #e0e0e0;border-radius:10px;padding:24px;margin-top:16px">
        <!-- Header -->
        <div style="display:flex;align-items:center;justify-content:space-between;margin-bottom:20px;flex-wrap:wrap;gap:10px">
            <div>
                <h2 style="margin:0;font-size:18px">🔔 Alertas de Agenda</h2>
                <p style="margin:4px 0 0;color:#57606a;font-size:13px">Envie lembretes automáticos para o grupo de WhatsApp da gestão antes de cada evento.</p>
            </div>
            <div style="display:flex;align-items:center;gap:12px">
                <label style="display:flex;align-items:center;gap:6px;font-size:13px;font-weight:600">
                    <span style="width:38px;height:22px;background:<?php echo $ag_alerts_enabled ? '#22c55e' : '#d1d5db'; ?>;border-radius:11px;position:relative;display:inline-block;cursor:pointer" onclick="document.getElementById('vm2AgAlertGlobal').click()">
                        <span style="position:absolute;top:2px;left:<?php echo $ag_alerts_enabled ? '18px' : '2px'; ?>;width:18px;height:18px;background:#fff;border-radius:50%;transition:left .2s"></span>
                    </span>
                    <?php echo $ag_alerts_enabled ? '<span style="color:#22c55e">Alertas Ativos</span>' : '<span style="color:#9ca3af">Alertas Pausados</span>'; ?>
                </label>
            </div>
        </div>

        <form method="post" action="<?php echo esc_url( add_query_arg(['page'=>'vm2-agenda','view'=>'alertas'], admin_url('admin.php')) ); ?>">
            <?php wp_nonce_field('vm2_agenda_alerts_save'); ?>
            <input type="hidden" name="vm2_save_agenda_alerts" value="1">
            <input type="hidden" name="vm2_agenda_alerts_global_enabled" id="vm2AgAlertGlobalHidden" value="<?php echo $ag_alerts_enabled ? '1' : '0'; ?>">
            <input type="checkbox" id="vm2AgAlertGlobal" style="display:none" <?php checked($ag_alerts_enabled, 1); ?> onchange="document.getElementById('vm2AgAlertGlobalHidden').value=this.checked?'1':'0';this.closest('form').submit()">

            <!-- Tabela de regras -->
            <div id="vm2AlertRulesWrap">
            <?php if ( empty($ag_alerts) ): ?>
            <div id="vm2AlertEmpty" style="text-align:center;padding:32px;background:#f9f9f9;border-radius:8px;border:2px dashed #e0e0e0;color:#57606a;font-size:14px">
                Nenhum alerta configurado ainda.<br>
                <button type="button" onclick="vm2AddAlertRule()" style="margin-top:12px;padding:8px 20px;background:#0073aa;color:#fff;border:none;border-radius:6px;cursor:pointer;font-size:13px">+ Adicionar Alerta</button>
            </div>
            <?php else: ?>
            <div id="vm2AlertEmpty" style="display:none"></div>
            <?php endif; ?>

            <div id="vm2AlertRules">
            <?php foreach ( $ag_alerts as $idx => $rule ): ?>
            <div class="vm2-alert-rule" data-idx="<?php echo $idx; ?>" style="background:#f9fafb;border:1px solid #e0e0e0;border-radius:10px;padding:18px;margin-bottom:14px;position:relative">
                <input type="hidden" name="agenda_alerts[<?php echo $idx; ?>][id]" value="<?php echo esc_attr($rule['id']); ?>">
                <div style="display:grid;grid-template-columns:1fr auto;gap:10px;align-items:start;margin-bottom:12px">
                    <div>
                        <label style="font-size:12px;font-weight:600;color:#57606a;display:block;margin-bottom:4px">Nome da regra</label>
                        <input type="text" name="agenda_alerts[<?php echo $idx; ?>][name]" value="<?php echo esc_attr($rule['name']); ?>" placeholder="Ex: Lembrete 7 dias antes" style="width:100%;padding:7px 10px;border:1px solid #ddd;border-radius:6px;font-size:13px">
                    </div>
                    <div style="display:flex;align-items:center;gap:10px;padding-top:22px">
                        <label style="font-size:12px;color:#57606a;display:flex;align-items:center;gap:5px">
                            <input type="checkbox" name="agenda_alerts[<?php echo $idx; ?>][enabled]" value="1" <?php checked($rule['enabled'], 1); ?>> Ativo
                        </label>
                        <button type="button" onclick="vm2RemoveAlertRule(this)" style="background:#fef2f2;border:1px solid #fecaca;color:#dc2626;border-radius:6px;padding:5px 10px;cursor:pointer;font-size:12px">🗑️</button>
                    </div>
                </div>
                <div style="display:grid;grid-template-columns:repeat(auto-fit,minmax(180px,1fr));gap:12px;margin-bottom:12px">
                    <div>
                        <label style="font-size:12px;font-weight:600;color:#57606a;display:block;margin-bottom:4px">⏰ Dias antes do evento</label>
                        <input type="number" name="agenda_alerts[<?php echo $idx; ?>][days_before]" value="<?php echo intval($rule['days_before']); ?>" min="1" max="365" style="width:100%;padding:7px 10px;border:1px solid #ddd;border-radius:6px;font-size:13px">
                    </div>
                    <div>
                        <label style="font-size:12px;font-weight:600;color:#57606a;display:block;margin-bottom:4px">📡 Canal Z-API</label>
                        <select name="agenda_alerts[<?php echo $idx; ?>][channel]" style="width:100%;padding:7px 10px;border:1px solid #ddd;border-radius:6px;font-size:13px">
                            <?php foreach ( $ag_channels as $ck => $ch ):
                                if ( ($ch['type'] ?? '') === 'waba' ) continue; // grupos só via Z-API
                            ?>
                            <option value="<?php echo esc_attr($ck); ?>" <?php selected($rule['channel'], $ck); ?>>
                                <?php echo esc_html($ch['label'] ?? $ck); ?>
                            </option>
                            <?php endforeach; ?>
                        </select>
                        <span style="font-size:11px;color:#9ca3af">⚠️ Apenas Z-API (grupos)</span>
                    </div>
                    <div>
                        <label style="font-size:12px;font-weight:600;color:#57606a;display:block;margin-bottom:4px">👥 ID do Grupo WA</label>
                        <input type="text" name="agenda_alerts[<?php echo $idx; ?>][group_id]" value="<?php echo esc_attr($rule['group_id']); ?>" placeholder="Ex: 120363425785358764-group" style="width:100%;padding:7px 10px;border:1px solid #ddd;border-radius:6px;font-size:13px;font-family:monospace">
                    </div>
                </div>
                <div>
                    <label style="font-size:12px;font-weight:600;color:#57606a;display:block;margin-bottom:4px">💬 Mensagem <span style="font-weight:400;color:#9ca3af">— Variáveis: {data} {dia_semana} {tipo} {homenageado} {prestador} {local} {endereco} {assessor} {horario} {custo} {dias_antes}</span></label>
                    <textarea name="agenda_alerts[<?php echo $idx; ?>][message]" rows="5" style="width:100%;padding:8px 10px;border:1px solid #ddd;border-radius:6px;font-size:13px;font-family:monospace;resize:vertical"><?php echo esc_textarea($rule['message']); ?></textarea>
                </div>
            </div>
            <?php endforeach; ?>
            </div>

            <button type="button" onclick="vm2AddAlertRule()" style="margin-top:4px;padding:8px 20px;background:#f0f9ff;border:1px solid #7dd3fc;color:#0369a1;border-radius:6px;cursor:pointer;font-size:13px;font-weight:600">+ Adicionar Regra</button>

            <div style="display:flex;justify-content:flex-end;margin-top:20px;padding-top:16px;border-top:1px solid #e0e0e0;gap:12px;align-items:center">
                <?php
                $last_run = get_option('vm2_agenda_alerts_last_run', '');
                if ($last_run): ?>
                <span style="font-size:12px;color:#57606a">Último disparo: <?php echo esc_html(vm2_local_date('d/m H:i', $last_run)); ?></span>
                <?php endif; ?>
                <button type="submit" class="button button-primary" style="font-size:14px;padding:8px 24px">💾 Salvar Alertas</button>
            </div>
            </div><!-- #vm2AlertRulesWrap -->
        </form>

        <!-- Info / Log box -->
        <?php
        $alert_log = get_option('vm2_agenda_alerts_log', []);
        $log_count = count($alert_log);
        ?>
        <div style="margin-top:20px;background:#f0fdf4;border:1px solid #bbf7d0;border-radius:8px;padding:14px 18px">
            <div style="font-size:13px;color:#15803d;font-weight:600;margin-bottom:6px">📋 Status do sistema</div>
            <div style="font-size:12px;color:#166534;display:flex;flex-wrap:wrap;gap:16px">
                <span>📊 Alertas já enviados no log: <strong><?php echo $log_count; ?></strong></span>
                <span>⏰ Cron: diário às 08:00 (horário SP)</span>
                <span>🔐 Deduplicação automática (nunca envia 2x o mesmo alerta)</span>
            </div>
            <?php if ($log_count > 0): ?>
            <div style="margin-top:8px">
                <a href="#" onclick="if(confirm('Isso vai limpar o histórico e permitir re-envio dos alertas. Confirmar?')){document.getElementById('vm2ClearAlertLog').submit();} return false;" style="font-size:11px;color:#dc2626">🗑️ Limpar log de deduplicação</a>
                <form id="vm2ClearAlertLog" method="post" style="display:none">
                    <?php wp_nonce_field('vm2_agenda_alerts_save'); ?>
                    <input type="hidden" name="vm2_save_agenda_alerts" value="1">
                    <input type="hidden" name="vm2_agenda_alerts_global_enabled" value="<?php echo $ag_alerts_enabled; ?>">
                    <input type="hidden" name="vm2_clear_alert_log" value="1">
                </form>
            </div>
            <?php endif; ?>
        </div>

        <!-- Variáveis info -->
        <div style="margin-top:14px;background:#fefce8;border:1px solid #fef08a;border-radius:8px;padding:14px 18px">
            <div style="font-size:13px;font-weight:600;color:#854d0e;margin-bottom:8px">📌 Variáveis disponíveis na mensagem</div>
            <div style="display:flex;flex-wrap:wrap;gap:6px;font-size:12px">
                <?php foreach (['data','dia_semana','tipo','homenageado','prestador','local','endereco','assessor','horario','custo','dias_antes'] as $var): ?>
                <code style="background:#fef9c3;padding:2px 7px;border-radius:4px;border:1px solid #fef08a;color:#713f12">{<?php echo $var; ?>}</code>
                <?php endforeach; ?>
            </div>
        </div>
    </div>

    <script>
    var vm2AlertIdx = <?php echo max(count($ag_alerts) - 1, -1); ?>;
    var vm2AlertChannels = <?php
        $ch_opts = [];
        foreach ($ag_channels as $ck => $ch) {
            if (($ch['type'] ?? '') === 'waba') continue;
            $ch_opts[] = ['key' => $ck, 'label' => $ch['label'] ?? $ck];
        }
        echo json_encode($ch_opts, JSON_UNESCAPED_UNICODE);
    ?>;
    var vm2AlertDefMsg = <?php echo json_encode($ag_def_msg, JSON_UNESCAPED_UNICODE); ?>;

    function vm2AddAlertRule() {
        vm2AlertIdx++;
        var idx = vm2AlertIdx;
        document.getElementById('vm2AlertEmpty').style.display = 'none';
        var chOpts = vm2AlertChannels.map(function(c){
            return '<option value="'+c.key+'">'+c.label+'</option>';
        }).join('');
        var html = '<div class="vm2-alert-rule" data-idx="'+idx+'" style="background:#f9fafb;border:1px solid #e0e0e0;border-radius:10px;padding:18px;margin-bottom:14px;position:relative">'
            +'<input type="hidden" name="agenda_alerts['+idx+'][id]" value="ar_'+idx+Date.now()+'">'
            +'<div style="display:grid;grid-template-columns:1fr auto;gap:10px;align-items:start;margin-bottom:12px">'
            +'<div><label style="font-size:12px;font-weight:600;color:#57606a;display:block;margin-bottom:4px">Nome da regra</label>'
            +'<input type="text" name="agenda_alerts['+idx+'][name]" placeholder="Ex: Lembrete 7 dias antes" style="width:100%;padding:7px 10px;border:1px solid #ddd;border-radius:6px;font-size:13px"></div>'
            +'<div style="display:flex;align-items:center;gap:10px;padding-top:22px">'
            +'<label style="font-size:12px;color:#57606a;display:flex;align-items:center;gap:5px"><input type="checkbox" name="agenda_alerts['+idx+'][enabled]" value="1" checked> Ativo</label>'
            +'<button type="button" onclick="vm2RemoveAlertRule(this)" style="background:#fef2f2;border:1px solid #fecaca;color:#dc2626;border-radius:6px;padding:5px 10px;cursor:pointer;font-size:12px">🗑️</button>'
            +'</div></div>'
            +'<div style="display:grid;grid-template-columns:repeat(auto-fit,minmax(180px,1fr));gap:12px;margin-bottom:12px">'
            +'<div><label style="font-size:12px;font-weight:600;color:#57606a;display:block;margin-bottom:4px">⏰ Dias antes do evento</label>'
            +'<input type="number" name="agenda_alerts['+idx+'][days_before]" value="7" min="1" max="365" style="width:100%;padding:7px 10px;border:1px solid #ddd;border-radius:6px;font-size:13px"></div>'
            +'<div><label style="font-size:12px;font-weight:600;color:#57606a;display:block;margin-bottom:4px">📡 Canal Z-API</label>'
            +'<select name="agenda_alerts['+idx+'][channel]" style="width:100%;padding:7px 10px;border:1px solid #ddd;border-radius:6px;font-size:13px">'+chOpts+'</select>'
            +'<span style="font-size:11px;color:#9ca3af">⚠️ Apenas Z-API (grupos)</span></div>'
            +'<div><label style="font-size:12px;font-weight:600;color:#57606a;display:block;margin-bottom:4px">👥 ID do Grupo WA</label>'
            +'<input type="text" name="agenda_alerts['+idx+'][group_id]" placeholder="Ex: 120363425785358764-group" style="width:100%;padding:7px 10px;border:1px solid #ddd;border-radius:6px;font-size:13px;font-family:monospace"></div>'
            +'</div>'
            +'<div><label style="font-size:12px;font-weight:600;color:#57606a;display:block;margin-bottom:4px">💬 Mensagem <span style="font-weight:400;color:#9ca3af">— Variáveis: {data} {dia_semana} {tipo} {homenageado} {prestador} {local} {endereco} {assessor} {horario} {custo} {dias_antes}</span></label>'
            +'<textarea name="agenda_alerts['+idx+'][message]" rows="5" style="width:100%;padding:8px 10px;border:1px solid #ddd;border-radius:6px;font-size:13px;font-family:monospace;resize:vertical">'+vm2AlertDefMsg+'</textarea>'
            +'</div></div>';
        document.getElementById('vm2AlertRules').insertAdjacentHTML('beforeend', html);
    }
    function vm2RemoveAlertRule(btn) {
        btn.closest('.vm2-alert-rule').remove();
        if (!document.querySelectorAll('.vm2-alert-rule').length) {
            document.getElementById('vm2AlertEmpty').style.display = '';
        }
    }
    </script>
    <?php endif; // view === alertas ?>

    <script>
    // Detecta e parseia blobs do tipo "Chave: Valor / Chave: Valor"
    function vm2ParseBlob(raw) {
        if (!raw || raw === '—' || raw.length < 30) return null;
        // Precisa ter padrão "Palavra: valor /" ou checkmark com segmentos
        if (raw.indexOf('/') === -1 && raw.indexOf('✅') === -1) return null;
        var segments = raw.split(/\s*\/\s*/).map(function(s){ return s.replace(/^\s*✅\s*/, '').trim(); });
        if (segments.length < 2) return null;
        var html = '<div style="display:flex;flex-direction:column;gap:6px">';
        segments.forEach(function(seg) {
            if (!seg) return;
            var ci = seg.indexOf(':');
            if (ci > 0 && ci < 28) {
                var lbl = seg.substring(0, ci).trim();
                var val = seg.substring(ci + 1).trim();
                if (val) html += '<div class="vm2-blob-row"><span class="vm2-blob-lbl">'+lbl+'</span><span class="vm2-blob-val">'+val+'</span></div>';
            } else if (seg.length > 2) {
                html += '<div class="vm2-blob-row"><span class="vm2-blob-val">'+seg+'</span></div>';
            }
        });
        html += '</div>';
        return html;
    }
    function vm2CleanName(raw) {
        if (!raw) return '—';
        var m = raw.match(/Nome Completo[:\s]+([^\/\n]{1,80})/i);
        if (m) return m[1].trim();
        return raw;
    }
    function vm2Row(lbl, val) {
        return '<div class="vm2-modal-row"><span class="vm2-modal-lbl">'+lbl+'</span><span class="vm2-modal-val">'+val+'</span></div>';
    }
    function vm2OpenModal(e) {
        var du = e.days_until;
        var tag = du < 0 ? '<span style="color:#6e7781">✓ Realizado</span>'
                : du === 0 ? '<span style="color:#d1242f;font-weight:700">🔴 HOJE!</span>'
                : du === 1 ? '<span style="color:#e16f24">⏰ Amanhã</span>'
                : '<span style="color:#57606a">📅 Em '+du+' dias</span>';
        document.getElementById('vm2AgTitle').innerHTML = '📋 ' + e.date_fmt + ' ' + tag;

        var html = '';
        // Bloco cliente no topo
        if (e.customer || (e.wa_link && e.wa_link !== '#')) {
            html += '<div class="vm2-modal-cliente">';
            if (e.customer) html += '<div class="vm2-modal-cliente-nome">👤 ' + e.customer + '</div>';
            if (e.wa_link && e.wa_link !== '#') {
                html += '<a href="'+e.wa_link+'" target="_blank" class="vm2-mbtn green" style="display:inline-flex;align-items:center;gap:6px;font-size:14px;padding:10px 20px;border-radius:8px;font-weight:700">💬 Chamar no WhatsApp</a>';
            }
            html += '</div>';
        }
        // Campos parseados do blob (só exibe se tiver valor)
        var fields = [
            ['🎪 Tipo de Evento',  e.tipo],
            ['👑 Homenageado/Casal', e.homenageado],
            ['🎤 Prestador',       e.prestador],
            ['📍 Local',           e.local],
            ['🏠 Endereço',        e.endereco],
            ['🤝 Assessor',        e.assessor],
            ['⏰ Horário',         e.horario],
            ['💰 Custo',           e.custo],
        ];
        fields.forEach(function(r) {
            if (r[1] && r[1] !== '—' && r[1] !== '') {
                html += vm2Row(r[0], r[1]);
            }
        });
        // Serviços VivaMais — bloco separado se existir
        if (e.servicos && e.servicos.trim()) {
            html += '<hr class="vm2-modal-hr">';
            html += '<p style="font-size:11px;font-weight:700;text-transform:uppercase;color:#7c3aed;margin:0 0 8px">🎭 Serviços VivaMais</p>';
            html += '<div style="font-size:13px;color:#1d2327;white-space:pre-line;line-height:1.5">' + e.servicos + '</div>';
        }
        // Whatsapp
        html += '<hr class="vm2-modal-hr">';
        html += '<div class="vm2-modal-acts">';
        if (e.wa_link && e.wa_link !== '#') {
            html += '<a href="'+e.wa_link+'" target="_blank" class="vm2-mbtn green">💬 WhatsApp</a>';
        }
        var contratoOrderId = e.wc_order_id || (e.source === 'wc' && e.id && !isNaN(e.id) ? e.id : 0);
        if (contratoOrderId) {
            html += '<button onclick="vm2OpenContrato('+contratoOrderId+')" class="vm2-mbtn" style="background:#f3f0ff;border:1px solid #a78bfa;color:#6d28d9">📄 Contrato</button>';
        }
        html += '</div>';
        document.getElementById('vm2AgContent').innerHTML = html;
        document.getElementById('vm2AgModal').classList.add('open');
    }
    var vm2ContratoNonce = '<?php echo wp_create_nonce('vm2_contrato'); ?>';
    function vm2OpenContrato(order_id) {
        var overlay = document.getElementById('vm2ContratoOverlay');
        var content = document.getElementById('vm2ContratoContent');
        content.innerHTML = '<div style="text-align:center;padding:40px;color:#57606a">⏳ Carregando dados do contrato...</div>';
        overlay.classList.add('open');
        // Fecha modal principal se estiver aberto
        document.getElementById('vm2AgModal').classList.remove('open');
        var fd = new FormData();
        fd.append('action', 'vm2_contrato_data');
        fd.append('order_id', order_id);
        fd.append('nonce', vm2ContratoNonce);
        fetch(ajaxurl, {method:'POST', body:fd})
            .then(function(r){return r.json();})
            .then(function(res){
                if (!res.success) {
                    content.innerHTML = '<div style="color:#d1242f;padding:20px">Erro: '+(res.data||'desconhecido')+'</div>';
                    return;
                }
                var d = res.data;
                function ct(lbl, val) {
                    if (!val || val === '—' || val === '') return '';
                    return '<div class="vm2-ct-row"><span class="vm2-ct-lbl">'+lbl+'</span><span class="vm2-ct-val">'+val+'</span></div>';
                }
                var html = '';
                // FICHA DO EVENTO
                html += '<div class="vm2-ct-section">📅 FICHA DO EVENTO</div>';
                html += ct('🎪 Tipo', d.tipo_evento);
                html += ct('👑 Homenageado', d.homenageado);
                html += ct('📅 Data', d.data_evento);
                html += ct('⏰ Início', d.hora_inicio !== '—' ? d.hora_inicio : '');
                html += ct('⏰ Término', d.hora_termino !== '—' ? d.hora_termino : '');
                if (d.duracao && d.duracao !== '—') html += ct('⏱ Duração', d.duracao + ' min');
                html += ct('🎤 Atrações', d.atracao);
                html += ct('📍 Local', d.local_evento);
                html += ct('🏠 Endereço evento', d.endereco);
                html += ct('🏘 Bairro', d.bairro !== '—' ? d.bairro : '');
                if (d.cidade !== '—' && d.estado !== '—') html += ct('🌆 Cidade/UF', d.cidade+'/'+d.estado);
                html += ct('🤝 Assessor', d.assessor);
                html += ct('💬 Obs cliente', d.obs !== '—' ? d.obs : '');
                // DADOS INTERNOS
                html += '<hr class="vm2-ct-sep"><div class="vm2-ct-section">🔒 DADOS INTERNOS</div>';
                html += ct('👤 Cliente', d.nome);
                if (d.cpf && d.cpf !== '—') html += ct('🪪 CPF/CNPJ', d.cpf);
                html += ct('📱 WhatsApp', d.telefone);
                html += ct('✉️ E-mail', d.email);
                if (d.empresa && d.empresa !== '—') html += ct('🏢 Empresa', d.empresa);
                if (d.bil_addr && d.bil_addr !== '—') {
                    html += ct('📬 End. cobrança', d.bil_addr + (d.bil_cidade !== '—' ? ', '+d.bil_cidade+'/'+d.bil_estado : ''));
                    if (d.bil_cep && d.bil_cep !== '—') html += ct('📮 CEP', d.bil_cep);
                }
                html += '<hr class="vm2-ct-sep">';
                html += ct('🧾 Pedido', '#'+d.numero);
                html += ct('💰 Valor total', d.valor);
                html += ct('💳 Pagamento', d.pgto);
                html += ct('📦 Status', d.status_pedido);
                html += ct('📝 ClickSign', d.contrato);
                if (d.cs_link) html += ct('🔗 Link contrato', '<a href="'+d.cs_link+'" target="_blank" style="color:#0969da">Abrir documento</a>');
                if (d.utm_source !== '—') html += ct('🔗 Origem', d.utm_source);
                if (d.utm_campaign !== '—') html += ct('📢 Campanha', d.utm_campaign);
                // Ações
                html += '<hr class="vm2-ct-sep"><div style="display:flex;gap:10px;flex-wrap:wrap">';
                html += '<a href="'+d.link_admin+'" target="_blank" class="vm2-mbtn" style="background:#f3f0ff;border:1px solid #a78bfa;color:#6d28d9;font-size:13px;padding:9px 16px">🔗 Ver Pedido WP</a>';
                if (d.telefone) html += '<a href="https://wa.me/'+d.telefone+'" target="_blank" class="vm2-mbtn green" style="font-size:13px;padding:9px 16px">💬 WhatsApp</a>';
                html += '</div>';
                content.innerHTML = html;
            })
            .catch(function(){
                content.innerHTML = '<div style="color:#d1242f;padding:20px">Erro de conexão. Tente novamente.</div>';
            });
    }
    function vm2CalDay(cell) {
        var spans = cell.querySelectorAll('.vm2agev');
        if (!spans.length) return;
        var events = [];
        spans.forEach(function(s){ events.push(JSON.parse(s.dataset.event)); });
        if (events.length === 1) {
            vm2OpenModal(events[0]);
            return;
        }
        // Múltiplos eventos: lista no modal
        var e0 = events[0];
        var du = e0.days_until;
        var tag = du < 0 ? '<span style="color:#6e7781">✓ Realizado</span>'
                : du === 0 ? '<span style="color:#d1242f;font-weight:700">🔴 HOJE!</span>'
                : du === 1 ? '<span style="color:#e16f24">⏰ Amanhã</span>'
                : '<span style="color:#57606a">📅 Em '+du+' dias</span>';
        document.getElementById('vm2AgTitle').innerHTML = '📅 ' + e0.date_fmt + ' — ' + events.length + ' eventos ' + tag;
        var html = '<div style="display:flex;flex-direction:column;gap:10px">';
        events.forEach(function(ev, i) {
            var color = ev.color || '#0969da';
            html += '<div style="border:1px solid #e0e0e0;border-left:4px solid '+color+';border-radius:8px;padding:12px;cursor:pointer;transition:background .15s" onclick="vm2OpenModal(vm2AgDayEvents['+i+'])" onmouseover="this.style.background=\'#f6f8fa\'" onmouseout="this.style.background=\'#fff\'">';
            html += '<div style="font-size:13px;font-weight:700;margin-bottom:4px">'+ev.customer+'</div>';
            html += '<div style="font-size:12px;color:#57606a;margin-bottom:2px">🎭 '+(ev.atracoes||'—')+'</div>';
            html += '<div style="font-size:12px;color:#57606a">🎪 '+(ev.tipo||'—')+'</div>';
            if (ev.homenageado) html += '<div style="font-size:12px;color:#57606a">👑 '+ev.homenageado+'</div>';
            html += '<div style="font-size:11px;color:#0969da;margin-top:6px;font-weight:600">Ver detalhes →</div>';
            html += '</div>';
        });
        html += '</div>';
        window.vm2AgDayEvents = events;
        document.getElementById('vm2AgContent').innerHTML = html;
        document.getElementById('vm2AgModal').classList.add('open');
    }
    function vm2FilterAgenda() {
        var q     = ((document.getElementById('vm2AgSearch')||{}).value||'').toLowerCase().trim();
        var cards = document.querySelectorAll('.vm2-ev-card');
        var visible = 0;
        cards.forEach(function(card) {
            var s  = card.dataset.search || '';
            var ok = !q || s.indexOf(q) !== -1;
            card.style.display = ok ? '' : 'none';
            if (ok) visible++;
        });
        var el = document.getElementById('vm2AgCount');
        if (el) el.textContent = visible + ' evento' + (visible !== 1 ? 's' : '');
    }
    function vm2ClearSearch() {
        var s = document.getElementById('vm2AgSearch');
        if (s) s.value = '';
        vm2FilterAgenda();
    }
    var vm2AgSyncNonce = '<?php echo esc_js($sync_nonce_ag); ?>';
    var vm2AgSyncStatusUrl = '<?php echo esc_js($ag_sync_status_url); ?>';
    var vm2AgLastSyncVal = '<?php echo esc_js($last_sync_ag); ?>';
    function vm2AgSync() {
        var btn = document.getElementById('vm2AgSyncBtn');
        if (!btn) return;
        btn.disabled = true; btn.textContent = '⏳ Aguardando...';
        fetch(ajaxurl, {
            method:'POST', credentials:'same-origin',
            headers:{'Content-Type':'application/x-www-form-urlencoded'},
            body:'action=vm2_agenda_trigger_sync&nonce='+vm2AgSyncNonce
        }).then(function(r){return r.json();}).then(function(d){
            if (d.success) {
                btn.textContent = '✅ Sincronizando...';
                var tries = 0;
                var poll = setInterval(function(){
                    tries++;
                    if (tries > 30) { clearInterval(poll); btn.disabled=false; btn.textContent='🔄 Sincronizar Planilha'; return; }
                    fetch(vm2AgSyncStatusUrl, {credentials:'same-origin'})
                        .then(function(r){return r.json();})
                        .then(function(s){
                            if (s.last_sync && s.last_sync !== vm2AgLastSyncVal) {
                                clearInterval(poll); location.reload();
                            }
                        });
                }, 3000);
            } else {
                btn.disabled=false; btn.textContent='🔄 Sincronizar Planilha';
                alert('Erro: ' + (d.data||'Desconhecido'));
            }
        });
    }
    </script>
    </div>
    <?php
}

// ─────────────────────────────────────────────────────────────
// AGENDA — DISPATCH ALERTAS (cron diário)
// ─────────────────────────────────────────────────────────────
function vm2_dispatch_agenda_alerts() {
    if ( ! get_option('vm2_agenda_alerts_global_enabled', 1) ) {
        vm2_log('agenda_alerts: desabilitado globalmente', 'info');
        return;
    }
    $rules = get_option('vm2_agenda_alerts', []);
    if ( empty($rules) || ! is_array($rules) ) return;

    $gs_events = get_option('vm2_agenda_gsheets', []);
    if ( ! is_array($gs_events) ) $gs_events = json_decode($gs_events, true) ?: [];
    if ( empty($gs_events) ) {
        vm2_log('agenda_alerts: sem eventos no GSheets', 'info');
        return;
    }

    $today_ts  = strtotime( current_time('Y-m-d') );
    $log       = get_option('vm2_agenda_alerts_log', []);
    if ( ! is_array($log) ) $log = [];
    $days_pt   = ['Sunday'=>'Domingo','Monday'=>'Segunda','Tuesday'=>'Terça','Wednesday'=>'Quarta','Thursday'=>'Quinta','Friday'=>'Sexta','Saturday'=>'Sábado'];
    $sent_total = 0;

    foreach ( $rules as $rule ) {
        if ( empty($rule['enabled']) )   continue;
        if ( empty($rule['group_id']) )  continue;
        if ( empty($rule['channel']) )   continue;
        if ( empty($rule['message']) )   continue;

        $days_before = intval($rule['days_before']);
        $rule_id     = $rule['id'] ?? md5(json_encode($rule));

        foreach ( $gs_events as $row ) {
            if ( empty($row['data_festa']) ) continue;
            $parts = explode('/', $row['data_festa']);
            if ( count($parts) !== 3 ) continue;
            $ts = mktime(0, 0, 0, (int)$parts[1], (int)$parts[0], (int)$parts[2]);
            if ( ! $ts ) continue;

            $days_until = intval( ( $ts - $today_ts ) / 86400 );
            if ( $days_until !== $days_before ) continue;

            // Deduplicação: mesmo alerta não envia 2x para mesmo evento
            $ev_key  = $row['row'] ?? md5( $row['data_festa'] . ($row['prestador'] ?? '') );
            $log_key = $rule_id . '_' . $ev_key . '_' . $days_before;
            if ( in_array($log_key, $log, true) ) {
                vm2_log("agenda_alerts: já enviado ($log_key)", 'info');
                continue;
            }

            // Montar variáveis
            $prestador   = trim($row['prestador'] ?? '');
            $tipo        = trim($row['tipo'] ?? '');
            $homenageado = trim($row['homenageado'] ?? '');
            if (!$tipo && !$homenageado) {
                // Tenta parsear do blob
                if (!empty($row['evento_blob'])) {
                    $parsed      = vm2_parse_agenda_blob($row['evento_blob']);
                    $tipo        = $tipo        ?: $parsed['tipo'];
                    $homenageado = $homenageado ?: $parsed['homenageado'];
                }
            }
            $vars = [
                '{data}'        => date('d/m/Y', $ts),
                '{dia_semana}'  => $days_pt[ date('l', $ts) ] ?? '',
                '{tipo}'        => $tipo        ?: '—',
                '{homenageado}' => $homenageado ?: '—',
                '{prestador}'   => $prestador   ?: '—',
                '{local}'       => trim($row['local'] ?? '')    ?: '—',
                '{endereco}'    => trim($row['endereco'] ?? '')  ?: '—',
                '{assessor}'    => trim($row['assessor'] ?? '')  ?: '—',
                '{horario}'     => trim($row['horario'] ?? '')   ?: '—',
                '{custo}'       => trim($row['custo'] ?? '')     ?: '—',
                '{dias_antes}'  => $days_before,
            ];
            $msg = str_replace( array_keys($vars), array_values($vars), $rule['message'] );

            $ok = vm2_send_zapi( $rule['channel'], $rule['group_id'], $msg );
            if ( $ok !== false ) {
                $log[] = $log_key;
                $sent_total++;
                vm2_log("agenda_alerts: enviado rule={$rule_id} evento={$row['data_festa']} {$prestador} ({$days_before}d antes)", 'info');
            } else {
                vm2_log("agenda_alerts: FALHA rule={$rule_id} evento={$row['data_festa']}", 'error');
            }
        }
    }

    // Trim log para máx 2000 entradas
    if ( count($log) > 2000 ) $log = array_slice($log, -2000);
    update_option('vm2_agenda_alerts_log', $log);
    update_option('vm2_agenda_alerts_last_run', current_time('mysql'));

    if ($sent_total > 0) vm2_log("agenda_alerts: {$sent_total} alertas enviados", 'info');
}
add_action('vm2_agenda_alert_cron', 'vm2_dispatch_agenda_alerts');

// ─────────────────────────────────────────────────────────────
// AJAX — TESTE DE ENVIO
// ─────────────────────────────────────────────────────────────
// ── AJAX: Contrato do Pedido ─────────────────────────────────────────────────
add_action('wp_ajax_vm2_contrato_data', function() {
    if (!current_user_can('manage_options')) wp_send_json_error('Sem permissão');
    check_ajax_referer('vm2_contrato', 'nonce');
    $order_id = intval($_POST['order_id'] ?? 0);
    if (!$order_id) wp_send_json_error('ID inválido');
    $order = wc_get_order($order_id);
    if (!$order) wp_send_json_error('Pedido não encontrado');

    $vars = vm2_build_order_vars($order);

    $billing_addr1   = $order->get_billing_address_1() ?: '—';
    $billing_addr2   = $order->get_billing_address_2() ?: '';
    $billing_city    = $order->get_billing_city() ?: '—';
    $billing_state   = $order->get_billing_state() ?: '—';
    $billing_post    = $order->get_billing_postcode() ?: '—';
    $billing_cpf     = $order->get_meta('_billing_cpf')
                    ?: $order->get_meta('billing_cpf')
                    ?: $order->get_meta('_billing_cnpj')
                    ?: '—';
    $billing_company = $order->get_billing_company() ?: '—';
    $status_label    = wc_get_order_status_name($order->get_status()) ?: $order->get_status();

    // ClickSign doc key / signing URL
    $cs_link = $order->get_meta('_clicksign_document_key')
            ?: $order->get_meta('_clicksign_signing_url')
            ?: $order->get_meta('_clicksign_document_url')
            ?: '';

    wp_send_json_success([
        // Cliente
        'nome'          => $vars['{nome}'],
        'telefone'      => $vars['{telefone}'],
        'email'         => $vars['{email}'],
        'cpf'           => $billing_cpf,
        'empresa'       => $billing_company,
        'bil_addr'      => trim($billing_addr1 . ($billing_addr2 ? ', '.$billing_addr2 : '')),
        'bil_cidade'    => $billing_city,
        'bil_estado'    => $billing_state,
        'bil_cep'       => $billing_post,
        // Evento
        'tipo_evento'   => $vars['{tipo_evento}'],
        'homenageado'   => $vars['{homenageado}'],
        'data_evento'   => $vars['{data_evento}'],
        'hora_inicio'   => $vars['{hora_inicio}'],
        'hora_termino'  => $vars['{hora_termino}'],
        'duracao'       => $vars['{duracao}'],
        'atracao'       => $vars['{atracao}'],
        'local_evento'  => $vars['{local_evento}'],
        'endereco'      => $vars['{endereco}'],
        'bairro'        => $vars['{bairro}'],
        'cidade'        => $vars['{cidade}'],
        'estado'        => $vars['{estado}'],
        'assessor'      => $vars['{assessor}'],
        'obs'           => $vars['{obs}'],
        // Financeiro
        'numero'        => $vars['{numero}'],
        'valor'         => 'R$ ' . $vars['{valor}'],
        'pgto'          => $vars['{pgto}'],
        'status_pedido' => $status_label,
        // ClickSign
        'contrato'      => $vars['{contrato}'],
        'cs_link'       => $cs_link,
        // UTM
        'utm_source'    => $vars['{utm_source}'],
        'utm_campaign'  => $vars['{utm_campaign}'],
        // Link admin
        'link_admin'    => $vars['{link_admin}'],
    ]);
});

add_action( 'wp_ajax_vm2_test_send', 'vm2_ajax_test_send' );
function vm2_ajax_test_send() {
    if ( ! check_ajax_referer( 'vm2_test_send', 'nonce', false ) ) {
        wp_send_json_error( [ 'message' => 'Nonce inválido' ] );
    }
    if ( ! current_user_can( 'manage_options' ) ) {
        wp_send_json_error( [ 'message' => 'Sem permissão' ] );
    }

    $phone    = preg_replace( '/\D/', '', sanitize_text_field( wp_unslash( $_POST['phone'] ?? '' ) ) );
    $order_id = intval( $_POST['order_id'] ?? 0 );
    $message  = sanitize_textarea_field( wp_unslash( $_POST['message'] ?? '' ) );
    $channel  = sanitize_key( $_POST['channel'] ?? 'zapi_7551' );
    $is_waba  = ! empty( $_POST['is_waba'] );
    $template = sanitize_text_field( wp_unslash( $_POST['template'] ?? '' ) );

    if ( ! $phone || strlen( $phone ) < 10 ) {
        wp_send_json_error( [ 'message' => 'Número inválido. Use formato: 5511999887766' ] );
    }

    if ( $is_waba ) {
        // Envio via WABA com template
        if ( ! $template ) {
            wp_send_json_error( [ 'message' => 'Selecione um template WABA antes de enviar.' ] );
        }
        $result = vm2_send_waba( $channel, $phone, $template );
        if ( $result && ! empty( $result['ok'] ) ) {
            wp_send_json_success( [ 'message' => 'Template WABA enviado! ✅' ] );
        } else {
            $detail = '';
            if ( is_array( $result ) && ! empty( $result['body'] ) ) {
                $decoded = json_decode( $result['body'], true );
                $detail  = $decoded['error']['message'] ?? $result['body'];
            }
            wp_send_json_error( [ 'message' => 'Falha WABA (' . ( $result['code'] ?? '?' ) . '): ' . $detail ] );
        }
        return;
    }

    // Substituir variáveis com dados do pedido
    $vars = [];
    if ( $order_id && function_exists( 'wc_get_order' ) ) {
        $order = wc_get_order( $order_id );
        if ( $order ) {
            $vars = vm2_build_order_vars( $order );
        }
    }

    $final_msg = vm2_replace_vars( $message, $vars );
    $ok        = vm2_send_zapi( $channel, $phone, $final_msg );

    if ( $ok ) {
        wp_send_json_success( [ 'message' => 'Mensagem enviada!' ] );
    } else {
        wp_send_json_error( [ 'message' => 'Falha ao enviar. Verifique o Log do WooCommerce (Status > Logs > vivamais-crm-v2).' ] );
    }
}

// ─── Sync Manual Kommo ────────────────────────────────────────────────────
add_action( 'wp_ajax_vm2_manual_sync', 'vm2_manual_sync_handler' );
function vm2_manual_sync_handler() {
    check_ajax_referer( 'vm2_manual_sync', 'nonce' );
    if ( ! current_user_can( 'manage_options' ) ) wp_send_json_error( [ 'msg' => 'Acesso negado' ] );
    @set_time_limit( 300 );

    $kommo_total  = 0;
    $woo_synced   = 0;
    $last_error   = null;

    // ── Kommo sync ──
    if ( function_exists( 'vm_kommo_run_sync' ) ) {
        vm_kommo_run_sync( $last_error );
        if ( ! $last_error ) {
            global $wpdb;
            $kommo_total = (int) $wpdb->get_var( "SELECT COUNT(*) FROM {$wpdb->prefix}vm_kommo_leads" );
        }
    }

    // ── WooCommerce sync (últimos 90 dias) ──
    if ( function_exists( 'vm_crm_process_woo_order' ) && function_exists( 'wc_get_orders' ) ) {
        $orders = wc_get_orders( [
            'limit'        => 500,
            'status'       => [ 'processing', 'completed', 'on-hold', 'pending' ],
            'date_created' => '>' . ( time() - 90 * DAY_IN_SECONDS ),
            'return'       => 'ids',
        ] );
        foreach ( $orders as $order_id ) {
            vm_crm_process_woo_order( $order_id );
            $woo_synced++;
        }
    }

    if ( $last_error && $woo_synced === 0 ) {
        wp_send_json_error( [ 'msg' => $last_error ] );
    }

    wp_send_json_success( [
        'msg' => "✅ Sync completo! Kommo: {$kommo_total} leads | WooCommerce: {$woo_synced} pedidos processados.",
    ] );
}


// ─────────────────────────────────────────────────────────────
// LOG
// ─────────────────────────────────────────────────────────────
function vm2_log( $message, $level = 'info' ) {
    if ( class_exists( 'WC_Logger' ) ) {
        wc_get_logger()->log( $level, '[VM2] ' . $message, [ 'source' => 'vivamais-crm-v2' ] );
    }
    error_log( '[VM2][' . strtoupper( $level ) . '] ' . $message );
}

// ─────────────────────────────────────────────────────────────
// PARCEIROS & ARTISTAS — TABELAS BD
// ─────────────────────────────────────────────────────────────
// ─────────────────────────────────────────────────────────────
// TABELA vm2_sends — árbitro central de cooldown/dedup
// ─────────────────────────────────────────────────────────────
function vm2_create_sends_table() {
    global $wpdb;
    $charset = $wpdb->get_charset_collate();
    $sql = "CREATE TABLE IF NOT EXISTS {$wpdb->prefix}vm2_sends (
        id          bigint(20) NOT NULL AUTO_INCREMENT,
        phone       varchar(30) NOT NULL,
        module      varchar(40) NOT NULL DEFAULT '',
        channel_key varchar(50) NOT NULL DEFAULT '',
        sent_at     datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
        PRIMARY KEY  (id),
        KEY idx_phone_sent   (phone, sent_at),
        KEY idx_channel_date (channel_key, sent_at)
    ) {$charset};";
    require_once ABSPATH . 'wp-admin/includes/upgrade.php';
    dbDelta( $sql );
}

function vm2_create_partner_tables() {
    global $wpdb;
    $charset = $wpdb->get_charset_collate();

    $sql = "CREATE TABLE IF NOT EXISTS {$wpdb->prefix}vm2_partners (
        id bigint(20) NOT NULL AUTO_INCREMENT,
        name varchar(200) NOT NULL,
        phone varchar(30),
        email varchar(100),
        atracao varchar(500),
        regiao varchar(200),
        cidade varchar(100),
        estado varchar(2),
        status varchar(20) DEFAULT 'ativo',
        nps decimal(3,1) DEFAULT NULL,
        total_eventos int DEFAULT 0,
        cache_tags varchar(500),
        wc_categories text DEFAULT NULL,
        wc_tags text DEFAULT NULL,
        observacoes text,
        funcao varchar(30) DEFAULT 'outros',
        cache_valor decimal(10,2) DEFAULT NULL,
        cache_tipo varchar(10) DEFAULT 'reais',
        created_at datetime DEFAULT CURRENT_TIMESTAMP,
        updated_at datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
        PRIMARY KEY (id)
    ) $charset;";

    $sql2 = "CREATE TABLE IF NOT EXISTS {$wpdb->prefix}vm2_availability (
        id bigint(20) NOT NULL AUTO_INCREMENT,
        partner_id bigint(20) NOT NULL,
        event_date date NOT NULL,
        status varchar(20) DEFAULT 'ocupado',
        order_id bigint(20),
        PRIMARY KEY (id),
        KEY partner_date (partner_id, event_date)
    ) $charset;";

    $sql3 = "CREATE TABLE IF NOT EXISTS {$wpdb->prefix}vm2_product_partners (
        id bigint(20) NOT NULL AUTO_INCREMENT,
        product_id bigint(20) NOT NULL,
        partner_id bigint(20) NOT NULL,
        PRIMARY KEY (id),
        UNIQUE KEY product_partner (product_id, partner_id)
    ) $charset;";

    $sql4 = "CREATE TABLE IF NOT EXISTS {$wpdb->prefix}vm2_partner_events (
        id bigint(20) NOT NULL AUTO_INCREMENT,
        partner_id bigint(20) NOT NULL,
        order_id bigint(20),
        event_date date,
        stage varchar(30) DEFAULT 'matching',
        notes text,
        created_at datetime DEFAULT CURRENT_TIMESTAMP,
        updated_at datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
        PRIMARY KEY (id)
    ) $charset;";

    $sql5 = "CREATE TABLE IF NOT EXISTS {$wpdb->prefix}vm2_approval_queue (
        id bigint(20) NOT NULL AUTO_INCREMENT,
        partner_id bigint(20),
        order_id bigint(20),
        phone varchar(30),
        message text,
        tipo varchar(50) DEFAULT 'convite',
        priority varchar(10) DEFAULT 'normal',
        status varchar(20) DEFAULT 'pendente',
        sent_at datetime,
        created_at datetime DEFAULT CURRENT_TIMESTAMP,
        PRIMARY KEY (id)
    ) $charset;";

    $sql6 = "CREATE TABLE IF NOT EXISTS {$wpdb->prefix}vm2_teams (
        id bigint(20) NOT NULL AUTO_INCREMENT,
        order_id bigint(20) NOT NULL DEFAULT 0,
        event_date date DEFAULT NULL,
        client_name varchar(200) DEFAULT NULL,
        client_phone varchar(30) DEFAULT NULL,
        team_json longtext DEFAULT NULL,
        missing_cats text DEFAULT NULL,
        confirm_token varchar(64) DEFAULT NULL,
        status varchar(20) DEFAULT \'draft\',
        confirmed_by varchar(100) DEFAULT NULL,
        is_simulation tinyint(1) DEFAULT 0,
        created_at datetime DEFAULT CURRENT_TIMESTAMP,
        confirmed_at datetime DEFAULT NULL,
        PRIMARY KEY (id),
        UNIQUE KEY confirm_token (confirm_token),
        KEY order_id (order_id)
    ) $charset;";

    require_once ABSPATH . 'wp-admin/includes/upgrade.php';
    dbDelta($sql); dbDelta($sql2); dbDelta($sql3); dbDelta($sql4); dbDelta($sql5); dbDelta($sql6);

    // Defensive: add new columns to vm2_partners if missing (for sites that already had the table)
    $partner_cols = $wpdb->get_col("SHOW COLUMNS FROM {$wpdb->prefix}vm2_partners");
    if (!in_array('wc_categories', $partner_cols)) {
        $wpdb->query("ALTER TABLE {$wpdb->prefix}vm2_partners ADD COLUMN wc_categories text DEFAULT NULL");
    }
    if (!in_array('wc_tags', $partner_cols)) {
        $wpdb->query("ALTER TABLE {$wpdb->prefix}vm2_partners ADD COLUMN wc_tags text DEFAULT NULL");
    }
    if (!in_array('funcao', $partner_cols)) {
        $wpdb->query("ALTER TABLE {$wpdb->prefix}vm2_partners ADD COLUMN funcao varchar(30) DEFAULT 'outros'");
    }
    if (!in_array('cache_valor', $partner_cols)) {
        $wpdb->query("ALTER TABLE {$wpdb->prefix}vm2_partners ADD COLUMN cache_valor decimal(10,2) DEFAULT NULL");
    }
    if (!in_array('cache_tipo', $partner_cols)) {
        $wpdb->query("ALTER TABLE {$wpdb->prefix}vm2_partners ADD COLUMN cache_tipo varchar(10) DEFAULT 'reais'");
    }
}

// Garante tabelas existem mesmo se plugin já estava ativo
add_action('admin_init', function() {
    if ( !get_option('vm2_partner_tables_v1') ) {
        vm2_create_partner_tables();
        update_option('vm2_partner_tables_v1', '1');
    }
    // v1.5.70 — garante vm2_teams existe mesmo em sites com migration antiga
    if ( !get_option('vm2_elenco_tables_v1') ) {
        global $wpdb;
        $charset = $wpdb->get_charset_collate();
        $sql_teams = "CREATE TABLE IF NOT EXISTS {$wpdb->prefix}vm2_teams (
            id bigint(20) NOT NULL AUTO_INCREMENT,
            order_id bigint(20) NOT NULL DEFAULT 0,
            event_date date DEFAULT NULL,
            client_name varchar(200) DEFAULT NULL,
            client_phone varchar(30) DEFAULT NULL,
            team_json longtext DEFAULT NULL,
            missing_cats text DEFAULT NULL,
            confirm_token varchar(64) DEFAULT NULL,
            status varchar(20) DEFAULT 'draft',
            confirmed_by varchar(100) DEFAULT NULL,
            is_simulation tinyint(1) DEFAULT 0,
            created_at datetime DEFAULT CURRENT_TIMESTAMP,
            confirmed_at datetime DEFAULT NULL,
            PRIMARY KEY (id),
            UNIQUE KEY confirm_token (confirm_token),
            KEY order_id (order_id)
        ) $charset;";
        require_once ABSPATH . 'wp-admin/includes/upgrade.php';
        dbDelta( $sql_teams );
        // Garantir colunas partner também
        $partner_cols = $wpdb->get_col("SHOW COLUMNS FROM {$wpdb->prefix}vm2_partners");
        if ( !in_array('wc_categories', $partner_cols) ) {
            $wpdb->query("ALTER TABLE {$wpdb->prefix}vm2_partners ADD COLUMN wc_categories text DEFAULT NULL");
        }
        if ( !in_array('wc_tags', $partner_cols) ) {
            $wpdb->query("ALTER TABLE {$wpdb->prefix}vm2_partners ADD COLUMN wc_tags text DEFAULT NULL");
        }
        update_option('vm2_elenco_tables_v1', '1');
    }
});

// ─────────────────────────────────────────────────────────────
// CONTATOS UNIFICADOS — vm2_contacts
// ─────────────────────────────────────────────────────────────
function vm2_create_contacts_table() {
    global $wpdb;
    $charset = $wpdb->get_charset_collate();
    $t = $wpdb->prefix . 'vm2_contacts';
    // Criar tabela se não existir
    $wpdb->query( "CREATE TABLE IF NOT EXISTS $t (
        id              bigint(20) NOT NULL AUTO_INCREMENT,
        phone           varchar(20) NOT NULL DEFAULT '',
        name            varchar(255) NOT NULL DEFAULT '',
        email           varchar(100) NOT NULL DEFAULT '',
        origens         text NOT NULL,
        kommo_lead_id   bigint(20) DEFAULT NULL,
        kommo_status_id bigint(20) DEFAULT NULL,
        data_evento     varchar(20) NOT NULL DEFAULT '',
        tipo_evento     varchar(100) NOT NULL DEFAULT '',
        cart_product    varchar(500) NOT NULL DEFAULT '',
        galeria_atracao varchar(255) NOT NULL DEFAULT '',
        score           int NOT NULL DEFAULT 0,
        utm_source      varchar(255) NOT NULL DEFAULT '',
        utm_medium      varchar(255) NOT NULL DEFAULT '',
        utm_campaign    varchar(255) NOT NULL DEFAULT '',
        utm_term        varchar(255) NOT NULL DEFAULT '',
        utm_content     varchar(255) NOT NULL DEFAULT '',
        last_activity   datetime DEFAULT NULL,
        created_at      datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
        updated_at      datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
        PRIMARY KEY (id),
        UNIQUE KEY uq_phone (phone),
        KEY idx_last_activity (last_activity)
    ) $charset" );
}
add_action('plugins_loaded', function() {
    if ( !get_option('vm2_contacts_table_v2') ) {
        vm2_create_contacts_table();
        update_option('vm2_contacts_table_v2', '1');
    }
    // [v1.5.76] Migration defensiva: adiciona colunas UTM se não existirem
    if ( !get_option('vm2_contacts_utm_cols_v1') ) {
        global $wpdb;
        $t = $wpdb->prefix . 'vm2_contacts';
        if ($wpdb->get_var("SHOW TABLES LIKE '$t'") === $t) {
            $cols = $wpdb->get_col("SHOW COLUMNS FROM $t");
            foreach (['utm_source','utm_medium','utm_campaign','utm_term','utm_content'] as $uc) {
                if (!in_array($uc, $cols)) {
                    $wpdb->query("ALTER TABLE $t ADD COLUMN $uc varchar(255) NOT NULL DEFAULT ''");
                }
            }
            update_option('vm2_contacts_utm_cols_v1', '1');
        }
    }
}, 20);

function vm2_sync_contacts() {
    global $wpdb;
    // Garante que a tabela existe (funciona tanto em admin quanto em REST)
    vm2_create_contacts_table();
    $table = $wpdb->prefix . 'vm2_contacts';
    $merged = [];

    // ── Source 1: Kommo leads ──
    $rows = $wpdb->get_results(
        "SELECT phone, name, data_evento, status_id, kommo_id, last_synced
         FROM {$wpdb->prefix}vm_kommo_leads
         WHERE phone != ''
         ORDER BY last_synced DESC LIMIT 10000"
    );
    foreach ($rows as $r) {
        $p = vm2_normalize_phone($r->phone);
        if (!$p) continue;
        if (!isset($merged[$p])) {
            $merged[$p] = [
                'phone' => $p, 'name' => $r->name ?? '', 'email' => '',
                'origens' => ['kommo'],
                'kommo_lead_id' => $r->kommo_id,
                'kommo_status_id' => $r->status_id,
                'data_evento' => $r->data_evento ?? '',
                'cart_product' => '', 'galeria_atracao' => '',
                'last_activity' => $r->last_synced,
            ];
        } else {
            if (!in_array('kommo', $merged[$p]['origens'])) $merged[$p]['origens'][] = 'kommo';
            if (empty($merged[$p]['name'])) $merged[$p]['name'] = $r->name ?? '';
            if (empty($merged[$p]['kommo_lead_id'])) {
                $merged[$p]['kommo_lead_id'] = $r->kommo_id;
                $merged[$p]['kommo_status_id'] = $r->status_id;
            }
        }
    }

    // ── Source 2: Galeria tokens ──
    $rows = $wpdb->get_results(
        "SELECT t.whatsapp, a.nome AS atracao_nome, t.created_at
         FROM {$wpdb->prefix}vmgal_tokens t
         LEFT JOIN {$wpdb->prefix}vmgal_atracoes a ON FIND_IN_SET(a.id, t.atracao_ids)
         WHERE t.whatsapp IS NOT NULL AND t.whatsapp != ''
         ORDER BY t.created_at DESC LIMIT 1000"
    );
    foreach ($rows as $r) {
        $p = vm2_normalize_phone($r->whatsapp);
        if (!$p) continue;
        if (!isset($merged[$p])) {
            $merged[$p] = [
                'phone' => $p, 'name' => '', 'email' => '',
                'origens' => ['galeria'],
                'kommo_lead_id' => null, 'kommo_status_id' => null,
                'data_evento' => '', 'cart_product' => '',
                'galeria_atracao' => $r->atracao_nome ?? '',
                'last_activity' => $r->created_at,
            ];
        } else {
            if (!in_array('galeria', $merged[$p]['origens'])) $merged[$p]['origens'][] = 'galeria';
            if (empty($merged[$p]['galeria_atracao'])) $merged[$p]['galeria_atracao'] = $r->atracao_nome ?? '';
            if (empty($merged[$p]['last_activity']) || strtotime($r->created_at) > strtotime($merged[$p]['last_activity']))
                $merged[$p]['last_activity'] = $r->created_at;
        }
    }

    // ── Source 3: WA Captures (popup/carrinho) ──
    $rows = $wpdb->get_results(
        "SELECT phone, product_name, captured_at
         FROM {$wpdb->prefix}vm_wa_captures
         WHERE phone != ''
         ORDER BY captured_at DESC LIMIT 5000"
    );
    foreach ($rows as $r) {
        $p = vm2_normalize_phone($r->phone);
        if (!$p) continue;
        if (!isset($merged[$p])) {
            $merged[$p] = [
                'phone' => $p, 'name' => '', 'email' => '',
                'origens' => ['carrinho'],
                'kommo_lead_id' => null, 'kommo_status_id' => null,
                'data_evento' => '',
                'cart_product' => $r->product_name ?? '',
                'galeria_atracao' => '',
                'last_activity' => $r->captured_at,
            ];
        } else {
            if (!in_array('carrinho', $merged[$p]['origens'])) $merged[$p]['origens'][] = 'carrinho';
            if (empty($merged[$p]['cart_product'])) $merged[$p]['cart_product'] = $r->product_name ?? '';
        }
    }

    // ── Source 4: Pedidos WooCommerce (HPOS) ──
    $wc_tbl = $wpdb->prefix . 'wc_orders';
    if ($wpdb->get_var("SHOW TABLES LIKE '$wc_tbl'") === $wc_tbl) {
        $wc_rows = $wpdb->get_results(
            "SELECT billing_phone, billing_first_name, billing_last_name, billing_email, date_created_gmt
             FROM {$wc_tbl}
             WHERE billing_phone != '' AND type = 'shop_order'
             ORDER BY date_created_gmt DESC LIMIT 2000"
        );
        foreach ($wc_rows as $r) {
            $p = vm2_normalize_phone($r->billing_phone);
            if (!$p) continue;
            $full_name = trim(($r->billing_first_name ?? '') . ' ' . ($r->billing_last_name ?? ''));
            $activity  = $r->date_created_gmt ?? null;
            if (!isset($merged[$p])) {
                $merged[$p] = [
                    'phone' => $p,
                    'name'  => $full_name,
                    'email' => $r->billing_email ?? '',
                    'origens' => ['pedido'],
                    'kommo_lead_id' => null, 'kommo_status_id' => null,
                    'data_evento' => '', 'cart_product' => '', 'galeria_atracao' => '',
                    'last_activity' => $activity,
                ];
            } else {
                if (!in_array('pedido', $merged[$p]['origens'])) $merged[$p]['origens'][] = 'pedido';
                if (empty($merged[$p]['name'])) $merged[$p]['name'] = $full_name;
                if (empty($merged[$p]['email'])) $merged[$p]['email'] = $r->billing_email ?? '';
            }
        }
    }


    // ── Source 5: V1 CRM Contacts (vm_crm_contacts) ──
    $v1_tbl = $wpdb->prefix . 'vm_crm_contacts';
    if ($wpdb->get_var("SHOW TABLES LIKE '$v1_tbl'") === $v1_tbl) {
        $v1_rows = $wpdb->get_results(
            "SELECT phone, name, email, created_at
             FROM {$wpdb->prefix}vm_crm_contacts
             WHERE phone != '' AND opt_out = 0
             ORDER BY created_at DESC LIMIT 10000"
        );
        foreach ($v1_rows as $r) {
            $p = vm2_normalize_phone($r->phone);
            if (!$p) continue;
            if (!isset($merged[$p])) {
                $merged[$p] = [
                    'phone'          => $p,
                    'name'           => $r->name ?? '',
                    'email'          => $r->email ?? '',
                    'origens'        => ['crm_v1'],
                    'kommo_lead_id'  => null, 'kommo_status_id' => null,
                    'data_evento'    => '', 'cart_product' => '', 'galeria_atracao' => '',
                    'last_activity'  => $r->created_at,
                ];
            } else {
                if (!in_array('crm_v1', $merged[$p]['origens'])) $merged[$p]['origens'][] = 'crm_v1';
                if (empty($merged[$p]['name']))  $merged[$p]['name']  = $r->name ?? '';
                if (empty($merged[$p]['email'])) $merged[$p]['email'] = $r->email ?? '';
            }
        }
    }

    // ── Upsert into vm2_contacts ──
    $count_new = 0; $count_upd = 0;
    foreach ($merged as $p => $data) {
        $existing = $wpdb->get_row($wpdb->prepare(
            "SELECT id, origens, name FROM $table WHERE phone = %s", $p
        ));
        if ($existing) {
            $ex_origens  = json_decode($existing->origens, true) ?: [];
            $new_origens = array_values(array_unique(array_merge($ex_origens, $data['origens'] ?? [])));
            $upd = [
                'origens'         => wp_json_encode($new_origens),
                'kommo_lead_id'   => $data['kommo_lead_id'] ?? null,
                'kommo_status_id' => $data['kommo_status_id'] ?? null,
                'data_evento'     => $data['data_evento'] ?? '',
                'last_activity'   => $data['last_activity'] ?: null,
                'updated_at'      => current_time('mysql'),
            ];
            if (!empty($data['name']))           $upd['name']           = $data['name'];
            if (!empty($data['email']))           $upd['email']          = $data['email'];
            if (!empty($data['cart_product']))    $upd['cart_product']   = $data['cart_product'];
            if (!empty($data['galeria_atracao'])) $upd['galeria_atracao']= $data['galeria_atracao'];
            $wpdb->update($table, $upd, ['phone' => $p]);
            $count_upd++;
        } else {
            $wpdb->insert($table, [
                'phone'           => $p,
                'name'            => $data['name'] ?? '',
                'email'           => $data['email'] ?? '',
                'origens'         => wp_json_encode($data['origens'] ?? []),
                'kommo_lead_id'   => $data['kommo_lead_id'] ?? null,
                'kommo_status_id' => $data['kommo_status_id'] ?? null,
                'data_evento'     => $data['data_evento'] ?? '',
                'cart_product'    => $data['cart_product'] ?? '',
                'galeria_atracao' => $data['galeria_atracao'] ?? '',
                'last_activity'   => $data['last_activity'] ?: null,
            ]);
            $count_new++;
        }
    }

    update_option('vm2_contacts_last_sync', current_time('mysql'));
    return ['new' => $count_new, 'updated' => $count_upd, 'total' => count($merged)];
}

// Cron horário
add_action('vm2_contacts_cron', 'vm2_sync_contacts');
add_action('wp', function() {
    if (!wp_next_scheduled('vm2_contacts_cron'))
        wp_schedule_event(time(), 'hourly', 'vm2_contacts_cron');
});

// REST endpoint sync manual
add_filter('rest_api_init', function() {
    register_rest_route('vm-crm-v2/v1', '/contacts/sync', [
        'methods'             => 'POST',
        'callback'            => function() {
            if (!current_user_can('manage_options')) return new WP_Error('forbidden','Acesso negado',['status'=>403]);
            $result = vm2_sync_contacts();
            return rest_ensure_response(['ok' => true, 'result' => $result]);
        },
        'permission_callback' => '__return_true',
    ]);

    // [v1.5.86] Bulk import endpoint — importa lista de contatos via Bearer token
    register_rest_route('vm-crm-v2/v1', '/contacts/import', [
        'methods'             => 'POST',
        'callback'            => function(WP_REST_Request $req) {
            $auth = $req->get_header('authorization');
            if ($auth !== 'Bearer vm2fsync_9kqw3p7x')
                return new WP_Error('forbidden', 'Acesso negado', ['status' => 403]);
            global $wpdb;
            $table    = $wpdb->prefix . 'vm2_contacts';
            $contacts = $req->get_json_params();
            if (!is_array($contacts) || empty($contacts))
                return new WP_Error('bad_request', 'JSON array esperado', ['status' => 400]);
            $inserted = 0; $skipped = 0;
            foreach ($contacts as $c) {
                $phone = sanitize_text_field($c['phone'] ?? '');
                $name  = sanitize_text_field($c['name']  ?? '');
                if (!$phone) { $skipped++; continue; }
                $existing = $wpdb->get_var($wpdb->prepare(
                    "SELECT id FROM $table WHERE phone = %s", $phone
                ));
                if ($existing) { $skipped++; continue; }
                $wpdb->insert($table, [
                    'phone'         => $phone,
                    'name'          => $name,
                    'email'         => '',
                    'origens'       => wp_json_encode(['kommo_import']),
                    'last_activity' => current_time('mysql'),
                    'created_at'    => current_time('mysql'),
                    'updated_at'    => current_time('mysql'),
                ]);
                $inserted++;
            }
            return rest_ensure_response(['ok' => true, 'inserted' => $inserted, 'skipped' => $skipped]);
        },
        'permission_callback' => '__return_true',
    ]);
}, 20);



// ─────────────────────────────────────────────────────────────
// PARCEIROS — AJAX HANDLERS
// ─────────────────────────────────────────────────────────────
add_action('wp_ajax_vm2_save_partner', 'vm2_ajax_save_partner');
function vm2_ajax_save_partner() {
    check_ajax_referer('vm2_nonce', 'nonce');
    global $wpdb;
    $table = $wpdb->prefix . 'vm2_partners';
    $id    = intval($_POST['id'] ?? 0);
    $data  = [
        'name'        => sanitize_text_field($_POST['name'] ?? ''),
        'phone'       => preg_replace('/\D/', '', $_POST['phone'] ?? ''),
        'email'       => sanitize_email($_POST['email'] ?? ''),
        'atracao'     => sanitize_text_field($_POST['atracao'] ?? ''),
        'regiao'      => sanitize_text_field($_POST['regiao'] ?? ''),
        'cidade'      => sanitize_text_field($_POST['cidade'] ?? ''),
        'estado'      => sanitize_text_field($_POST['estado'] ?? ''),
        'status'      => sanitize_text_field($_POST['status'] ?? 'ativo'),
        'observacoes'   => sanitize_textarea_field($_POST['observacoes'] ?? ''),
        'wc_categories' => wp_json_encode( json_decode( stripslashes( $_POST['wc_categories'] ?? '[]' ), true ) ?: [] ),
        'wc_tags'       => wp_json_encode( json_decode( stripslashes( $_POST['wc_tags']       ?? '[]' ), true ) ?: [] ),
        'funcao'        => sanitize_text_field($_POST['funcao'] ?? 'outros'),
        'cache_valor'   => is_numeric($_POST['cache_valor'] ?? '') ? floatval($_POST['cache_valor']) : null,
        'cache_tipo'    => in_array($_POST['cache_tipo'] ?? 'reais', ['reais','porcentagem']) ? $_POST['cache_tipo'] : 'reais',
    ];
    if ($id) {
        $data['updated_at'] = current_time('mysql');
        $wpdb->update($table, $data, ['id' => $id]);
        wp_send_json_success(['id' => $id, 'action' => 'updated']);
    } else {
        $data['created_at'] = current_time('mysql');
        $wpdb->insert($table, $data);
        wp_send_json_success(['id' => $wpdb->insert_id, 'action' => 'created']);
    }
}

add_action('wp_ajax_vm2_delete_partner', 'vm2_ajax_delete_partner');
function vm2_ajax_delete_partner() {
    check_ajax_referer('vm2_nonce', 'nonce');
    global $wpdb;
    $id = intval($_POST['id'] ?? 0);
    if ($id) $wpdb->delete($wpdb->prefix . 'vm2_partners', ['id' => $id]);
    wp_send_json_success();
}

add_action('wp_ajax_vm2_approve_queue', 'vm2_ajax_approve_queue');
function vm2_ajax_approve_queue() {
    check_ajax_referer('vm2_nonce', 'nonce');
    global $wpdb;
    $id     = intval($_POST['id'] ?? 0);
    $action = sanitize_text_field($_POST['queue_action'] ?? 'approve');
    if ($action === 'approve') {
        $row = $wpdb->get_row($wpdb->prepare("SELECT * FROM {$wpdb->prefix}vm2_approval_queue WHERE id=%d", $id));
        if ($row && $row->phone) {
            // Enviar via Z-API
            $channel = get_option('vm2_parceiros_channel', 'zapi_7551');
            $channels = vm2_channels();
            if (isset($channels[$channel])) {
                $ch = $channels[$channel];
                $url = "https://api.z-api.io/instances/{$ch['instance']}/token/{$ch['token']}/send-text";
                wp_remote_post($url, [
                    'headers' => ['Content-Type'=>'application/json','Client-Token'=>VM2_ZAPI_CLIENT],
                    'body'    => json_encode(['phone'=>$row->phone, 'message'=>$row->message]),
                    'timeout' => 10,
                ]);
            }
        }
        $wpdb->update($wpdb->prefix . 'vm2_approval_queue', ['status'=>'aprovado','sent_at'=>current_time('mysql')], ['id'=>$id]);
        wp_send_json_success(['action'=>'approved']);
    } elseif ($action === 'cancel') {
        $wpdb->update($wpdb->prefix . 'vm2_approval_queue', ['status'=>'cancelado'], ['id'=>$id]);
        wp_send_json_success(['action'=>'cancelled']);
    } elseif ($action === 'edit') {
        $msg = sanitize_textarea_field($_POST['message'] ?? '');
        $wpdb->update($wpdb->prefix . 'vm2_approval_queue', ['message'=>$msg], ['id'=>$id]);
        wp_send_json_success();
    }
}

add_action('wp_ajax_vm2_create_matching_round', 'vm2_ajax_create_matching_round');
function vm2_ajax_create_matching_round() {
    check_ajax_referer('vm2_nonce', 'nonce');
    global $wpdb;
    $atracao   = sanitize_text_field($_POST['atracao'] ?? '');
    $event_date = sanitize_text_field($_POST['event_date'] ?? '');
    $order_id  = intval($_POST['order_id'] ?? 0);
    $msg_tpl   = sanitize_textarea_field($_POST['msg_template'] ?? '');

    // Buscar parceiros com essa atração e disponíveis na data
    $partners = $wpdb->get_results(
        $wpdb->prepare(
            "SELECT p.* FROM {$wpdb->prefix}vm2_partners p
             WHERE p.status='ativo' AND p.atracao LIKE %s
             AND p.id NOT IN (
                SELECT partner_id FROM {$wpdb->prefix}vm2_availability
                WHERE event_date=%s AND status='ocupado'
             ) LIMIT 20",
            '%' . $atracao . '%', $event_date
        )
    );

    $queued = 0;
    $channel = get_option('vm2_parceiros_channel', 'zapi_7551');
    foreach ($partners as $p) {
        if (!$p->phone) continue;
        $msg = str_replace(['{nome}','{data_evento}','{atracao}'], [$p->name, $event_date, $atracao], $msg_tpl);
        $wpdb->insert($wpdb->prefix . 'vm2_approval_queue', [
            'partner_id' => $p->id,
            'order_id'   => $order_id,
            'phone'      => $p->phone,
            'message'    => $msg,
            'tipo'       => 'convite',
            'priority'   => 'urgente',
            'status'     => 'pendente',
            'created_at' => current_time('mysql'),
        ]);
        $queued++;
    }
    wp_send_json_success(['queued' => $queued, 'partners' => count($partners)]);
}

// ─────────────────────────────────────────────────────────────
// PARCEIROS — PÁGINA PRINCIPAL
// ─────────────────────────────────────────────────────────────
function vm2_parceiros_page() {
    global $wpdb;
    $nonce      = wp_create_nonce('vm2_nonce');
    $tab        = sanitize_text_field($_GET['tab'] ?? 'cadastro');
    $base       = admin_url('admin.php');
    $tabs       = ['cadastro'=>'👥 Cadastro','matching'=>'🎯 Matching','eventos'=>'🎪 Eventos Ativos','fila'=>'📋 Fila de Aprovação','metricas'=>'📊 Métricas','elenco'=>'🎬 Elenco'];

    // ── Dados de cada tab ──
    $total_partners   = (int)$wpdb->get_var("SELECT COUNT(*) FROM {$wpdb->prefix}vm2_partners");
    $total_ativos     = (int)$wpdb->get_var("SELECT COUNT(*) FROM {$wpdb->prefix}vm2_partners WHERE status='ativo'");
    $fila_pendentes   = (int)$wpdb->get_var("SELECT COUNT(*) FROM {$wpdb->prefix}vm2_approval_queue WHERE status='pendente'");
    $fila_urgentes    = (int)$wpdb->get_var("SELECT COUNT(*) FROM {$wpdb->prefix}vm2_approval_queue WHERE status='pendente' AND priority='urgente'");

    // Parceiros cadastrados
    $search   = sanitize_text_field($_GET['s'] ?? '');
    $per_page = 20;
    $paged    = max(1, intval($_GET['paged'] ?? 1));
    $offset   = ($paged - 1) * $per_page;
    $where_s  = $search ? $wpdb->prepare("AND (name LIKE %s OR phone LIKE %s OR atracao LIKE %s)", "%$search%", "%$search%", "%$search%") : '';
    $partners = $wpdb->get_results("SELECT * FROM {$wpdb->prefix}vm2_partners WHERE 1=1 $where_s ORDER BY name ASC LIMIT $per_page OFFSET $offset");
    $total_filtered = (int)$wpdb->get_var("SELECT COUNT(*) FROM {$wpdb->prefix}vm2_partners WHERE 1=1 $where_s");

    // Fila de aprovação
    $queue = $wpdb->get_results("SELECT q.*, p.name as partner_name FROM {$wpdb->prefix}vm2_approval_queue q LEFT JOIN {$wpdb->prefix}vm2_partners p ON q.partner_id=p.id WHERE q.status='pendente' ORDER BY FIELD(q.priority,'urgente','normal','baixo'), q.created_at ASC LIMIT 50");

    // Métricas
    $top_partners = $wpdb->get_results("SELECT *, nps FROM {$wpdb->prefix}vm2_partners WHERE status='ativo' ORDER BY total_eventos DESC LIMIT 10");

    // Produtos WooCommerce para o select
    $wc_products = [];
    if (function_exists('wc_get_products')) {
        $prods = wc_get_products(['limit'=>50,'status'=>'publish']);
        foreach ($prods as $p) $wc_products[$p->get_id()] = $p->get_name();
    }

    // Stage labels para Eventos Ativos
    $stages = ['matching'=>'① Matching','convidado'=>'② Convite Enviado','confirmado'=>'③ Confirmado','equipe'=>'④ Equipe Formada','grupo'=>'⑤ Grupo WA','onboarding'=>'⑥ Onboarding','lembrete'=>'⑦ Lembrete','checkin'=>'⑧ Check-in','checkout'=>'⑨ Check-out','pagamento'=>'⑩ Pagamento'];

    // Eventos ativos com parceiros
    $eventos_ativos = $wpdb->get_results("SELECT pe.*, p.name as partner_name, p.phone as partner_phone FROM {$wpdb->prefix}vm2_partner_events pe LEFT JOIN {$wpdb->prefix}vm2_partners p ON pe.partner_id=p.id ORDER BY pe.event_date ASC LIMIT 20");

    echo '<div class="wrap vm2-wrap">';
    echo '<style>
    .vm2-wrap{max-width:1200px}
    .vm2-kpi-row{display:flex;gap:12px;flex-wrap:wrap;margin-bottom:20px}
    .vm2-kpi{background:#fff;border:1px solid #e0e0e0;border-radius:8px;padding:14px 18px;min-width:140px;flex:1;cursor:pointer;transition:all .15s ease}
    .vm2-kpi:hover{transform:translateY(-2px);box-shadow:0 4px 14px rgba(0,0,0,.12);border-color:#0073aa}
    .vm2-kpi .label{font-size:12px;color:#666;margin-bottom:4px}
    .vm2-kpi .value{font-size:26px;font-weight:700;color:#1d2327}
    .vm2-kpi .sub{font-size:11px;color:#888;margin-top:2px}
    .vm2-tabs{display:flex;gap:4px;flex-wrap:wrap;margin-bottom:20px;border-bottom:2px solid #e0e0e0;padding-bottom:0}
    .vm2-tab-btn{padding:10px 16px;border:none;background:none;cursor:pointer;font-size:13px;color:#555;border-bottom:3px solid transparent;margin-bottom:-2px;border-radius:4px 4px 0 0;transition:all .15s}
    .vm2-tab-btn:hover{background:#f0f0f0;color:#1d2327}
    .vm2-tab-btn.active{color:#7c3aed;border-bottom-color:#7c3aed;font-weight:600;background:#f9f4ff}
    .vm2-badge{display:inline-block;padding:2px 7px;border-radius:10px;font-size:11px;font-weight:700;margin-left:4px}
    .badge-red{background:#fee2e2;color:#dc2626}
    .badge-green{background:#dcfce7;color:#16a34a}
    .badge-purple{background:#ede9fe;color:#7c3aed}
    .badge-gray{background:#f1f5f9;color:#64748b}
    .vm2-card{background:#fff;border:1px solid #e0e0e0;border-radius:8px;padding:18px;margin-bottom:16px}
    .vm2-card h3{margin:0 0 12px;font-size:15px;color:#1d2327}
    .vm2-split{display:grid;grid-template-columns:320px 1fr;gap:16px}
    @media(max-width:900px){.vm2-split{grid-template-columns:1fr}}
    .vm2-partner-list{border:1px solid #e0e0e0;border-radius:8px;overflow:hidden;background:#fff}
    .vm2-partner-item{display:flex;align-items:center;gap:10px;padding:10px 14px;border-bottom:1px solid #f0f0f0;cursor:pointer;transition:background .1s}
    .vm2-partner-item:hover{background:#f9f4ff}
    .vm2-partner-item.selected{background:#f9f4ff;border-left:3px solid #7c3aed}
    .vm2-partner-avatar{width:36px;height:36px;border-radius:50%;background:linear-gradient(135deg,#7c3aed,#a855f7);color:#fff;display:flex;align-items:center;justify-content:center;font-weight:700;font-size:14px;flex-shrink:0}
    .vm2-partner-info .name{font-weight:600;font-size:13px;color:#1d2327}
    .vm2-partner-info .sub{font-size:11px;color:#888;margin-top:1px}
    .vm2-detail-panel{background:#fff;border:1px solid #e0e0e0;border-radius:8px;padding:20px}
    .vm2-form-row{display:grid;grid-template-columns:1fr 1fr;gap:12px;margin-bottom:12px}
    @media(max-width:600px){.vm2-form-row{grid-template-columns:1fr}}
    .vm2-form-row label{display:block;font-size:12px;font-weight:600;color:#555;margin-bottom:4px}
    .vm2-form-row input,.vm2-form-row select,.vm2-form-row textarea{width:100%;padding:7px 10px;border:1px solid #ddd;border-radius:6px;font-size:13px;box-sizing:border-box}
    .vm2-btn{display:inline-flex;align-items:center;gap:6px;padding:8px 16px;border-radius:6px;border:none;cursor:pointer;font-size:13px;font-weight:600;transition:all .15s}
    .vm2-btn-primary{background:#7c3aed;color:#fff}
    .vm2-btn-primary:hover{background:#6d28d9}
    .vm2-btn-success{background:#16a34a;color:#fff}
    .vm2-btn-danger{background:#dc2626;color:#fff}
    .vm2-btn-gray{background:#f1f5f9;color:#374151;border:1px solid #e0e0e0}
    .vm2-btn-gray:hover{background:#e5e7eb}
    .vm2-btn-sm{padding:5px 10px;font-size:12px}
    .vm2-table{width:100%;border-collapse:collapse;font-size:13px}
    .vm2-table th{text-align:left;padding:8px 10px;background:#f9fafb;border-bottom:2px solid #e0e0e0;font-size:12px;color:#6b7280;font-weight:600}
    .vm2-table td{padding:8px 10px;border-bottom:1px solid #f0f0f0;vertical-align:middle}
    .vm2-table tr:hover td{background:#fafafa}
    .vm2-queue-item{background:#fff;border:1px solid #e0e0e0;border-radius:10px;padding:14px;margin-bottom:10px;position:relative}
    .vm2-queue-item .header{display:flex;align-items:center;justify-content:space-between;margin-bottom:8px}
    .vm2-queue-item .bubble{background:#f0fdf4;border:1px solid #bbf7d0;border-radius:12px 12px 12px 0;padding:10px 14px;white-space:pre-wrap;font-size:13px;color:#1d2327;line-height:1.5;max-height:120px;overflow:auto}
    .vm2-queue-item .actions{display:flex;gap:6px;margin-top:8px;flex-wrap:wrap}
    .vm2-priority-urgente{border-left:4px solid #dc2626}
    .vm2-priority-normal{border-left:4px solid #f59e0b}
    .vm2-priority-baixo{border-left:4px solid #22c55e}
    .vm2-lifecycle-bar{display:flex;gap:2px;align-items:center;flex-wrap:wrap;margin-top:6px}
    .vm2-stage-dot{width:24px;height:24px;border-radius:50%;background:#e5e7eb;display:flex;align-items:center;justify-content:center;font-size:9px;font-weight:700;color:#6b7280;cursor:default;flex-shrink:0}
    .vm2-stage-dot.done{background:#7c3aed;color:#fff}
    .vm2-stage-dot.current{background:#f59e0b;color:#fff;box-shadow:0 0 0 3px #fef3c7}
    .vm2-matching-card{background:#f9f4ff;border:1px solid #ddd6fe;border-radius:10px;padding:16px;margin-bottom:12px}
    .vm2-matching-card .title{font-weight:700;font-size:15px;margin-bottom:8px;color:#5b21b6}
    .vm2-empty-state{text-align:center;padding:48px 20px;color:#9ca3af}
    .vm2-empty-state .icon{font-size:48px;margin-bottom:12px}
    .vm2-empty-state p{font-size:14px;margin-bottom:16px}
    </style>';

    // Header + KPIs
    echo '<div style="display:flex;align-items:center;justify-content:space-between;flex-wrap:wrap;gap:8px;margin-bottom:16px">
        <h1 style="margin:0;font-size:22px">🎭 Parceiros & Artistas</h1>
        <div style="display:flex;gap:8px">
            <button class="vm2-btn vm2-btn-primary" onclick="vm2OpenModal(0)">+ Novo Parceiro</button>
        </div>
    </div>';

    echo '<div class="vm2-kpi-row">
        <div class="vm2-kpi" onclick="location.href=\'?page=vm2-parceiros&tab=cadastro\'"><div class="label">Total Parceiros</div><div class="value">' . $total_partners . '</div><div class="sub">cadastrados</div></div>
        <div class="vm2-kpi" onclick="location.href=\'?page=vm2-parceiros&tab=cadastro\'"><div class="label">🟢 Ativos</div><div class="value">' . $total_ativos . '</div><div class="sub">disponíveis</div></div>
        <div class="vm2-kpi" onclick="location.href=\'?page=vm2-parceiros&tab=fila\'"><div class="label">📋 Fila Aprovação</div><div class="value">' . $fila_pendentes . '</div><div class="sub">' . ($fila_urgentes ? "<span style='color:#dc2626'>⚡ $fila_urgentes urgentes</span>" : 'pendentes') . '</div></div>
        <div class="vm2-kpi" onclick="location.href=\'?page=vm2-parceiros&tab=eventos\'"><div class="label">🎪 Eventos Ativos</div><div class="value">' . count($eventos_ativos) . '</div><div class="sub">em andamento</div></div>
    </div>';

    // Tabs
    echo '<div class="vm2-tabs">';
    foreach ($tabs as $tk => $tl) {
        $url    = add_query_arg(['page'=>'vm2-parceiros','tab'=>$tk], $base);
        $active = ($tab === $tk) ? ' active' : '';
        $badge  = '';
        if ($tk === 'fila' && $fila_pendentes > 0) {
            $cls   = $fila_urgentes > 0 ? 'badge-red' : 'badge-purple';
            $badge = '<span class="vm2-badge '.$cls.'">' . ($fila_urgentes ?: $fila_pendentes) . '</span>';
        }
        echo "<a href='$url' class='vm2-tab-btn$active'>$tl$badge</a>";
    }
    echo '</div>';

    // ── TAB: CADASTRO ──
    if ($tab === 'cadastro') {
        $sel_id = intval($_GET['partner_id'] ?? 0);
        $sel_partner = $sel_id ? $wpdb->get_row($wpdb->prepare("SELECT * FROM {$wpdb->prefix}vm2_partners WHERE id=%d", $sel_id)) : null;

        echo '<div style="display:flex;gap:10px;align-items:center;margin-bottom:14px;flex-wrap:wrap">';
        $su = add_query_arg(['page'=>'vm2-parceiros','tab'=>'cadastro','s'=>''], $base);
        echo '<form method="get" style="display:flex;gap:8px;flex:1">';
        echo '<input type="hidden" name="page" value="vm2-parceiros"><input type="hidden" name="tab" value="cadastro">';
        echo '<input type="search" name="s" value="' . esc_attr($search) . '" placeholder="🔍 Buscar por nome, phone ou atração..." style="flex:1;padding:7px 12px;border:1px solid #ddd;border-radius:6px;font-size:13px">';
        echo '<button type="submit" class="vm2-btn vm2-btn-gray">Buscar</button>';
        if ($search) echo '<a href="' . add_query_arg(['page'=>'vm2-parceiros','tab'=>'cadastro'], $base) . '" class="vm2-btn vm2-btn-gray">✕ Limpar</a>';
        echo '</form></div>';

        if ($total_partners === 0) {
            echo '<div class="vm2-empty-state">
                <div class="icon">🎭</div>
                <p>Nenhum parceiro cadastrado ainda.<br>Clique em <strong>+ Novo Parceiro</strong> para começar!</p>
            </div>';
        } else {
            echo '<div class="vm2-split">';
            // Lista
            echo '<div>';
            echo '<div class="vm2-partner-list">';
            foreach ($partners as $p) {
                $initial = mb_strtoupper(mb_substr($p->name, 0, 1));
                $purl    = add_query_arg(['page'=>'vm2-parceiros','tab'=>'cadastro','partner_id'=>$p->id], $base);
                $cls     = ($p->id == $sel_id) ? ' selected' : '';
                $status_badge = $p->status === 'ativo' ? '<span class="vm2-badge badge-green">ativo</span>' : '<span class="vm2-badge badge-gray">' . esc_html($p->status) . '</span>';
                $nps_str = $p->nps ? '⭐ ' . number_format($p->nps,1) : '';
                echo "<a href='$purl' style='text-decoration:none;color:inherit'><div class='vm2-partner-item$cls'>
                    <div class='vm2-partner-avatar'>$initial</div>
                    <div class='vm2-partner-info' style='flex:1;min-width:0'>
                        <div class='name'>" . esc_html($p->name) . " $status_badge</div>
                        <div class='sub'>" . esc_html($p->atracao ?: '—') . " · " . esc_html($p->cidade ?: $p->regiao ?: '—') . " $nps_str</div>
                    </div>
                    <div style='font-size:11px;color:#aaa;white-space:nowrap'>" . $p->total_eventos . " ev.</div>
                </div></a>";
            }
            echo '</div>';
            // Paginação
            $total_pages = ceil($total_filtered / $per_page);
            if ($total_pages > 1) {
                echo '<div style="display:flex;justify-content:center;gap:4px;margin-top:10px;flex-wrap:wrap">';
                for ($i=1; $i<=$total_pages; $i++) {
                    $pu = add_query_arg(['page'=>'vm2-parceiros','tab'=>'cadastro','paged'=>$i,'s'=>$search], $base);
                    $active_p = ($i == $paged) ? 'background:#7c3aed;color:#fff;' : 'background:#f1f5f9;color:#374151;';
                    echo "<a href='$pu' style='{$active_p}padding:5px 10px;border-radius:5px;font-size:12px;text-decoration:none'>$i</a>";
                }
                echo '</div>';
            }
            echo '</div>'; // end lista col

            // Detalhe / Form
            echo '<div>';
            if ($sel_partner) {
                // Mostrar ficha do parceiro selecionado
                echo '<div class="vm2-detail-panel">';
                echo '<div style="display:flex;align-items:center;justify-content:space-between;margin-bottom:16px;flex-wrap:wrap;gap:8px">';
                echo '<div style="display:flex;align-items:center;gap:12px">';
                $initial = mb_strtoupper(mb_substr($sel_partner->name, 0, 1));
                echo "<div class='vm2-partner-avatar' style='width:48px;height:48px;font-size:20px'>$initial</div>";
                echo '<div><div style="font-size:18px;font-weight:700">' . esc_html($sel_partner->name) . '</div>';
                echo '<div style="font-size:12px;color:#888">' . esc_html($sel_partner->atracao ?: '—') . '</div></div>';
                echo '</div>';
                echo '<div style="display:flex;gap:6px;flex-wrap:wrap">';
                if ($sel_partner->phone) {
                    echo '<a href="https://wa.me/' . $sel_partner->phone . '" target="_blank" class="vm2-btn vm2-btn-success vm2-btn-sm">💬 WhatsApp</a>';
                }
                echo '<button class="vm2-btn vm2-btn-primary vm2-btn-sm" onclick="vm2OpenModal(' . $sel_partner->id . ')">✏️ Editar</button>';
                echo '<button class="vm2-btn vm2-btn-danger vm2-btn-sm" onclick="vm2DeletePartner(' . $sel_partner->id . ')">🗑️ Excluir</button>';
                echo '</div></div>';

                // Info grid
                echo '<div class="vm2-cfg-2col" style="display:grid;grid-template-columns:1fr 1fr;gap:12px;margin-bottom:16px">';
                $funcao_labels = ['artista'=>'🎤 Artista','coordenador'=>'🎯 Coordenador','outros'=>'👤 Outros'];
                $funcao_display = $funcao_labels[$sel_partner->funcao ?? 'outros'] ?? '👤 Outros';
                $cache_display = '—';
                if (!empty($sel_partner->cache_valor) && $sel_partner->cache_valor > 0) {
                    $cache_display = ($sel_partner->cache_tipo === 'porcentagem')
                        ? number_format($sel_partner->cache_valor,1,',','.') . '%'
                        : 'R$ ' . number_format($sel_partner->cache_valor,2,',','.');
                }
                $fields = [
                    ['📱 WhatsApp', $sel_partner->phone],
                    ['📧 Email', $sel_partner->email],
                    ['🎪 Atrações', $sel_partner->atracao],
                    ['📍 Região', $sel_partner->regiao],
                    ['🏙️ Cidade', $sel_partner->cidade . ($sel_partner->estado ? '/' . $sel_partner->estado : '')],
                    ['⭐ NPS', $sel_partner->nps ? number_format($sel_partner->nps,1) : '—'],
                    ['🎭 Eventos', $sel_partner->total_eventos],
                    ['🔴🟢 Status', $sel_partner->status],
                    ['🎭 Função', $funcao_display],
                    ['💰 Cachê', $cache_display],
                ];
                foreach ($fields as [$label, $val]) {
                    echo '<div style="background:#f9fafb;border-radius:6px;padding:10px">
                        <div style="font-size:11px;color:#666;font-weight:600;margin-bottom:2px">' . $label . '</div>
                        <div style="font-size:13px;color:#1d2327">' . esc_html($val ?: '—') . '</div>
                    </div>';
                }
                echo '</div>';

                if ($sel_partner->observacoes) {
                    echo '<div style="background:#fff9e6;border:1px solid #fde68a;border-radius:6px;padding:10px;font-size:13px">
                        <strong>📝 Obs:</strong> ' . nl2br(esc_html($sel_partner->observacoes)) . '</div>';
                }

                // Últimos eventos do parceiro
                $pevents = $wpdb->get_results($wpdb->prepare("SELECT * FROM {$wpdb->prefix}vm2_partner_events WHERE partner_id=%d ORDER BY created_at DESC LIMIT 5", $sel_partner->id));
                if ($pevents) {
                    echo '<div style="margin-top:16px"><div style="font-size:13px;font-weight:600;margin-bottom:8px;color:#555">📅 Histórico de Eventos</div>';
                    foreach ($pevents as $ev) {
                        $stage_label = $stages[$ev->stage] ?? $ev->stage;
                        echo '<div style="display:flex;align-items:center;gap:8px;padding:6px 0;border-bottom:1px solid #f0f0f0;font-size:12px">
                            <span style="color:#7c3aed">◉</span>
                            <span>' . esc_html($ev->event_date ?: '—') . '</span>
                            <span class="vm2-badge badge-purple">' . esc_html($stage_label) . '</span>
                            ' . ($ev->order_id ? '<a href="' . admin_url('post.php?post=' . $ev->order_id . '&action=edit') . '" target="_blank" style="font-size:11px;color:#7c3aed">#' . $ev->order_id . '</a>' : '') . '
                        </div>';
                    }
                    echo '</div>';
                } else {
                    echo '<div style="margin-top:12px;font-size:12px;color:#aaa">Nenhum evento registrado ainda.</div>';
                }

                echo '</div>'; // detail panel
            } else {
                // Nenhum parceiro selecionado
                echo '<div class="vm2-detail-panel" style="display:flex;align-items:center;justify-content:center;min-height:300px">
                    <div class="vm2-empty-state">
                        <div class="icon">👆</div>
                        <p>Selecione um parceiro na lista para ver a ficha completa</p>
                        <button class="vm2-btn vm2-btn-primary" onclick="vm2OpenModal(0)">+ Cadastrar Novo Parceiro</button>
                    </div>
                </div>';
            }
            echo '</div>'; // detail col
            echo '</div>'; // split
        }
    }

    // ── TAB: MATCHING ──
    elseif ($tab === 'matching') {
        echo '<div class="vm2-matching-card">
            <div class="title">🎯 Nova Rodada de Matching</div>
            <p style="font-size:13px;color:#555;margin-bottom:12px">Sistema iFood-style: informe a atração e data do evento, selecione os parceiros disponíveis e crie os convites para a Fila de Aprovação.</p>
            <div class="vm2-form-row">
                <div><label>🎪 Atração</label><input type="text" id="match_atracao" placeholder="Ex: DJ, Mágico, Buffet..." style="width:100%;padding:8px;border:1px solid #ddd;border-radius:6px;font-size:13px"></div>
                <div><label>📅 Data do Evento</label><input type="date" id="match_date" style="width:100%;padding:8px;border:1px solid #ddd;border-radius:6px;font-size:13px"></div>
            </div>
            <div class="vm2-form-row">
                <div><label>🛒 Pedido (opcional)</label><input type="number" id="match_order" placeholder="ID do pedido WooCommerce" style="width:100%;padding:8px;border:1px solid #ddd;border-radius:6px;font-size:13px"></div>
                <div></div>
            </div>
            <div style="margin-bottom:12px">
                <label style="font-size:12px;font-weight:600;color:#555;display:block;margin-bottom:4px">📝 Mensagem do Convite</label>
                <textarea id="match_msg" rows="4" style="width:100%;padding:8px;border:1px solid #ddd;border-radius:6px;font-size:13px;resize:vertical">Olá {nome}! 👋

Temos um evento em {data_evento} que combina com você.
Atração: {atracao}

Você tem disponibilidade? Responda SIM para confirmar interesse! 🎉</textarea>
            </div>
            <div style="display:flex;gap:8px;align-items:center;flex-wrap:wrap">
                <button class="vm2-btn vm2-btn-primary" onclick="vm2CreateRound()">🚀 Criar Rodada de Matching</button>
                <span style="font-size:12px;color:#888">As mensagens vão para a Fila de Aprovação antes de serem enviadas</span>
            </div>
            <div id="match_result" style="margin-top:12px"></div>
        </div>';

        // Parceiros disponíveis
        echo '<div class="vm2-card"><h3>👥 Parceiros Cadastrados (' . $total_ativos . ' ativos)</h3>';
        if ($total_partners === 0) {
            echo '<div class="vm2-empty-state"><div class="icon">🎭</div><p>Cadastre parceiros primeiro para criar rodadas de matching</p></div>';
        } else {
            echo '<div style="overflow-x:auto">';
            echo '<table class="vm2-table"><thead><tr><th>Nome</th><th>Atrações</th><th>Região</th><th>Status</th><th>Eventos</th><th>NPS</th></tr></thead><tbody>';
            $all_p = $wpdb->get_results("SELECT * FROM {$wpdb->prefix}vm2_partners ORDER BY total_eventos DESC LIMIT 30");
            foreach ($all_p as $p) {
                $sc = $p->status === 'ativo' ? '#16a34a' : '#6b7280';
                echo '<tr>
                    <td><strong>' . esc_html($p->name) . '</strong><br><span style="font-size:11px;color:#888">' . esc_html($p->phone ?: '—') . '</span></td>
                    <td style="font-size:12px">' . esc_html($p->atracao ?: '—') . '</td>
                    <td style="font-size:12px">' . esc_html($p->cidade ?: $p->regiao ?: '—') . '</td>
                    <td><span style="color:' . $sc . ';font-weight:600;font-size:12px">●</span> ' . esc_html($p->status) . '</td>
                    <td style="text-align:center">' . $p->total_eventos . '</td>
                    <td>' . ($p->nps ? '⭐ ' . number_format($p->nps,1) : '—') . '</td>
                </tr>';
            }
            echo '</tbody></table></div>'; // fecha overflow-x
        }
        echo '</div>';
    }

    // ── TAB: EVENTOS ATIVOS ──
    elseif ($tab === 'eventos') {
        $stage_idx = array_keys($stages);
        echo '<div class="vm2-card"><h3>🎪 Eventos em Andamento</h3>';
        if (empty($eventos_ativos)) {
            echo '<div class="vm2-empty-state"><div class="icon">🎪</div><p>Nenhum evento com parceiros em andamento.<br>Use o Matching para iniciar o ciclo de vida.</p></div>';
        } else {
            foreach ($eventos_ativos as $ev) {
                $cur_idx  = array_search($ev->stage, $stage_idx);
                if ($cur_idx === false) $cur_idx = 0;
                $pct      = round(($cur_idx / (count($stages)-1)) * 100);
                $order_link = $ev->order_id ? '<a href="' . admin_url('post.php?post=' . $ev->order_id . '&action=edit') . '" target="_blank" style="color:#7c3aed;text-decoration:none">#' . $ev->order_id . '</a>' : '—';
                echo '<div class="vm2-card" style="margin-bottom:12px;border-left:4px solid #7c3aed">
                    <div style="display:flex;justify-content:space-between;align-items:flex-start;flex-wrap:wrap;gap:8px;margin-bottom:10px">
                        <div>
                            <div style="font-weight:700;font-size:14px">' . esc_html($ev->partner_name ?: 'Parceiro #' . $ev->partner_id) . '</div>
                            <div style="font-size:12px;color:#888">Evento: ' . esc_html($ev->event_date ?: '—') . ' · Pedido: ' . $order_link . '</div>
                        </div>
                        <span class="vm2-badge badge-purple">' . esc_html($stages[$ev->stage] ?? $ev->stage) . '</span>
                    </div>
                    <div style="background:#e9d5ff;border-radius:4px;height:6px;margin-bottom:8px"><div style="width:' . $pct . '%;background:#7c3aed;height:6px;border-radius:4px"></div></div>
                    <div class="vm2-lifecycle-bar">';
                foreach ($stage_idx as $i => $sk) {
                    $cls = $i < $cur_idx ? 'done' : ($i == $cur_idx ? 'current' : '');
                    $num = $i + 1;
                    echo '<div class="vm2-stage-dot ' . $cls . '" title="' . esc_attr($stages[$sk]) . '">' . $num . '</div>';
                    if ($i < count($stage_idx)-1) echo '<div style="width:8px;height:2px;background:' . ($i < $cur_idx ? '#7c3aed' : '#e5e7eb') . '"></div>';
                }
                echo '</div>';
                // Advance stage button
                if ($cur_idx < count($stage_idx)-1) {
                    $next_stage = $stage_idx[$cur_idx + 1];
                    $next_label = $stages[$next_stage];
                    $ns_js = esc_js($next_stage);
                    echo '<div style="margin-top:10px"><button class="vm2-btn vm2-btn-primary vm2-btn-sm" onclick="vm2AdvanceStage(' . $ev->id . ',\'' . $ns_js . '\')">→ Avançar para ' . esc_html($next_label) . '</button></div>';
                }
                echo '</div></div>';
            }
        }
        echo '</div>';
    }

    // ── TAB: FILA DE APROVAÇÃO ──
    elseif ($tab === 'fila') {
        echo '<div style="display:flex;align-items:center;justify-content:space-between;margin-bottom:16px;flex-wrap:wrap;gap:8px">';
        echo '<div>';
        echo '<span class="vm2-badge badge-red" style="font-size:13px;padding:4px 10px">' . $fila_urgentes . ' urgentes</span> ';
        echo '<span class="vm2-badge badge-purple" style="font-size:13px;padding:4px 10px">' . $fila_pendentes . ' pendentes total</span>';
        echo '</div>';
        if ($fila_urgentes > 0) {
            echo '<button class="vm2-btn vm2-btn-danger" onclick="vm2ApproveAllUrgent()">⚡ Aprovar Todos Urgentes</button>';
        }
        echo '</div>';

        if (empty($queue)) {
            echo '<div class="vm2-empty-state"><div class="icon">✅</div><p>Fila vazia — nenhuma mensagem pendente!</p></div>';
        } else {
            foreach ($queue as $item) {
                $priority_cls = 'vm2-priority-' . $item->priority;
                $priority_emoji = ['urgente'=>'🔴','normal'=>'🟡','baixo'=>'🟢'][$item->priority] ?? '⚪';
                $tipo_label = ['convite'=>'Convite','confirmacao'=>'Confirmação','lembrete'=>'Lembrete Pré-Evento','checkin'=>'Check-in','checkout'=>'Check-out','pagamento'=>'Pagamento','onboarding'=>'Onboarding'][$item->tipo] ?? $item->tipo;
                echo '<div class="vm2-queue-item ' . $priority_cls . '" id="qi_' . $item->id . '">
                    <div class="header">
                        <div>
                            <span style="font-weight:700">' . $priority_emoji . ' ' . esc_html($item->partner_name ?: 'Parceiro') . '</span>
                            <span class="vm2-badge badge-gray">' . esc_html($tipo_label) . '</span>
                            ' . ($item->phone ? '<span style="font-size:11px;color:#888">· 📱 +' . esc_html($item->phone) . '</span>' : '') . '
                        </div>
                        <span style="font-size:11px;color:#aaa">' . date('d/m H:i', strtotime($item->created_at)) . '</span>
                    </div>
                    <div class="bubble" id="bubble_' . $item->id . '">' . esc_html($item->message) . '</div>
                    <div class="actions">
                        <button class="vm2-btn vm2-btn-success vm2-btn-sm" onclick="vm2QueueAction(' . $item->id . ',\'approve\')">✅ Aprovar & Enviar</button>
                        <button class="vm2-btn vm2-btn-gray vm2-btn-sm" onclick="vm2EditBubble(' . $item->id . ')">✏️ Editar</button>
                        <button class="vm2-btn vm2-btn-danger vm2-btn-sm" onclick="vm2QueueAction(' . $item->id . ',\'cancel\')">✕ Cancelar</button>
                    </div>
                </div>';
            }
        }
    }

    // ── TAB: ELENCO ──
    elseif ($tab === 'elenco') {
        global $wpdb;
        $teams = $wpdb->get_results(
            "SELECT * FROM {$wpdb->prefix}vm2_teams ORDER BY created_at DESC LIMIT 50"
        );

        // WC categories for simulation
        $wc_cats_sim = get_terms(['taxonomy'=>'product_cat','hide_empty'=>false,'fields'=>'id=>name','number'=>200]);
        if (is_wp_error($wc_cats_sim)) $wc_cats_sim = [];
        $cats_sim_js = [];
        foreach ($wc_cats_sim as $tid => $tname) $cats_sim_js[] = ['id'=>$tid,'name'=>$tname];

        echo '<script>var vm2SimCats=' . wp_json_encode($cats_sim_js) . ';</script>';

        // Missing partners alert
        $missing_cats_all = [];
        foreach ($teams as $t) {
            $m = json_decode($t->missing_cats ?: '[]', true) ?: [];
            foreach ($m as $mc) {
                $mn = is_array($mc) ? $mc['name'] : $mc;
                $missing_cats_all[$mn] = ($missing_cats_all[$mn] ?? 0) + 1;
            }
        }
        if (!empty($missing_cats_all)) {
            echo '<div style="background:#fff5f5;border:1px solid #fca5a5;border-radius:10px;padding:14px 18px;margin-bottom:16px">';
            echo '<div style="font-weight:700;color:#dc2626;margin-bottom:6px">⚠️ Categorias sem parceiros cadastrados</div>';
            foreach ($missing_cats_all as $cat_name => $count) {
                echo '<div style="font-size:13px;color:#7f1d1d;margin-bottom:3px">• <strong>' . esc_html($cat_name) . '</strong> — apareceu ' . $count . 'x sem parceiro</div>';
            }
            echo '<div style="font-size:12px;color:#991b1b;margin-top:8px">👉 Cadastre parceiros na aba <a href="' . esc_url(add_query_arg(['page'=>'vm2-parceiros','tab'=>'cadastro'],$base)) . '" style="color:#7c3aed">🎭 Cadastro</a> e vincule as categorias WC a eles.</div>';
            echo '</div>';
        }

        // Simulate section
        echo '<div class="vm2-card" style="margin-bottom:20px">
            <h3 style="margin-bottom:14px;font-size:15px;font-weight:700">🧪 Simular Montagem de Equipe</h3>
            <p style="font-size:13px;color:#555;margin-bottom:14px">Teste o motor de elenco sem precisar criar um pedido real. A mensagem será enviada no WA com flag de simulação.</p>
            <div class="vm2-form-row" style="display:grid;grid-template-columns:1fr 1fr;gap:12px;margin-bottom:12px">
                <div><label style="font-size:12px;font-weight:600;color:#555;display:block;margin-bottom:4px">📅 Data do Evento</label>
                <input type="date" id="sim_date" style="width:100%;padding:8px;border:1px solid #ddd;border-radius:6px;font-size:13px"></div>
                <div><label style="font-size:12px;font-weight:600;color:#555;display:block;margin-bottom:4px">🎯 Categorias WC necessárias</label>
                <div id="sim_cats_wrap" style="border:1px solid #ddd;border-radius:6px;padding:8px;background:#fafafa;max-height:100px;overflow-y:auto;font-size:12px">Carregando...</div></div>
            </div>
            <button class="vm2-btn vm2-btn-primary" id="btn_simulate" onclick="vm2SimulateElenco()">🎬 Simular Montagem</button>
            <div id="sim_result" style="margin-top:14px;min-height:20px"></div>
        </div>';

        // Teams history table
        echo '<div class="vm2-card">
            <h3 style="margin-bottom:14px;font-size:15px;font-weight:700">📋 Histórico de Equipes</h3>';
        if (empty($teams)) {
            echo '<div class="vm2-empty-state"><div class="icon">🎬</div><p>Nenhuma equipe montada ainda.<br>Aguarde um pedido ser assinado ou use o simulador acima.</p></div>';
        } else {
            echo '<div style="overflow-x:auto"><table style="width:100%;border-collapse:collapse;font-size:13px">';
            echo '<thead><tr style="background:#f9fafb">';
            foreach (['Pedido','Data Evento','Cliente','Equipe','Faltou','Status','Criado','Link'] as $h) {
                echo '<th style="padding:8px 10px;text-align:left;border-bottom:1px solid #e5e7eb;white-space:nowrap;font-size:11px;font-weight:700;color:#555">' . $h . '</th>';
            }
            echo '</tr></thead><tbody>';
            foreach ($teams as $t) {
                $team_arr    = json_decode($t->team_json ?: '{}', true) ?: [];
                $missing_arr = json_decode($t->missing_cats ?: '[]', true) ?: [];
                $team_names  = implode(', ', array_map(function($x){ return $x['partner_name'] ?? '—'; }, $team_arr));
                $miss_names  = implode(', ', array_map(function($m){ return is_array($m) ? ($m['name']??'—') : $m; }, $missing_arr));
                $status_badge = $t->status === 'confirmed'
                    ? '<span class="vm2-badge badge-green">✅ Confirmado</span>'
                    : '<span class="vm2-badge badge-gray">⏳ Pendente</span>';
                $sim_badge   = $t->is_simulation ? '<span class="vm2-badge badge-purple">🧪 sim</span>' : '';
                $date_ev     = $t->event_date ? wp_date('d/m/Y', strtotime($t->event_date)) : '—';
                $created     = $t->created_at ? wp_date('d/m H:i', strtotime($t->created_at)) : '—';
                $order_lbl   = ($t->order_id && !$t->is_simulation) ? '#' . $t->order_id : '—';
                $link        = $t->confirm_token ? '<a href="' . esc_url(home_url('/elenco-vivamais/?token='.$t->confirm_token)) . '" target="_blank" style="color:#7c3aed;font-size:11px">🔗 Abrir</a>' : '—';

                echo '<tr style="border-bottom:1px solid #f0f0f0" onmouseover="this.style.background=\'#fafafa\'" onmouseout="this.style.background=\'#fff\'">';
                echo '<td style="padding:8px 10px">' . esc_html($order_lbl) . ' ' . $sim_badge . '</td>';
                echo '<td style="padding:8px 10px">' . esc_html($date_ev) . '</td>';
                echo '<td style="padding:8px 10px">' . esc_html($t->client_name ?: '—') . '</td>';
                echo '<td style="padding:8px 10px;max-width:180px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis">' . esc_html($team_names ?: '—') . '</td>';
                echo '<td style="padding:8px 10px;color:#dc2626">' . esc_html($miss_names ?: '—') . '</td>';
                echo '<td style="padding:8px 10px">' . $status_badge . '</td>';
                echo '<td style="padding:8px 10px;color:#888;font-size:11px">' . esc_html($created) . '</td>';
                echo '<td style="padding:8px 10px">' . $link . '</td>';
                echo '</tr>';
            }
            echo '</tbody></table></div>';
        }
        echo '</div>';

        // JS for simulate
        ?>
        <script>
        (function(){
            // Render category checkboxes
            var wrap = document.getElementById('sim_cats_wrap');
            if (wrap && typeof vm2SimCats !== 'undefined') {
                if (!vm2SimCats.length) { wrap.innerHTML='<span style="color:#aaa">Nenhuma categoria WC encontrada</span>'; }
                else { wrap.innerHTML = vm2SimCats.map(function(c){
                    return '<label style="display:inline-flex;align-items:center;gap:3px;margin:2px 4px 2px 0;background:#fff;border:1px solid #e5e7eb;border-radius:4px;padding:2px 7px;cursor:pointer;font-size:11px">'
                         + '<input type="checkbox" value="'+c.id+'" style="margin:0"> '+c.name+'</label>';
                }).join(''); }
            }
        })();

        function vm2SimulateElenco() {
            var btn = document.getElementById('btn_simulate');
            var res = document.getElementById('sim_result');
            btn.disabled = true; btn.textContent = 'Simulando...';
            res.innerHTML = '';

            var date = document.getElementById('sim_date').value;
            var catIds = Array.from(document.querySelectorAll('#sim_cats_wrap input:checked')).map(function(cb){ return parseInt(cb.value); });

            var fd = new FormData();
            fd.append('action','vm2_simulate_elenco');
            fd.append('nonce', vm2Nonce);
            fd.append('event_date', date);
            fd.append('cat_ids', JSON.stringify(catIds));

            fetch(vm2Base, {method:'POST',body:fd})
                .then(function(r){return r.json();})
                .then(function(data){
                    btn.disabled=false; btn.textContent='🎬 Simular Montagem';
                    if (data.success && data.data) {
                        var d = data.data;
                        var teamLines = Object.values(d.team||{}).map(function(t){
                            return '<div style="padding:4px 0;font-size:13px">🎭 <strong>'+t.cat_name+':</strong> '+t.partner_name+(t.is_busy?' <span style="color:#f59e0b">⚠️ ocupado</span>':'')+'</div>';
                        });
                        var missLines = (d.missing||[]).map(function(m){
                            var mn=typeof m==='object'?m.name:m;
                            return '<div style="padding:4px 0;font-size:13px;color:#dc2626">⚠️ <strong>'+mn+':</strong> sem parceiro</div>';
                        });
                        var html = '<div style="background:#f0fdf4;border:1px solid #86efac;border-radius:8px;padding:14px">'
                            + '<div style="font-weight:700;color:#15803d;margin-bottom:8px">✅ Equipe montada! Notificação WA enviada.</div>'
                            + teamLines.join('') + missLines.join('')
                            + '<div style="margin-top:10px;padding-top:10px;border-top:1px solid #bbf7d0">'
                            + '<a href="'+d.confirm_url+'" target="_blank" style="color:#7c3aed;font-size:13px;font-weight:600">🔗 Abrir página de confirmação →</a>'
                            + '</div></div>';
                        res.innerHTML = html;
                        setTimeout(function(){ location.reload(); }, 4000);
                    } else {
                        res.innerHTML = '<div style="color:#dc2626;font-size:13px">❌ Erro na simulação. Verifique o console.</div>';
                    }
                })
                .catch(function(e){
                    btn.disabled=false; btn.textContent='🎬 Simular Montagem';
                    res.innerHTML='<div style="color:#dc2626">❌ Erro de rede: '+e.message+'</div>';
                });
        }
        </script>
        <?php
    }


    // ── TAB: MÉTRICAS ──
    elseif ($tab === 'metricas') {
        echo '<div style="display:grid;grid-template-columns:repeat(auto-fill,minmax(280px,1fr));gap:16px">';

        // Top por eventos
        echo '<div class="vm2-card"><h3>🏆 Top por Eventos</h3>';
        if (empty($top_partners)) {
            echo '<div style="color:#aaa;font-size:13px">Sem dados ainda</div>';
        } else {
            $rank = 1;
            foreach ($top_partners as $p) {
                $medal = ['🥇','🥈','🥉'][$rank-1] ?? "#{$rank}";
                echo '<div style="display:flex;align-items:center;gap:10px;padding:8px 0;border-bottom:1px solid #f0f0f0">
                    <span style="font-size:18px">' . $medal . '</span>
                    <div style="flex:1">
                        <div style="font-weight:600;font-size:13px">' . esc_html($p->name) . '</div>
                        <div style="font-size:11px;color:#888">' . esc_html($p->atracao ?: '—') . '</div>
                    </div>
                    <div style="text-align:right">
                        <div style="font-weight:700;color:#7c3aed">' . $p->total_eventos . '</div>
                        <div style="font-size:10px;color:#aaa">eventos</div>
                    </div>
                </div>';
                $rank++;
            }
        }
        echo '</div>';

        // Top por NPS
        $top_nps = $wpdb->get_results("SELECT * FROM {$wpdb->prefix}vm2_partners WHERE nps IS NOT NULL AND status='ativo' ORDER BY nps DESC LIMIT 5");
        echo '<div class="vm2-card"><h3>⭐ Top NPS</h3>';
        if (empty($top_nps)) {
            echo '<div style="color:#aaa;font-size:13px">Sem avaliações ainda</div>';
        } else {
            foreach ($top_nps as $p) {
                $nps_pct = min(100, ($p->nps / 10) * 100);
                $nps_color = $p->nps >= 8 ? '#16a34a' : ($p->nps >= 6 ? '#f59e0b' : '#dc2626');
                echo '<div style="padding:8px 0;border-bottom:1px solid #f0f0f0">
                    <div style="display:flex;justify-content:space-between;align-items:center;margin-bottom:4px">
                        <span style="font-weight:600;font-size:13px">' . esc_html($p->name) . '</span>
                        <span style="font-weight:700;color:' . $nps_color . '">' . number_format($p->nps,1) . '</span>
                    </div>
                    <div style="background:#e5e7eb;border-radius:4px;height:4px"><div style="width:' . $nps_pct . '%;background:' . $nps_color . ';height:4px;border-radius:4px"></div></div>
                </div>';
            }
        }
        echo '</div>';

        // Distribuição por atração
        $by_atracao = $wpdb->get_results("SELECT atracao, COUNT(*) as total FROM {$wpdb->prefix}vm2_partners GROUP BY atracao ORDER BY total DESC LIMIT 10");
        echo '<div class="vm2-card"><h3>🎪 Por Atração</h3>';
        if (empty($by_atracao)) {
            echo '<div style="color:#aaa;font-size:13px">Sem dados ainda</div>';
        } else {
            $max = max(array_column($by_atracao, 'total')) ?: 1;
            foreach ($by_atracao as $row) {
                $pct = round(($row->total / $max) * 100);
                echo '<div style="padding:6px 0">
                    <div style="display:flex;justify-content:space-between;font-size:12px;margin-bottom:3px">
                        <span>' . esc_html($row->atracao ?: 'Não informado') . '</span>
                        <strong>' . $row->total . '</strong>
                    </div>
                    <div style="background:#e9d5ff;border-radius:4px;height:6px"><div style="width:' . $pct . '%;background:#7c3aed;height:6px;border-radius:4px"></div></div>
                </div>';
            }
        }
        echo '</div>';

        // Resumo geral
        $total_inativos = $wpdb->get_var("SELECT COUNT(*) FROM {$wpdb->prefix}vm2_partners WHERE status='inativo'");
        $avg_nps = $wpdb->get_var("SELECT AVG(nps) FROM {$wpdb->prefix}vm2_partners WHERE nps IS NOT NULL");
        echo '<div class="vm2-card"><h3>📊 Resumo Geral</h3>
            <div class="vm2-cfg-2col" style="display:grid;grid-template-columns:1fr 1fr;gap:10px">
                <div style="background:#f9f4ff;border-radius:6px;padding:10px;text-align:center">
                    <div style="font-size:22px;font-weight:700;color:#7c3aed">' . $total_partners . '</div>
                    <div style="font-size:11px;color:#666">Total</div>
                </div>
                <div style="background:#f0fdf4;border-radius:6px;padding:10px;text-align:center">
                    <div style="font-size:22px;font-weight:700;color:#16a34a">' . $total_ativos . '</div>
                    <div style="font-size:11px;color:#666">Ativos</div>
                </div>
                <div style="background:#fff9e6;border-radius:6px;padding:10px;text-align:center">
                    <div style="font-size:22px;font-weight:700;color:#f59e0b">' . ($avg_nps ? number_format($avg_nps,1) : '—') . '</div>
                    <div style="font-size:11px;color:#666">NPS Médio</div>
                </div>
                <div style="background:#fef2f2;border-radius:6px;padding:10px;text-align:center">
                    <div style="font-size:22px;font-weight:700;color:#dc2626">' . $total_inativos . '</div>
                    <div style="font-size:11px;color:#666">Inativos</div>
                </div>
            </div>
        </div>';

        echo '</div>'; // grid
    }

    // ── MODAL CADASTRO/EDIÇÃO ──
    // Output WC categories and tags for the modal
    $wc_cats_list = get_terms(['taxonomy' => 'product_cat', 'hide_empty' => false, 'fields' => 'id=>name', 'number' => 200]);
    $wc_tags_list = get_terms(['taxonomy' => 'product_tag', 'hide_empty' => false, 'fields' => 'id=>name', 'number' => 200]);
    if (is_wp_error($wc_cats_list)) $wc_cats_list = [];
    if (is_wp_error($wc_tags_list)) $wc_tags_list = [];
    $cats_for_js = [];
    foreach ($wc_cats_list as $tid => $tname) { $cats_for_js[] = ['id' => $tid, 'name' => $tname]; }
    $tags_for_js = [];
    foreach ($wc_tags_list as $tid => $tname) { $tags_for_js[] = ['id' => $tid, 'name' => $tname]; }
    echo '<script>var vm2WcCats=' . wp_json_encode($cats_for_js) . ';var vm2WcTags=' . wp_json_encode($tags_for_js) . ';</script>';

    echo '<div id="vm2PartnerModal" style="display:none;position:fixed;inset:0;background:rgba(0,0,0,.5);z-index:9999;overflow-y:auto">
        <div style="background:#fff;max-width:600px;margin:40px auto;border-radius:12px;padding:28px;position:relative">
            <button onclick="document.getElementById(\'vm2PartnerModal\').style.display=\'none\'" style="position:absolute;top:12px;right:16px;background:none;border:none;font-size:20px;cursor:pointer;color:#666">✕</button>
            <h2 id="vm2ModalTitle" style="margin:0 0 20px;font-size:18px">Novo Parceiro</h2>
            <input type="hidden" id="pm_id" value="0">
            <div class="vm2-form-row">
                <div><label>Nome completo *</label><input type="text" id="pm_name" placeholder="Ex: João DJ Sounds"></div>
                <div><label>WhatsApp (DDI+DDD+número)</label><input type="tel" id="pm_phone" placeholder="5511999999999"></div>
            </div>
            <div class="vm2-form-row">
                <div><label>Email</label><input type="email" id="pm_email" placeholder="email@exemplo.com"></div>
                <div><label>Status</label><select id="pm_status"><option value="ativo">🟢 Ativo</option><option value="inativo">⚫ Inativo</option><option value="bloqueado">🔴 Bloqueado</option></select></div>
            </div>
            <div class="vm2-form-row">
                <div><label>🎪 Atrações (separadas por vírgula)</label><input type="text" id="pm_atracao" placeholder="DJ, Mágico, Buffet..."></div>
                <div><label>📍 Região</label><input type="text" id="pm_regiao" placeholder="Ex: Grande SP, Interior SP"></div>
            </div>
            <div class="vm2-form-row">
                <div><label>🏙️ Cidade</label><input type="text" id="pm_cidade" placeholder="São Paulo"></div>
                <div><label>UF</label><input type="text" id="pm_estado" maxlength="2" placeholder="SP"></div>
            </div>
            <div class="vm2-form-row">
                <div>
                    <label>🎭 Função do parceiro</label>
                    <select id="pm_funcao" style="width:100%;padding:7px 10px;border:1px solid #ddd;border-radius:6px;font-size:13px">
                        <option value="artista">🎤 Artista</option>
                        <option value="coordenador">🎯 Coordenador</option>
                        <option value="outros" selected>👤 Outros</option>
                    </select>
                </div>
                <div>
                    <label>💰 Valor / Cachê</label>
                    <div style="display:flex;gap:6px;align-items:center;width:100%">
                        <select id="pm_cache_tipo" style="width:64px;min-width:60px;padding:7px 6px;border:1px solid #ddd;border-radius:6px;font-size:13px;box-sizing:border-box">
                            <option value="reais">R$</option>
                            <option value="porcentagem">%</option>
                        </select>
                        <input type="number" id="pm_cache_valor" min="0" step="0.01" placeholder="0,00" style="flex:1;min-width:0;padding:7px 10px;border:1px solid #ddd;border-radius:6px;font-size:13px;box-sizing:border-box">
                    </div>
                </div>
            </div>
            <div style="margin-bottom:12px">
                <label style="display:block;font-size:12px;font-weight:600;color:#555;margin-bottom:4px">📝 Observações</label>
                <textarea id="pm_observacoes" rows="3" style="width:100%;padding:7px 10px;border:1px solid #ddd;border-radius:6px;font-size:13px;resize:vertical;box-sizing:border-box" placeholder="Informações adicionais..."></textarea>
            </div>
            <div style="margin-bottom:14px">
                <label style="display:block;font-size:12px;font-weight:700;color:#555;margin-bottom:6px">🎪 Categorias WooCommerce <span style="font-weight:400;color:#aaa">(para montagem de elenco)</span></label>
                <div id="pm_cats_wrap" style="display:flex;flex-wrap:wrap;gap:6px;max-height:120px;overflow-y:auto;border:1px solid #eee;padding:8px;border-radius:6px"></div>
            </div>
            <div style="margin-bottom:16px">
                <label style="display:block;font-size:12px;font-weight:700;color:#555;margin-bottom:6px">🏷️ Tags WooCommerce <span style="font-weight:400;color:#aaa">(opcional)</span></label>
                <div id="pm_tags_wrap" style="display:flex;flex-wrap:wrap;gap:6px;max-height:100px;overflow-y:auto;border:1px solid #eee;padding:8px;border-radius:6px"></div>
            </div>
            <div style="display:flex;gap:8px;justify-content:flex-end">
                <button class="vm2-btn vm2-btn-gray" onclick="document.getElementById(\'vm2PartnerModal\').style.display=\'none\'">Cancelar</button>
                <button class="vm2-btn vm2-btn-primary" onclick="vm2SavePartner()">💾 Salvar Parceiro</button>
            </div>
            <div id="pm_msg" style="margin-top:10px;font-size:13px"></div>
        </div>
    </div>';

    // ── JAVASCRIPT ──
    ?>
<script>
    var vm2Nonce = "<?php echo $nonce; ?>";
    var vm2Base  = "<?php echo admin_url('admin-ajax.php'); ?>";
    var vm2Page  = "<?php echo admin_url('admin.php?page=vm2-parceiros'); ?>";

    function vm2RenderCheckboxes(wrapId, items, checkedIds) {
        var wrap = document.getElementById(wrapId);
        if (!wrap) return;
        if (!items || items.length === 0) { wrap.innerHTML = '<span style="color:#aaa;font-size:11px">Nenhuma opção encontrada</span>'; return; }
        wrap.innerHTML = items.map(function(it) {
            var chk = (checkedIds && checkedIds.indexOf(it.id) >= 0) ? ' checked' : '';
            return '<label style="display:inline-flex;align-items:center;gap:4px;background:#fff;border:1px solid #e5e7eb;border-radius:4px;padding:3px 8px;cursor:pointer;white-space:nowrap">'
                 + '<input type="checkbox" value="' + it.id + '"' + chk + ' style="margin:0">'
                 + '<span>' + it.name + '</span></label>';
        }).join('');
    }

    function vm2GetCheckedIds(wrapId) {
        var wrap = document.getElementById(wrapId);
        if (!wrap) return [];
        return Array.from(wrap.querySelectorAll('input[type=checkbox]:checked')).map(function(cb){ return parseInt(cb.value); });
    }

    function vm2OpenModal(id) {
        var m = document.getElementById("vm2PartnerModal");
        // Render checkboxes always
        vm2RenderCheckboxes("pm_cats_wrap", typeof vm2WcCats !== "undefined" ? vm2WcCats : [], []);
        vm2RenderCheckboxes("pm_tags_wrap", typeof vm2WcTags !== "undefined" ? vm2WcTags : [], []);
        var msgEl = document.getElementById("pm_msg");
        if (msgEl) msgEl.textContent = "";
        if (id > 0) {
            document.getElementById("vm2ModalTitle").textContent = "Editar Parceiro";
            document.getElementById("pm_id").value = id;
            // [v1.5.105] Reset Função + Cachê
            var fnEl = document.getElementById("pm_funcao");
            if (fnEl) fnEl.value = "outros";
            var cvEl = document.getElementById("pm_cache_valor");
            if (cvEl) cvEl.value = "";
            var ctEl = document.getElementById("pm_cache_tipo");
            if (ctEl) ctEl.value = "reais";
            // Load partner data via AJAX
            var fd = new FormData();
            fd.append("action","vm2_get_partner");
            fd.append("nonce",vm2Nonce);
            fd.append("id",id);
            fetch(vm2Base, {method:"POST",body:fd}).then(function(r){return r.json();}).then(function(res){
                if (res.success && res.data) {
                    var p = res.data;
                    ["name","phone","email","atracao","regiao","cidade","estado","observacoes","funcao","cache_valor","cache_tipo"].forEach(function(f){
                        var el = document.getElementById("pm_"+f);
                        if (el) el.value = p[f] || "";
                    });
                    var st = document.getElementById("pm_status");
                    if (st) st.value = p.status || "ativo";
                    try {
                        var cats = JSON.parse(p.wc_categories || "[]");
                        var tags = JSON.parse(p.wc_tags || "[]");
                        vm2RenderCheckboxes("pm_cats_wrap", typeof vm2WcCats !== "undefined" ? vm2WcCats : [], cats);
                        vm2RenderCheckboxes("pm_tags_wrap", typeof vm2WcTags !== "undefined" ? vm2WcTags : [], tags);
                    } catch(e) {}
                }
            });
        } else {
            document.getElementById("vm2ModalTitle").textContent = "Novo Parceiro";
            document.getElementById("pm_id").value = 0;
            ["pm_name","pm_phone","pm_email","pm_atracao","pm_regiao","pm_cidade","pm_estado","pm_observacoes","pm_cache_valor"].forEach(function(f){ var el=document.getElementById(f); if(el) el.value=""; });
            document.getElementById("pm_status").value = "ativo";
            var fnEl2 = document.getElementById("pm_funcao"); if(fnEl2) fnEl2.value = "outros";
            var ctEl2 = document.getElementById("pm_cache_tipo"); if(ctEl2) ctEl2.value = "reais";
        }
        m.style.display = "block";
    }

    function vm2SavePartner() {
        var btn = event.target;
        btn.disabled = true; btn.textContent = "Salvando...";
        var fd = new FormData();
        fd.append("action","vm2_save_partner");
        fd.append("nonce", vm2Nonce);
        ["id","name","phone","email","atracao","regiao","cidade","estado","status","observacoes","funcao","cache_valor","cache_tipo"].forEach(function(f){
            var el = document.getElementById("pm_"+f);
            if (el) fd.append(f, el.value);
        });
        fd.append("wc_categories", JSON.stringify(vm2GetCheckedIds("pm_cats_wrap")));
        fd.append("wc_tags",       JSON.stringify(vm2GetCheckedIds("pm_tags_wrap")));
        fetch(vm2Base, {method:"POST",body:fd}).then(r=>r.json()).then(function(res){
            btn.disabled = false; btn.textContent = "💾 Salvar Parceiro";
            var msg = document.getElementById("pm_msg");
            if (res.success) {
                msg.style.color = "#16a34a";
                msg.textContent = "✅ Parceiro salvo com sucesso!";
                setTimeout(function(){ location.reload(); }, 800);
            } else {
                msg.style.color = "#dc2626";
                msg.textContent = "❌ Erro ao salvar.";
            }
        });
    }

    function vm2DeletePartner(id) {
        if (!confirm("Excluir este parceiro? Esta ação não pode ser desfeita.")) return;
        var fd = new FormData();
        fd.append("action","vm2_delete_partner");
        fd.append("nonce",vm2Nonce);
        fd.append("id",id);
        fetch(vm2Base, {method:"POST",body:fd}).then(r=>r.json()).then(function(res){
            if (res.success) location.href = vm2Page + "&tab=cadastro";
        });
    }

    function vm2QueueAction(id, action) {
        var fd = new FormData();
        fd.append("action","vm2_approve_queue");
        fd.append("nonce",vm2Nonce);
        fd.append("id",id);
        fd.append("queue_action",action);
        fetch(vm2Base, {method:"POST",body:fd}).then(r=>r.json()).then(function(res){
            if (res.success) {
                var el = document.getElementById("qi_"+id);
                if (el) { el.style.opacity="0.3"; el.style.pointerEvents="none"; }
                if (action==="approve") { el.innerHTML = "<div style='padding:10px;color:#16a34a;font-weight:600'>✅ Aprovado & Enviado!</div>"; }
                else { el.innerHTML = "<div style='padding:10px;color:#dc2626'>✕ Cancelado</div>"; }
            }
        });
    }

    function vm2EditBubble(id) {
        var bubble = document.getElementById("bubble_"+id);
        var current = bubble.textContent;
        var ta = document.createElement("textarea");
        ta.value = current; ta.rows = 5;
        ta.style.cssText = "width:100%;padding:8px;border:1px solid #7c3aed;border-radius:6px;font-size:13px;resize:vertical;box-sizing:border-box";
        bubble.parentNode.replaceChild(ta, bubble);
        ta.id = "bubble_"+id;
        var saveBtn = bubble.parentNode.querySelector(".actions");
        if (!saveBtn) return;
        var newBtn = document.createElement("button");
        newBtn.className = "vm2-btn vm2-btn-primary vm2-btn-sm";
        newBtn.textContent = "💾 Salvar edição";
        newBtn.onclick = function() {
            var fd = new FormData();
            fd.append("action","vm2_approve_queue");
            fd.append("nonce",vm2Nonce);
            fd.append("id",id);
            fd.append("queue_action","edit");
            fd.append("message",ta.value);
            fetch(vm2Base,{method:"POST",body:fd}).then(r=>r.json()).then(function(r){
                if(r.success){newBtn.textContent="✅ Salvo!";}
            });
        };
        saveBtn.prepend(newBtn);
    }

    function vm2ApproveAllUrgent() {
        if (!confirm("Aprovar e enviar TODAS as mensagens urgentes?")) return;
        document.querySelectorAll(".vm2-priority-urgente").forEach(function(el){
            var id = el.id.replace("qi_","");
            if (id) vm2QueueAction(parseInt(id), "approve");
        });
    }

    function vm2CreateRound() {
        var atracao = document.getElementById("match_atracao").value.trim();
        var date    = document.getElementById("match_date").value;
        var order   = document.getElementById("match_order").value;
        var msg     = document.getElementById("match_msg").value.trim();
        var res_div = document.getElementById("match_result");
        if (!atracao || !date) { res_div.innerHTML = "<span style='color:#dc2626'>⚠️ Preencha a atração e a data.</span>"; return; }
        res_div.innerHTML = "<span style='color:#888'>⏳ Criando rodada...</span>";
        var fd = new FormData();
        fd.append("action","vm2_create_matching_round");
        fd.append("nonce",vm2Nonce);
        fd.append("atracao",atracao);
        fd.append("event_date",date);
        fd.append("order_id",order||0);
        fd.append("msg_template",msg);
        fetch(vm2Base,{method:"POST",body:fd}).then(r=>r.json()).then(function(r){
            if(r.success){
                var d = r.data;
                if(d.queued > 0){
                    res_div.innerHTML = "<span style='color:#16a34a'>✅ " + d.queued + " convite(s) adicionado(s) à Fila de Aprovação!</span> <a href='"+vm2Page+"&tab=fila' style='color:#7c3aed'>→ Ver Fila</a>";
                } else {
                    res_div.innerHTML = "<span style='color:#f59e0b'>⚠️ Nenhum parceiro disponível com essa atração na data informada. Cadastre parceiros primeiro.</span>";
                }
            } else {
                res_div.innerHTML = "<span style='color:#dc2626'>❌ Erro ao criar rodada.</span>";
            }
        });
    }

    function vm2AdvanceStage(event_id, next_stage) {
        var fd = new FormData();
        fd.append("action","vm2_advance_partner_stage");
        fd.append("nonce",vm2Nonce);
        fd.append("event_id",event_id);
        fd.append("stage",next_stage);
        fetch(vm2Base,{method:"POST",body:fd}).then(r=>r.json()).then(function(r){
            if(r.success) location.reload();
        });
    }
</script>
    <?php

    echo '</div>'; // .vm2-wrap
}

// AJAX: Advance partner event stage

// ═══════════════════════════════════════════════════════════════════
// ELENCO — BOT DE MONTAGEM DE EQUIPE
// ═══════════════════════════════════════════════════════════════════

// ── Auto-criar página /elenco-vivamais/ na ativação ──
add_action('init', 'vm2_ensure_elenco_page');
function vm2_ensure_elenco_page() {
    if (get_option('vm2_elenco_page_v1')) return;
    $existing = get_page_by_path('elenco-vivamais');
    if (!$existing) {
        $page_id = wp_insert_post([
            'post_title'   => 'Confirmar Equipe',
            'post_name'    => 'elenco-vivamais',
            'post_status'  => 'publish',
            'post_type'    => 'page',
            'post_content' => '',
        ]);
        if ($page_id && !is_wp_error($page_id)) {
            update_option('vm2_elenco_page_v1', $page_id);
        }
    } else {
        update_option('vm2_elenco_page_v1', $existing->ID);
    }
}

// ── Template override para a página de confirmação ──
add_action('template_redirect', 'vm2_elenco_template_redirect');
function vm2_elenco_template_redirect() {
    if (!is_page('elenco-vivamais')) return;
    $token    = sanitize_text_field($_GET['token'] ?? '');
    global $wpdb;
    $team_row = null;
    if ($token) {
        $team_row = $wpdb->get_row($wpdb->prepare(
            "SELECT * FROM {$wpdb->prefix}vm2_teams WHERE confirm_token=%s",
            $token
        ));
    }
    vm2_elenco_render_confirmation($team_row, $token);
    exit;
}

// ── Pegar data do evento a partir do pedido ──
function vm2_get_event_date_from_order($order_id) {
    $order = wc_get_order($order_id);
    if (!$order) return null;
    foreach ($order->get_items() as $item) {
        $bd = $item->get_meta('yith_booking_data');
        if ($bd) {
            $from = $bd['from'] ?? ($bd['start'] ?? null);
            if ($from) {
                $ts = is_numeric($from) ? (int)$from : strtotime($from);
                if ($ts > 0) return date('Y-m-d', $ts);
            }
        }
    }
    foreach (['_data_evento','data_evento','_yith_booking_start'] as $meta_key) {
        $v = get_post_meta($order_id, $meta_key, true);
        if ($v) { $ts = strtotime($v); if ($ts > 0) return date('Y-m-d', $ts); }
    }
    return null;
}

// ── Motor de montagem de equipe ──
function vm2_assemble_team($order_id, $simulate = false, $sim_date = null, $sim_cat_ids = []) {
    global $wpdb;

    $order       = function_exists('wc_get_order') ? wc_get_order($order_id) : null;
    $event_date  = $sim_date ?: ($order ? vm2_get_event_date_from_order($order_id) : null);
    $client_name = 'Simulação';
    $client_phone = '';

    if ($order) {
        $fn = $order->get_billing_first_name();
        $ln = $order->get_billing_last_name();
        $client_name  = trim("$fn $ln") ?: 'Cliente';
        $client_phone = preg_replace('/\D/', '', $order->get_billing_phone());
    }

    // Determinar categorias necessárias
    $needed_cats = $sim_cat_ids;
    if (empty($needed_cats) && $order) {
        foreach ($order->get_items() as $item) {
            $pid   = $item->get_product_id();
            $terms = wp_get_post_terms($pid, 'product_cat', ['fields' => 'ids']);
            if (!is_wp_error($terms)) $needed_cats = array_merge($needed_cats, $terms);
        }
        $needed_cats = array_unique($needed_cats);
    }

    $team    = [];
    $missing = [];

    foreach ($needed_cats as $cat_id) {
        $cat      = get_term((int)$cat_id, 'product_cat');
        $cat_name = ($cat && !is_wp_error($cat)) ? $cat->name : "Categoria $cat_id";

        // Buscar parceiros ativos que atendem esta categoria
        $all_partners = $wpdb->get_results(
            "SELECT * FROM {$wpdb->prefix}vm2_partners WHERE status='ativo'"
        );

        $matching = array_values(array_filter($all_partners, function($p) use ($cat_id) {
            $cats = json_decode($p->wc_categories ?: '[]', true);
            return in_array((int)$cat_id, (array)$cats);
        }));

        if (empty($matching)) {
            $missing[] = ['id' => $cat_id, 'name' => $cat_name];
            continue;
        }

        // Separar por disponibilidade na data
        $free = []; $busy = [];
        foreach ($matching as $p) {
            if ($event_date) {
                $count = (int)$wpdb->get_var($wpdb->prepare(
                    "SELECT COUNT(*) FROM {$wpdb->prefix}vm2_partner_events
                     WHERE partner_id=%d AND event_date=%s AND stage != 'cancelled'",
                    $p->id, $event_date
                ));
                if ($count > 0) $busy[] = $p; else $free[] = $p;
            } else {
                $free[] = $p;
            }
        }

        // Ordenar pool por menos eventos ativos (quem tem menos compromissos é chamado primeiro)
        usort($free, function($a, $b) use ($wpdb, $event_date) {
            $count_a = (int)$wpdb->get_var($wpdb->prepare(
                "SELECT COUNT(*) FROM {$wpdb->prefix}vm2_partner_events WHERE partner_id=%d AND stage != 'cancelled'", $a->id
            ));
            $count_b = (int)$wpdb->get_var($wpdb->prepare(
                "SELECT COUNT(*) FROM {$wpdb->prefix}vm2_partner_events WHERE partner_id=%d AND stage != 'cancelled'", $b->id
            ));
            return $count_a - $count_b;
        });
        $pool   = !empty($free) ? $free : $busy;
        // Escolher aleatório entre os 3 menos ocupados (ou todos se < 3)
        $top_pool = array_slice($pool, 0, min(3, count($pool)));
        $chosen = $top_pool[array_rand($top_pool)];

        $team[(string)$cat_id] = [
            'cat_id'        => (int)$cat_id,
            'cat_name'      => $cat_name,
            'partner_id'    => (int)$chosen->id,
            'partner_name'  => $chosen->name,
            'partner_phone' => $chosen->phone,
            'funcao'        => $chosen->funcao ?? 'outros',
            'cache_valor'   => $chosen->cache_valor ?? null,
            'cache_tipo'    => $chosen->cache_tipo ?? 'reais',
            'is_busy'       => !empty($busy) && in_array($chosen, $busy),
        ];
    }

    // Garantir 1 Artista + 1 Coordenador se não vieram pelas categorias
    $has_artista     = false;
    $has_coordenador = false;
    foreach ($team as $t) {
        if (($t['funcao'] ?? '') === 'artista')     $has_artista = true;
        if (($t['funcao'] ?? '') === 'coordenador') $has_coordenador = true;
    }

    // Se não tem artista, buscar o artista com menos eventos
    if (!$has_artista) {
        $artistas = $wpdb->get_results(
            "SELECT p.*, COUNT(pe.id) as ev_count
             FROM {$wpdb->prefix}vm2_partners p
             LEFT JOIN {$wpdb->prefix}vm2_partner_events pe ON pe.partner_id = p.id AND pe.stage != 'cancelled'
             WHERE p.status='ativo' AND p.funcao='artista'
             GROUP BY p.id ORDER BY ev_count ASC LIMIT 3"
        );
        if (!empty($artistas)) {
            $chosen_a = $artistas[array_rand(array_slice($artistas, 0, min(3, count($artistas))))];
            $team['extra_artista'] = [
                'cat_id'        => 0,
                'cat_name'      => 'Artista',
                'partner_id'    => (int)$chosen_a->id,
                'partner_name'  => $chosen_a->name,
                'partner_phone' => $chosen_a->phone,
                'funcao'        => 'artista',
                'cache_valor'   => $chosen_a->cache_valor ?? null,
                'cache_tipo'    => $chosen_a->cache_tipo ?? 'reais',
                'is_busy'       => false,
            ];
        }
    }

    // Se não tem coordenador, buscar o coordenador com menos eventos
    if (!$has_coordenador) {
        $coordenadores = $wpdb->get_results(
            "SELECT p.*, COUNT(pe.id) as ev_count
             FROM {$wpdb->prefix}vm2_partners p
             LEFT JOIN {$wpdb->prefix}vm2_partner_events pe ON pe.partner_id = p.id AND pe.stage != 'cancelled'
             WHERE p.status='ativo' AND p.funcao='coordenador'
             GROUP BY p.id ORDER BY ev_count ASC LIMIT 3"
        );
        if (!empty($coordenadores)) {
            $chosen_c = $coordenadores[array_rand(array_slice($coordenadores, 0, min(3, count($coordenadores))))];
            $team['extra_coordenador'] = [
                'cat_id'        => 0,
                'cat_name'      => 'Coordenador',
                'partner_id'    => (int)$chosen_c->id,
                'partner_name'  => $chosen_c->name,
                'partner_phone' => $chosen_c->phone,
                'funcao'        => 'coordenador',
                'cache_valor'   => $chosen_c->cache_valor ?? null,
                'cache_tipo'    => $chosen_c->cache_tipo ?? 'reais',
                'is_busy'       => false,
            ];
        }
    }

    // Salvar no banco
    $token = bin2hex(random_bytes(24));
    $wpdb->insert($wpdb->prefix . 'vm2_teams', [
        'order_id'      => (int)$order_id,
        'event_date'    => $event_date,
        'client_name'   => $client_name,
        'client_phone'  => $client_phone,
        'team_json'     => wp_json_encode($team),
        'missing_cats'  => wp_json_encode($missing),
        'confirm_token' => $token,
        'status'        => 'draft',
        'is_simulation' => $simulate ? 1 : 0,
        'created_at'    => current_time('mysql'),
    ]);
    $team_id = (int)$wpdb->insert_id;

    return [
        'team_id'     => $team_id,
        'order_id'    => $order_id,
        'event_date'  => $event_date,
        'client_name' => $client_name,
        'team'        => $team,
        'missing'     => $missing,
        'token'       => $token,
        'confirm_url' => home_url('/elenco-vivamais/?token=' . $token),
        'is_simulation' => $simulate,
    ];
}

// ── Enviar notificação WA para os admins ──
function vm2_notify_admins_elenco($result) {
    if (empty($result['team_id'])) return;
    $date_fmt  = $result['event_date'] ? wp_date('d/m/Y', strtotime($result['event_date'])) : '—';
    $sim_label = !empty($result['is_simulation']) ? "\n🧪 *SIMULAÇÃO — não é pedido real*\n" : '';
    $order_label = (!empty($result['order_id']) && !$result['is_simulation']) ? "Pedido #{$result['order_id']}" : 'Simulação';

    $lines = [];
    $total_reais = 0.0;
    $has_porcentagem = false;
    foreach ($result['team'] as $t) {
        $busy_flag  = !empty($t['is_busy']) ? ' ⚠️' : '';
        $funcao_label = '';
        switch ($t['funcao'] ?? 'outros') {
            case 'artista':     $funcao_label = ' 🎤'; break;
            case 'coordenador': $funcao_label = ' 🎯'; break;
            default:            $funcao_label = '';    break;
        }
        $cache_str = '';
        if (!empty($t['cache_valor']) && $t['cache_valor'] > 0) {
            if (($t['cache_tipo'] ?? 'reais') === 'porcentagem') {
                $cache_str = ' — ' . number_format($t['cache_valor'], 1, ',', '.') . '%';
                $has_porcentagem = true;
            } else {
                $cache_str = ' — R$ ' . number_format($t['cache_valor'], 2, ',', '.');
                $total_reais += floatval($t['cache_valor']);
            }
        }
        $lines[] = "• {$t['cat_name']}{$funcao_label}: *{$t['partner_name']}*{$cache_str}{$busy_flag}";
    }
    foreach ($result['missing'] as $m) {
        $cat_name = is_array($m) ? $m['name'] : $m;
        $lines[]  = "• {$cat_name}: ⚠️ *SEM PARCEIRO CADASTRADO*";
    }

    $team_text = implode("\n", $lines) ?: '_(nenhuma categoria nos produtos)_';

    $total_line = '';
    if ($total_reais > 0) {
        $total_line = "\n💸 *Total cachês (R$):* R$ " . number_format($total_reais, 2, ',', '.');
    }
    if ($has_porcentagem) {
        $total_line .= "\n⚠️ Alguns cachês são em % (não incluídos no total)";
    }

    $sem_coord_url = $result['confirm_url'] . '&sem_coordenador=1';

    $msg = "🎬 *EQUIPE MONTADA — {$order_label}*{$sim_label}\n"
         . "📅 Data: {$date_fmt}\n"
         . "👤 Cliente: {$result['client_name']}\n\n"
         . "🎪 *Equipe:*\n{$team_text}{$total_line}\n\n"
         . "🔗 Confirmar equipe:\n{$result['confirm_url']}\n"
         . "❌ Dispensar coordenador:\n{$sem_coord_url}";

    foreach (['5511988195809', '5511992586894'] as $phone) {
        vm2_send_zapi('zapi_7551', $phone, $msg);
    }
}

// ── Hook WC: contract-signed → montar equipe ──
add_action('woocommerce_order_status_changed', 'vm2_on_contract_signed_elenco', 10, 3);
function vm2_on_contract_signed_elenco($order_id, $old_status, $new_status) {
    if ($new_status !== 'contract-signed') return;
    global $wpdb;
    $already = (int)$wpdb->get_var($wpdb->prepare(
        "SELECT id FROM {$wpdb->prefix}vm2_teams WHERE order_id=%d AND is_simulation=0 LIMIT 1",
        $order_id
    ));
    if ($already) return;
    $result = vm2_assemble_team($order_id);
    if (!empty($result['team_id'])) vm2_notify_admins_elenco($result);
}

// ── AJAX: simular montagem ──
add_action('wp_ajax_vm2_simulate_elenco', 'vm2_ajax_simulate_elenco');
function vm2_ajax_simulate_elenco() {
    check_ajax_referer('vm2_nonce', 'nonce');
    $order_id  = intval($_POST['order_id'] ?? 0);
    $sim_date  = sanitize_text_field($_POST['event_date'] ?? '');
    $cat_ids   = array_map('intval', json_decode(stripslashes($_POST['cat_ids'] ?? '[]'), true) ?: []);
    $result    = vm2_assemble_team($order_id ?: 0, true, $sim_date ?: null, $cat_ids);
    $result['is_simulation'] = true;
    vm2_notify_admins_elenco($result);
    wp_send_json_success($result);
}

// ── AJAX: carregar dados do parceiro (para modal de edição) ──
add_action('wp_ajax_vm2_get_partner', 'vm2_ajax_get_partner');
function vm2_ajax_get_partner() {
    check_ajax_referer('vm2_nonce', 'nonce');
    global $wpdb;
    $id = intval($_POST['id'] ?? 0);
    $p  = $wpdb->get_row($wpdb->prepare("SELECT * FROM {$wpdb->prefix}vm2_partners WHERE id=%d", $id));
    if (!$p) { wp_send_json_error('not found'); return; }
    wp_send_json_success((array)$p);
}

// ── AJAX (público): confirmar equipe via token ──
add_action('wp_ajax_nopriv_vm2_confirm_elenco', 'vm2_ajax_confirm_elenco');
add_action('wp_ajax_vm2_confirm_elenco',        'vm2_ajax_confirm_elenco');

// ── v1.5.91: Salvar e-mail por telefone (WA Capture step 2 + SofIA) ──────────
add_action('wp_ajax_nopriv_vm_wa_save_email', 'vm2_ajax_save_email');
add_action('wp_ajax_vm_wa_save_email',        'vm2_ajax_save_email');
function vm2_ajax_save_email() {
    if ( ! check_ajax_referer('vm_wa_capture', 'nonce', false) ) {
        wp_send_json_error('invalid_nonce'); return;
    }
    $phone = preg_replace('/\D/', '', sanitize_text_field($_POST['phone'] ?? ''));
    $email = sanitize_email($_POST['email'] ?? '');
    if ( strlen($phone) < 10 || ! is_email($email) ) {
        wp_send_json_error('invalid_data'); return;
    }
    // Normalizar telefone com DDI 55
    if ( strlen($phone) <= 11 ) $phone = '55' . $phone;
    global $wpdb;
    $ct = $wpdb->prefix . 'vm2_contacts';
    $row = $wpdb->get_row($wpdb->prepare("SELECT id, email FROM $ct WHERE phone=%s LIMIT 1", $phone));
    if ( $row ) {
        if ( empty($row->email) ) {
            $wpdb->update($ct, ['email' => $email, 'last_activity' => current_time('mysql')], ['id' => $row->id]);
            wp_send_json_success(['updated' => true]);
        } else {
            wp_send_json_success(['updated' => false, 'reason' => 'already_has_email']);
        }
    } else {
        wp_send_json_error('contact_not_found');
    }
}
function vm2_ajax_confirm_elenco() {
    global $wpdb;
    $token      = sanitize_text_field($_POST['token'] ?? '');
    $team_json  = stripslashes($_POST['team_json'] ?? '');
    $by         = sanitize_text_field($_POST['confirmed_by'] ?? 'admin_wa');

    if (!$token) { wp_send_json_error('token_missing'); return; }

    $team_row = $wpdb->get_row($wpdb->prepare(
        "SELECT * FROM {$wpdb->prefix}vm2_teams WHERE confirm_token=%s", $token
    ));
    if (!$team_row) { wp_send_json_error('not_found'); return; }

    $team_data = json_decode($team_json ?: $team_row->team_json, true) ?: [];

    $wpdb->update($wpdb->prefix . 'vm2_teams', [
        'team_json'    => wp_json_encode($team_data),
        'status'       => 'confirmed',
        'confirmed_by' => $by,
        'confirmed_at' => current_time('mysql'),
    ], ['confirm_token' => $token]);

    // Inserir na agenda dos parceiros
    if ($team_row->event_date) {
        $wpdb->delete($wpdb->prefix . 'vm2_partner_events',
            ['order_id' => $team_row->order_id, 'stage' => 'elenco']);

        foreach ($team_data as $t) {
            if (empty($t['partner_id'])) continue;
            $wpdb->insert($wpdb->prefix . 'vm2_partner_events', [
                'partner_id' => (int)$t['partner_id'],
                'order_id'   => $team_row->order_id,
                'event_date' => $team_row->event_date,
                'stage'      => 'elenco',
                'notes'      => 'Confirmado via link de aprovação · ' . $by,
                'created_at' => current_time('mysql'),
            ]);
        }
    }
    wp_send_json_success(['status' => 'confirmed']);
}

// ── Página de confirmação — renderer ──
function vm2_elenco_render_confirmation($team_row, $token) {
    global $wpdb;
    $ajax_url = admin_url('admin-ajax.php');

    // Carregar todos os parceiros ativos para o dropdown de substituição
    $all_active = $wpdb->get_results(
        "SELECT id, name, wc_categories FROM {$wpdb->prefix}vm2_partners WHERE status='ativo' ORDER BY name ASC"
    );
    $partners_js = wp_json_encode(array_map(function($p) {
        return [
            'id'   => (int)$p->id,
            'name' => $p->name,
            'cats' => json_decode($p->wc_categories ?: '[]', true) ?: [],
        ];
    }, $all_active));

    $team_data    = $team_row ? (json_decode($team_row->team_json ?: '{}', true) ?: []) : [];
    $missing_data = $team_row ? (json_decode($team_row->missing_cats ?: '[]', true) ?: []) : [];
    $event_date   = $team_row ? ($team_row->event_date ? wp_date('d/m/Y', strtotime($team_row->event_date)) : '—') : '—';
    $client       = $team_row ? esc_html($team_row->client_name ?: '—') : '—';
    $order_id     = $team_row ? (int)$team_row->order_id : 0;
    $status       = $team_row ? $team_row->status : '';
    $is_sim       = $team_row ? (bool)$team_row->is_simulation : false;
    $order_label  = ($order_id && !$is_sim) ? "Pedido #{$order_id}" : 'Simulação';
    $team_json_escaped = esc_attr(wp_json_encode($team_data));

    header('Content-Type: text/html; charset=utf-8');
    ?><!DOCTYPE html>
<html lang="pt-BR">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Confirmar Equipe · VivaMais</title>
<style>
  *{box-sizing:border-box;margin:0;padding:0}
  body{font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',sans-serif;background:#f3f4f6;min-height:100vh}
  .top-bar{background:linear-gradient(135deg,#7c3aed,#4f46e5);color:#fff;padding:16px 20px;display:flex;align-items:center;gap:12px}
  .top-bar .logo{font-size:22px;font-weight:800;letter-spacing:-0.5px}
  .top-bar .sub{font-size:13px;opacity:.8}
  .container{max-width:640px;margin:0 auto;padding:20px 16px 60px}
  .card{background:#fff;border-radius:12px;padding:20px;margin-bottom:16px;box-shadow:0 1px 3px rgba(0,0,0,.08)}
  .card h2{font-size:16px;font-weight:700;margin-bottom:14px;display:flex;align-items:center;gap:8px}
  .info-grid{display:grid;grid-template-columns:1fr 1fr;gap:10px;margin-bottom:4px}
  .info-item{background:#f9fafb;border-radius:8px;padding:10px}
  .info-item .lbl{font-size:11px;color:#888;font-weight:600;margin-bottom:2px}
  .info-item .val{font-size:14px;font-weight:700;color:#1d2327}
  .team-slot{border:1px solid #e5e7eb;border-radius:10px;padding:14px;margin-bottom:10px;background:#fafafa}
  .team-slot .cat-name{font-size:12px;font-weight:600;color:#7c3aed;margin-bottom:6px;text-transform:uppercase;letter-spacing:.5px}
  .team-slot .partner-name{font-size:15px;font-weight:700;color:#1d2327;margin-bottom:6px}
  .team-slot .busy-warn{font-size:11px;color:#f59e0b;background:#fffbeb;border:1px solid #fde68a;border-radius:4px;padding:3px 7px;display:inline-block;margin-bottom:6px}
  .team-slot select{width:100%;padding:7px 10px;border:1px solid #d1d5db;border-radius:6px;font-size:13px;background:#fff}
  .missing-slot{border:1px solid #fca5a5;border-radius:10px;padding:14px;margin-bottom:10px;background:#fff5f5}
  .missing-slot .cat-name{font-size:12px;font-weight:600;color:#dc2626;margin-bottom:4px;text-transform:uppercase}
  .missing-slot .msg{font-size:13px;color:#dc2626}
  .confirmed-banner{background:linear-gradient(135deg,#dcfce7,#bbf7d0);border:1px solid #86efac;border-radius:10px;padding:16px;text-align:center;margin-bottom:16px}
  .confirmed-banner .icon{font-size:32px;margin-bottom:6px}
  .confirmed-banner .title{font-size:16px;font-weight:700;color:#15803d}
  .confirmed-banner .sub{font-size:13px;color:#166534;margin-top:4px}
  .sim-banner{background:#fffbeb;border:1px solid #fde68a;border-radius:8px;padding:10px 14px;font-size:12px;color:#92400e;margin-bottom:16px}
  .btn-confirm{width:100%;background:linear-gradient(135deg,#7c3aed,#4f46e5);color:#fff;border:none;border-radius:10px;padding:15px;font-size:16px;font-weight:700;cursor:pointer;margin-top:4px}
  .btn-confirm:hover{opacity:.92}
  .btn-confirm:disabled{opacity:.5;cursor:not-allowed}
  .invalid-card{text-align:center;padding:40px 20px}
  .invalid-card .icon{font-size:48px;margin-bottom:12px}
  .invalid-card p{color:#666;font-size:14px}
</style>
</head>
<body>
<div class="top-bar">
  <div>
    <div class="logo">🎬 VivaMais</div>
    <div class="sub">Confirmação de Equipe</div>
  </div>
</div>
<div class="container">
<?php if (!$token || !$team_row): ?>
  <div class="card invalid-card">
    <div class="icon">🔒</div>
    <h2 style="margin-bottom:8px">Link inválido ou expirado</h2>
    <p>Este link de confirmação é inválido.<br>Solicite um novo link pelo WhatsApp.</p>
  </div>
<?php elseif ($status === 'confirmed'): ?>
  <div class="confirmed-banner">
    <div class="icon">✅</div>
    <div class="title">Equipe já confirmada!</div>
    <div class="sub">Confirmado em <?php echo $team_row->confirmed_at ? wp_date('d/m/Y H:i', strtotime($team_row->confirmed_at)) : '—'; ?></div>
  </div>
  <div class="card">
    <h2>📋 Resumo do <?php echo esc_html($order_label); ?></h2>
    <div class="info-grid">
      <div class="info-item"><div class="lbl">📅 Data do Evento</div><div class="val"><?php echo $event_date; ?></div></div>
      <div class="info-item"><div class="lbl">👤 Cliente</div><div class="val"><?php echo $client; ?></div></div>
    </div>
  </div>
  <div class="card">
    <h2>🎪 Equipe Confirmada</h2>
    <?php foreach ($team_data as $t): ?>
    <div class="team-slot">
      <div class="cat-name"><?php echo esc_html($t['cat_name'] ?? ''); ?></div>
      <div class="partner-name">🎭 <?php echo esc_html($t['partner_name'] ?? '—'); ?></div>
    </div>
    <?php endforeach; ?>
  </div>
<?php else: ?>
  <?php if ($is_sim): ?><div class="sim-banner">🧪 <strong>Simulação</strong> — Este link foi gerado como teste e não representa um pedido real.</div><?php endif; ?>
  <div class="card">
    <h2>📋 <?php echo esc_html($order_label); ?></h2>
    <div class="info-grid">
      <div class="info-item"><div class="lbl">📅 Data do Evento</div><div class="val"><?php echo $event_date; ?></div></div>
      <div class="info-item"><div class="lbl">👤 Cliente</div><div class="val"><?php echo $client; ?></div></div>
    </div>
  </div>
  <div class="card">
    <h2>🎪 Equipe Sugerida <span style="font-size:12px;font-weight:400;color:#888">(altere se necessário)</span></h2>
    <div id="team-slots">
    <?php foreach ($team_data as $cat_id => $t): ?>
    <div class="team-slot" data-cat="<?php echo esc_attr($cat_id); ?>">
      <div class="cat-name"><?php echo esc_html($t['cat_name']); ?></div>
      <?php if (!empty($t['is_busy'])): ?><div class="busy-warn">⚠️ Já tem evento nesse dia</div><?php endif; ?>
      <select class="partner-select" data-cat="<?php echo esc_attr($cat_id); ?>" data-current="<?php echo esc_attr($t['partner_id']); ?>">
        <option value="">Carregando...</option>
      </select>
    </div>
    <?php endforeach; ?>
    </div>
    <?php foreach ($missing_data as $m):
        $mname = is_array($m) ? $m['name'] : $m; ?>
    <div class="missing-slot">
      <div class="cat-name"><?php echo esc_html($mname); ?></div>
      <div class="msg">⚠️ Nenhum parceiro cadastrado para esta categoria. Cadastre parceiros em VivaMais 2.0 → Parceiros.</div>
    </div>
    <?php endforeach; ?>
    <div id="extra-slots"></div>
  </div>
  <button onclick="vm2AddPartnerSlot()" style="width:100%;background:#fff;border:2px dashed #7c3aed;color:#7c3aed;border-radius:10px;padding:12px;font-size:14px;font-weight:700;cursor:pointer;margin-bottom:12px;">＋ Adicionar Parceiro</button>
  <button class="btn-confirm" id="btn-confirm" onclick="vm2ConfirmTeam()">✅ Confirmar Equipe</button>
  <div id="confirm-msg" style="text-align:center;margin-top:12px;font-size:14px;min-height:20px"></div>
<?php endif; ?>
</div>

<script>
var vm2AjaxUrl = <?php echo wp_json_encode($ajax_url); ?>;
var vm2Token   = <?php echo wp_json_encode($token); ?>;
var vm2AllPartners = <?php echo $partners_js; ?>;
var vm2TeamData = JSON.parse(<?php echo wp_json_encode(wp_json_encode($team_data)); ?>);

// Populate partner selects — FIX: comparar como string pois JSON pode retornar "15" ou 15
function vm2GetMatchingPartners(catId) {
    var catStr = String(catId);
    return vm2AllPartners.filter(function(p) {
        return p.cats.some(function(c){ return String(c) === catStr; });
    });
}

document.querySelectorAll('.partner-select').forEach(function(sel) {
    var catId   = sel.dataset.cat;
    var current = parseInt(sel.dataset.current);
    var matching = vm2GetMatchingPartners(catId);
    // Incluir parceiro atual mesmo que não tenha a categoria (segurança)
    var currentP = vm2AllPartners.find(function(p){ return p.id === current; });
    if (currentP && matching.findIndex(function(p){return p.id===current;}) < 0) matching.unshift(currentP);

    sel.innerHTML = matching.map(function(p) {
        return '<option value="'+p.id+'"'+(p.id===current?' selected':'')+'>'+p.name+'</option>';
    }).join('') || '<option value="">Nenhum parceiro para esta categoria</option>';
});

// Carrega todas as categorias WC para o selector de adicionar parceiro
var vm2AllWcCats = [];
(function(){
    var seen = {};
    vm2AllPartners.forEach(function(p){
        p.cats.forEach(function(c){
            var cs = String(c);
            if (!seen[cs]) { seen[cs] = true; vm2AllWcCats.push({id:cs, name:'Categoria '+cs}); }
        });
    });
})();

// Buscar nomes reais das categorias dos slots já existentes
document.querySelectorAll('.team-slot[data-cat]').forEach(function(slot){
    var catId = String(slot.dataset.cat);
    var catName = slot.querySelector('.cat-name') ? slot.querySelector('.cat-name').textContent.trim() : '';
    var existing = vm2AllWcCats.find(function(c){ return c.id === catId; });
    if (existing && catName) existing.name = catName;
    else if (catName && !existing) vm2AllWcCats.push({id:catId, name:catName});
});

var vm2ExtraSlotCount = 0;

function vm2AddPartnerSlot() {
    vm2ExtraSlotCount++;
    var slotId = 'extra-slot-' + vm2ExtraSlotCount;
    var container = document.getElementById('extra-slots');

    // Montar options de categorias
    var catOptions = '<option value="">— Selecione a categoria —</option>' +
        vm2AllWcCats.map(function(c){ return '<option value="'+c.id+'">'+c.name+'</option>'; }).join('');

    var div = document.createElement('div');
    div.className = 'team-slot';
    div.id = slotId;
    div.style.borderColor = '#c4b5fd';
    div.innerHTML =
        '<div class="cat-name" style="color:#7c3aed;display:flex;align-items:center;justify-content:space-between;">' +
        '<span>➕ Parceiro Adicional</span>' +
        '<button onclick="document.getElementById(\''+slotId+'\').remove()" style="background:none;border:none;cursor:pointer;font-size:16px;color:#ef4444">✕</button>' +
        '</div>' +
        '<label style="font-size:12px;color:#666;display:block;margin-bottom:4px">Categoria:</label>' +
        '<select class="extra-cat-select" data-slot="'+vm2ExtraSlotCount+'" onchange="vm2UpdateExtraPartners(this,'+vm2ExtraSlotCount+')" style="width:100%;padding:7px 10px;border:1px solid #d1d5db;border-radius:6px;font-size:13px;background:#fff;margin-bottom:8px">'+catOptions+'</select>' +
        '<label style="font-size:12px;color:#666;display:block;margin-bottom:4px">Parceiro:</label>' +
        '<select class="extra-partner-select" data-slot="'+vm2ExtraSlotCount+'" style="width:100%;padding:7px 10px;border:1px solid #d1d5db;border-radius:6px;font-size:13px;background:#fff">' +
        '<option value="">Selecione a categoria primeiro</option>' +
        '</select>';
    container.appendChild(div);
}

function vm2UpdateExtraPartners(catSel, slotId) {
    var catId = catSel.value;
    var partnerSel = document.querySelector('.extra-partner-select[data-slot="'+slotId+'"]');
    if (!catId) { partnerSel.innerHTML = '<option value="">Selecione a categoria primeiro</option>'; return; }
    var matching = vm2GetMatchingPartners(catId);
    partnerSel.innerHTML = matching.length
        ? '<option value="">— Selecione —</option>' + matching.map(function(p){ return '<option value="'+p.id+'">'+p.name+'</option>'; }).join('')
        : '<option value="">Nenhum parceiro para esta categoria</option>';
}

function vm2ConfirmTeam() {
    var btn = document.getElementById('btn-confirm');
    var msg = document.getElementById('confirm-msg');
    btn.disabled = true; btn.textContent = 'Confirmando...';

    // Build updated team data from selects (slots originais)
    var updatedTeam = JSON.parse(JSON.stringify(vm2TeamData));
    document.querySelectorAll('.partner-select').forEach(function(sel) {
        var catId = sel.dataset.cat;
        var newPartnerId = parseInt(sel.value);
        if (updatedTeam[catId] && newPartnerId) {
            var p = vm2AllPartners.find(function(p){ return p.id === newPartnerId; });
            updatedTeam[catId].partner_id   = newPartnerId;
            updatedTeam[catId].partner_name = p ? p.name : updatedTeam[catId].partner_name;
        }
    });

    // Incluir slots extras adicionados manualmente
    document.querySelectorAll('.extra-partner-select').forEach(function(sel, idx) {
        var partnerId = parseInt(sel.value);
        var catSel = document.querySelector('.extra-cat-select[data-slot="'+sel.dataset.slot+'"]');
        var catId = catSel ? catSel.value : '';
        var catName = catSel ? catSel.options[catSel.selectedIndex].text : '';
        if (partnerId && catId) {
            var p = vm2AllPartners.find(function(p){ return p.id === partnerId; });
            var key = 'extra_' + catId + '_' + idx;
            updatedTeam[key] = {
                cat_id: catId,
                cat_name: catName,
                partner_id: partnerId,
                partner_name: p ? p.name : 'Parceiro',
                is_extra: true
            };
        }
    });

    var fd = new FormData();
    fd.append('action','vm2_confirm_elenco');
    fd.append('token', vm2Token);
    fd.append('team_json', JSON.stringify(updatedTeam));
    fd.append('confirmed_by', 'admin_wa_link');

    fetch(vm2AjaxUrl, {method:'POST',body:fd})
        .then(function(r){return r.json();})
        .then(function(res){
            if (res.success) {
                msg.style.color='#16a34a';
                msg.textContent='✅ Equipe confirmada com sucesso!';
                setTimeout(function(){ location.reload(); }, 1200);
            } else {
                btn.disabled=false; btn.textContent='✅ Confirmar Equipe';
                msg.style.color='#dc2626';
                msg.textContent='❌ Erro ao confirmar. Tente novamente.';
            }
        });
}
</script>
</body>
</html>
<?php
}


add_action('wp_ajax_vm2_advance_partner_stage', function() {
    check_ajax_referer('vm2_nonce', 'nonce');
    global $wpdb;
    $id    = intval($_POST['event_id'] ?? 0);
    $stage = sanitize_text_field($_POST['stage'] ?? '');
    if ($id && $stage) $wpdb->update($wpdb->prefix . 'vm2_partner_events', ['stage'=>$stage,'updated_at'=>current_time('mysql')], ['id'=>$id]);
    wp_send_json_success();
});


// =============================================================
// FASE 8 — MÓDULO FINANCEIRO
// =============================================================

function vm2_create_payment_table() {
    global $wpdb;
    $charset = $wpdb->get_charset_collate();
    $sql = "CREATE TABLE IF NOT EXISTS {$wpdb->prefix}vm2_payments (
        id bigint(20) NOT NULL AUTO_INCREMENT,
        partner_id bigint(20) DEFAULT NULL,
        order_id bigint(20) DEFAULT NULL,
        amount decimal(10,2) NOT NULL DEFAULT 0,
        due_date date DEFAULT NULL,
        paid_at datetime DEFAULT NULL,
        reference varchar(300) DEFAULT NULL,
        notes text,
        status varchar(20) DEFAULT 'pending',
        created_at datetime DEFAULT CURRENT_TIMESTAMP,
        PRIMARY KEY (id),
        KEY partner_id (partner_id),
        KEY status (status)
    ) $charset;";
    require_once ABSPATH . 'wp-admin/includes/upgrade.php';
    dbDelta($sql);
}

add_action('admin_init', function() {
    if ( !get_option('vm2_payment_table_v1') ) {
        vm2_create_payment_table();
        update_option('vm2_payment_table_v1', '1');
    }
});

// ── FINANCEIRO V2 HELPERS ─────────────────────────────────────
function vm2_month_label_pt( $ym ) {
    $ms = ['01'=>'Janeiro','02'=>'Fevereiro','03'=>'Março','04'=>'Abril',
           '05'=>'Maio','06'=>'Junho','07'=>'Julho','08'=>'Agosto',
           '09'=>'Setembro','10'=>'Outubro','11'=>'Novembro','12'=>'Dezembro'];
    if (!preg_match('/^(\d{4})-(\d{2})$/', $ym, $m)) return $ym;
    return ($ms[$m[2]] ?? $m[2]) . ' ' . $m[1];
}
function vm2_fin_fmt_r( $v ) { return 'R$ ' . number_format((float)$v, 2, ',', '.'); }

// ── FINANCEIRO PAGE ─────────────────────────────────────────────

// ── FINANCEIRO: helpers UI ───────────────────────────────────────
function vm2_fin_filter_bar(string $tid, string $ph = 'Filtrar...'): void {
    $e = esc_js($tid);
    echo "<div style='margin-bottom:12px;display:flex;gap:10px;align-items:center;flex-wrap:wrap'>"
        . "<input type='text' oninput=\"vm2FinFilter(this,'{$e}')\" placeholder='🔍 {$ph}'"
        . " style='padding:7px 14px;border:1px solid #d1d5db;border-radius:8px;font-size:13px;width:260px;outline:none'"
        . " onfocus=\"this.style.borderColor='#7c3aed'\" onblur=\"this.style.borderColor='#d1d5db'\">"
        . "<span style='font-size:12px;color:#9ca3af;align-self:center'>Clique no cabeçalho para ordenar ⇅</span>"
        . "</div>";
}
function vm2_fin_thead(array $cols, string $tid, int $left = 1): void {
    $e = esc_js($tid);
    echo "<thead><tr style='background:#f3f4f6;border-bottom:2px solid #e5e7eb'>";
    foreach ($cols as $i => $h) {
        $align = $i < $left ? 'left' : 'right';
        echo "<th onclick=\"vm2FinSort('" . $e . "'," . $i . ")\" style='padding:10px 14px;"
           . "text-align:{$align};font-size:11px;font-weight:700;text-transform:uppercase;"
           . "white-space:nowrap;cursor:pointer;user-select:none;color:#374151;transition:background .1s'"
           . " onmouseenter=\"this.style.background='#e5e7eb'\" onmouseleave=\"this.style.background=''\">"
           . esc_html($h) . " <span class='vm2si' data-col='" . $i . "' style='color:#9ca3af;font-size:10px'>⇅</span></th>";
    }
    echo "</tr></thead>";
}

function vm2_financeiro_page() {
    if ( !current_user_can('manage_options') ) { wp_die('Forbidden'); }

    $dre_rows     = get_option('vm2_fin_dre',     []);
    $receber_rows = get_option('vm2_fin_receber',  []);
    $pagar_rows   = get_option('vm2_fin_pagar',    []);
    $last_sync    = get_option('vm2_fin_last_sync', '');
    $webhook_url  = get_option('vm2_fin_webhook_url', '');
    $syncing      = (bool) get_option('vm2_fin_sync_pending', 0);

    $sel_month = sanitize_text_field($_GET['fm'] ?? date('Y-m'));
    if ( !preg_match('/^\d{4}-\d{2}$/', $sel_month) ) $sel_month = date('Y-m');
    [$sel_year, $sel_m] = explode('-', $sel_month);

    $prev_m = date('Y-m', strtotime("{$sel_month}-01 -1 month"));
    $next_m = date('Y-m', strtotime("{$sel_month}-01 +1 month"));
    $base   = admin_url('admin.php');
    $tab    = sanitize_key($_GET['ftab'] ?? 'dre');
    $tabs   = ['dre'=>'💵 Caixa','competencia'=>'📅 Competência','receber'=>'💚 A Receber','pagar'=>'🔴 A Pagar','woo'=>'🛒 WooCommerce'];

    $mnames = ['01'=>'janeiro','02'=>'fevereiro','03'=>'março','04'=>'abril',
               '05'=>'maio','06'=>'junho','07'=>'julho','08'=>'agosto',
               '09'=>'setembro','10'=>'outubro','11'=>'novembro','12'=>'dezembro'];
    $cur_mname = $mnames[$sel_m] ?? '';
    $dre_row   = null;
    if ( is_array($dre_rows) ) {
        // Primeira passagem: procura match exato "Maio 2026"
        foreach ( $dre_rows as $row ) {
            if ( is_array($row) && isset($row['mes']) ) {
                $mes_lower = strtolower(trim($row['mes']));
                if ( $mes_lower === $cur_mname . ' ' . $sel_year ) {
                    $dre_row = $row; break;
                }
            }
        }
        // Segunda passagem: se não achou com ano, pega o ÚLTIMO match pelo nome do mês
        if ( !$dre_row ) {
            foreach ( $dre_rows as $row ) {
                if ( is_array($row) && isset($row['mes']) ) {
                    $mes_lower = strtolower(trim($row['mes']));
                    if ( $mes_lower === $cur_mname || strpos($mes_lower, $cur_mname) === 0 ) {
                        $dre_row = $row; // não faz break → pega o último
                    }
                }
            }
        }
    }

    $vendas  = (float)($dre_row['vendas']        ?? $dre_row['venda']          ?? 0);
    $custo   = (float)($dre_row['custo']         ?? $dre_row['custo_direto']    ?? 0);
    $bruto   = (float)($dre_row['bruto']         ?? $dre_row['bruto_vivamais']  ?? 0);
    $mkt     = (float)($dre_row['mkt']           ?? $dre_row['marketing']       ?? 0);
    $liquido = (float)($dre_row['liquido']       ?? 0);
    $m_bruta = (float)($dre_row['margem_bruta']  ?? 0);
    $roas    = (float)($dre_row['roas']          ?? 0);
    $vs_ant  = isset($dre_row['vs_mes_anterior']) && $dre_row['vs_mes_anterior'] !== '' ? (float)$dre_row['vs_mes_anterior'] : null;

    $sync_nonce   = wp_create_nonce('vm2_fin_sync');
    $rest_nonce   = wp_create_nonce('wp_rest');
    $last_fmt     = $last_sync ? date('d/m H\hi', strtotime($last_sync)) : 'nunca';
    $no_data      = empty($dre_rows);
    $month_label  = vm2_month_label_pt($sel_month);
    $rest_status_url = rest_url('vm-crm-v2/v1/financeiro/sync-status');
    ?>
    <div class="vm2-wrap" id="vm2-fin-wrap">

    <div style="display:flex;align-items:center;justify-content:space-between;flex-wrap:wrap;gap:12px;margin-bottom:20px">
        <h1 style="margin:0;font-size:22px;font-weight:700">💰 Financeiro</h1>
        <div style="display:flex;align-items:center;gap:10px;flex-wrap:wrap">
            <div style="display:flex;align-items:center;gap:4px;background:#f3f4f6;border-radius:8px;padding:4px">
                <a href="<?php echo esc_url(add_query_arg(['page'=>'vm2-financeiro','fm'=>$prev_m,'ftab'=>$tab],$base)); ?>" style="padding:4px 10px;border-radius:6px;color:#374151;text-decoration:none;font-size:13px">◀</a>
                <span style="padding:4px 12px;font-size:13px;font-weight:600;color:#111"><?php echo esc_html($month_label); ?></span>
                <a href="<?php echo esc_url(add_query_arg(['page'=>'vm2-financeiro','fm'=>$next_m,'ftab'=>$tab],$base)); ?>" style="padding:4px 10px;border-radius:6px;color:#374151;text-decoration:none;font-size:13px">▶</a>
            </div>
            <?php if ($webhook_url) : ?>
            <div style="display:flex;align-items:center;gap:8px">
                <button id="vm2-fin-sync-btn" onclick="vm2FinSync()" style="padding:8px 16px;background:#7c3aed;color:#fff;border:none;border-radius:8px;cursor:pointer;font-size:13px;font-weight:600;display:flex;align-items:center;gap:6px">
                    <span id="vm2-fin-sync-icon"><?php echo $syncing ? '⏳' : '🔄'; ?></span>
                    <span id="vm2-fin-sync-txt"><?php echo $syncing ? 'Sincronizando...' : 'Sincronizar GSheets'; ?></span>
                </button>
                <span style="font-size:11px;color:#9ca3af" id="vm2-fin-last">Última sync: <?php echo esc_html($last_fmt); ?></span>
            </div>
            <?php else : ?>
            <a href="<?php echo esc_url(admin_url('admin.php?page=vm2-settings#fin-webhook')); ?>" style="padding:8px 16px;background:#fef3c7;color:#92400e;border:1px solid #fde047;border-radius:8px;font-size:13px;font-weight:600;text-decoration:none">⚙️ Configurar Webhook</a>
            <?php endif; ?>
        </div>
    </div>

    <?php if ($no_data) : ?>
    <div style="background:#fef9c3;border:1px solid #fde047;border-radius:12px;padding:20px;margin-bottom:20px;text-align:center">
        <div style="font-size:32px;margin-bottom:8px">📊</div>
        <div style="font-weight:600;color:#713f12;margin-bottom:6px">Dados não sincronizados ainda</div>
        <div style="color:#a16207;font-size:13px">
            <?php if ($webhook_url) : ?>Clique em <strong>🔄 Sincronizar GSheets</strong> para importar os dados da planilha VIVAMAIS-VENDAS.
            <?php else : ?>Configure o webhook em <a href="<?php echo esc_url(admin_url('admin.php?page=vm2-settings')); ?>" style="color:#7c3aed">⚙️ Configurações</a> e depois sincronize.<?php endif; ?>
        </div>
    </div>
    <?php endif; ?>

    <div style="display:grid;grid-template-columns:repeat(auto-fit,minmax(160px,1fr));gap:12px;margin-bottom:24px">
    <?php
    $kpis = [
        ['💰 Vendas (Planilha)',  vm2_fin_fmt_r($vendas),  $dre_row ? number_format($m_bruta*100,1,',','.').'% margem bruta' : '—', '#10b981', 'woo'],
        ['💸 Custo Direto',       vm2_fin_fmt_r($custo),   'parceiros e artistas', '#ef4444', 'pagar'],
        ['🏦 Bruto VivaMais',     vm2_fin_fmt_r($bruto),   $vendas > 0 ? number_format($bruto/$vendas*100,1,',','.').'% das vendas' : '—', '#3b82f6', 'dre'],
        ['📢 Mkt/Tecnologia',     vm2_fin_fmt_r($mkt),     $roas > 0 ? 'ROAS: '.number_format($roas,2,',','.').'x' : '—', '#f59e0b', 'dre'],
        ['💵 Líquido',            vm2_fin_fmt_r($liquido),  $vs_ant !== null ? ($vs_ant >= 0 ? '▲ ' : '▼ ').number_format(abs($vs_ant)*100,1,',','.').'% vs mês ant.' : '—', $liquido >= 0 ? '#7c3aed' : '#ef4444', 'dre'],
        ['📈 ROAS',               number_format($roas,2,',','.').'x', $roas > 0 ? 'Retorno sobre adspend' : '—', $roas >= 5 ? '#10b981' : ($roas >= 2 ? '#f59e0b' : '#ef4444'), 'dre'],
    ];
    foreach ($kpis as [$lbl,$val,$sub,$cor,$ltab]) :
        $lhref = esc_js(add_query_arg(['page'=>'vm2-financeiro','fm'=>$sel_month,'ftab'=>$ltab],$base));
    ?>
    <div onclick="location.href='<?php echo $lhref; ?>'"
         onmouseenter="this.style.transform='translateY(-2px)';this.style.boxShadow='0 4px 14px rgba(0,0,0,.1)'"
         onmouseleave="this.style.transform='';this.style.boxShadow=''"
         style="background:#fff;border:1px solid #e5e7eb;border-radius:12px;padding:16px;border-top:4px solid <?php echo $cor; ?>;cursor:pointer;transition:transform .15s,box-shadow .15s">
        <div style="font-size:11px;color:#6b7280;margin-bottom:6px;font-weight:600;text-transform:uppercase"><?php echo $lbl; ?></div>
        <div style="font-size:20px;font-weight:700;color:#111;margin-bottom:3px"><?php echo $val; ?></div>
        <div style="font-size:11px;color:#9ca3af"><?php echo $sub; ?></div>
    </div>
    <?php endforeach; ?>
    </div>

    <div style="display:flex;gap:8px;margin-bottom:20px;flex-wrap:wrap">
    <?php foreach ($tabs as $tk => $tl) :
        $act  = ($tab === $tk);
        $turl = add_query_arg(['page'=>'vm2-financeiro','fm'=>$sel_month,'ftab'=>$tk],$base);
        $ts   = $act ? 'padding:8px 18px;border-radius:8px;background:#7c3aed;color:#fff;text-decoration:none;font-weight:600;font-size:14px'
                     : 'padding:8px 18px;border-radius:8px;background:#f3f4f6;color:#374151;text-decoration:none;font-size:14px';
    ?><a href="<?php echo esc_url($turl); ?>" style="<?php echo $ts; ?>"><?php echo $tl; ?></a>
    <?php endforeach; ?>
    </div>

    <?php
    if      ($tab === 'dre')          vm2_fin_tab_dre($dre_rows, $sel_month);
    elseif  ($tab === 'receber')      vm2_fin_tab_receber($receber_rows, $sel_month);
    elseif  ($tab === 'pagar')        vm2_fin_tab_pagar($pagar_rows, $sel_month);
    elseif  ($tab === 'competencia')  vm2_fin_tab_competencia($receber_rows, $pagar_rows, $sel_month);
    else                              vm2_fin_tab_woo($sel_month);
    ?>
    </div>

    <script>
    function vm2FinSync() {
        var btn  = document.getElementById('vm2-fin-sync-btn');
        var icon = document.getElementById('vm2-fin-sync-icon');
        var txt  = document.getElementById('vm2-fin-sync-txt');
        btn.disabled = true; icon.textContent = '⏳'; txt.textContent = 'Iniciando...';
        fetch(ajaxurl, {
            method:'POST', credentials:'same-origin',
            headers:{'Content-Type':'application/x-www-form-urlencoded'},
            body:'action=vm2_fin_trigger_sync&nonce=<?php echo esc_js($sync_nonce); ?>'
        }).then(r=>r.json()).then(d=>{
            if (d.success) { txt.textContent='Sincronizando...'; vm2FinPollStart=Date.now(); vm2FinPoll(); }
            else { icon.textContent='❌'; txt.textContent='Erro: '+(d.data||'falha'); btn.disabled=false; }
        }).catch(()=>{ icon.textContent='❌'; txt.textContent='Erro de rede'; btn.disabled=false; });
    }
    var vm2FinPollStart=null;
    function vm2FinPoll() {
        if (Date.now()-vm2FinPollStart>120000) {
            document.getElementById('vm2-fin-sync-txt').textContent='Timeout — tente novamente';
            document.getElementById('vm2-fin-sync-btn').disabled=false; return;
        }
        fetch('<?php echo esc_js($rest_status_url); ?>',
              {headers:{'X-WP-Nonce':'<?php echo esc_js($rest_nonce); ?>'},credentials:'same-origin'})
        .then(r=>r.json()).then(d=>{
            if (!d.syncing) {
                document.getElementById('vm2-fin-sync-icon').textContent='✅';
                document.getElementById('vm2-fin-sync-txt').textContent='Sincronizado!';
                var ls=document.getElementById('vm2-fin-last');
                if (ls && d.last_sync) {
                    var dt=new Date(d.last_sync.replace(' ','T'));
                    ls.textContent='Última sync: '+dt.toLocaleString('pt-BR',{day:'2-digit',month:'2-digit',hour:'2-digit',minute:'2-digit'}).replace(',','');
                }
                setTimeout(()=>location.reload(),1500);
            } else { setTimeout(vm2FinPoll,3000); }
        }).catch(()=>setTimeout(vm2FinPoll,4000));
    }
    // ── Sort + Filter (Financeiro) ────────────────────────────────
    var vm2SS={};
    function vm2FinFilter(inp,tid){
        var q=inp.value.toLowerCase();
        document.querySelectorAll('#'+tid+' tbody tr').forEach(function(r){
            r.style.display=r.textContent.toLowerCase().indexOf(q)>-1?'':'none';
        });
    }
    var VM2_MES={'janeiro':1,'fevereiro':2,'março':3,'marco':3,'abril':4,'maio':5,'junho':6,
                   'julho':7,'agosto':8,'setembro':9,'outubro':10,'novembro':11,'dezembro':12};
    function vm2ParseNum(v){
        var s=v.trim().toLowerCase();
        // "Janeiro 2025" / "Março\n2026" → ano*100 + mes
        var m=/^([a-záàãâéêíóôõúç]+)\s+(\d{4})$/.exec(s.replace(/\s+/g,' '));
        if(m&&VM2_MES[m[1]]){return parseInt(m[2])*100+VM2_MES[m[1]];}
        // date dd/mm/yyyy → yyyymmdd
        var d=/^(\d{1,2})\/(\d{1,2})\/(\d{2,4})$/.exec(v.trim());
        if(d){var y=d[3].length===2?'20'+d[3]:d[3];return parseInt(y+d[2].padStart(2,'0')+d[1].padStart(2,'0'));}
        // negative indicator
        var neg=v.indexOf('▼')>-1?-1:1;
        var n=parseFloat(v.replace(/[R$\s%x▲▼]/g,'').replace(/\./g,'').replace(',','.'));
        return isNaN(n)?null:neg*n;
    }
    function vm2FinSort(tid,col,forceDesc){
        var key=tid+'_'+col;
        var asc=forceDesc===true?false:(forceDesc===false?true:vm2SS[key]!=='asc');
        vm2SS[key]=asc?'asc':'desc';
        var tbody=document.querySelector('#'+tid+' tbody');
        if(!tbody)return;
        var rows=Array.from(tbody.querySelectorAll('tr'));
        rows.sort(function(a,b){
            var av=(a.cells[col]?a.cells[col].textContent:'').trim();
            var bv=(b.cells[col]?b.cells[col].textContent:'').trim();
            var an=vm2ParseNum(av),bn=vm2ParseNum(bv);
            if(an!==null&&bn!==null)return asc?an-bn:bn-an;
            return asc?av.localeCompare(bv,'pt-BR'):bv.localeCompare(av,'pt-BR');
        });
        rows.forEach(function(r){tbody.appendChild(r);});
        document.querySelectorAll('#'+tid+' .vm2si').forEach(function(s){
            var c=parseInt(s.getAttribute('data-col'));
            s.textContent=c===col?(asc?'▲':'▼'):'⇅';
            s.style.color=c===col?'#7c3aed':'#9ca3af';
        });
    }
    // Ordenação padrão: por mês desc (mais recente primeiro)
    // Executado inline — tabela já está no DOM quando o script roda
    (function(){
        if(document.getElementById('vm2-fin-dre')) vm2FinSort('vm2-fin-dre',0,true);
        if(document.getElementById('vm2-fin-rec')) vm2FinSort('vm2-fin-rec',0,true);
        if(document.getElementById('vm2-fin-pag')) vm2FinSort('vm2-fin-pag',0,true);
        if(document.getElementById('vm2-fin-woo')) vm2FinSort('vm2-fin-woo',6,true);
    })();
    <?php if ($syncing) : ?>
    document.getElementById('vm2-fin-sync-btn').disabled=true;
    vm2FinPollStart=Date.now(); vm2FinPoll();
    <?php endif; ?>
    </script>
    <?php
}

// ── TAB DRE ─────────────────────────────────────────────────────
function vm2_fin_tab_dre( $rows, $sel_month ) {
    if ( empty($rows) || !is_array($rows) ) {
        echo '<div style="text-align:center;padding:60px;color:#9ca3af">Sem dados — sincronize a planilha.</div>'; return;
    }
    [$sy,$sm] = explode('-',$sel_month);
    $mnames = ['01'=>'janeiro','02'=>'fevereiro','03'=>'março','04'=>'abril','05'=>'maio','06'=>'junho',
               '07'=>'julho','08'=>'agosto','09'=>'setembro','10'=>'outubro','11'=>'novembro','12'=>'dezembro'];
    $sel_mname = $mnames[$sm] ?? '';
    echo '<div style="display:flex;align-items:center;gap:10px;margin-bottom:12px;flex-wrap:wrap">';
    echo '<span style="background:#dbeafe;color:#1d4ed8;font-size:11px;font-weight:700;padding:3px 10px;border-radius:20px;letter-spacing:.5px">💵 REGIME DE CAIXA</span>';
    echo '<span style="color:#6b7280;font-size:12px">Receitas e despesas pelo mês em que o dinheiro entrou/saiu</span>';
    echo '</div>';
    vm2_fin_filter_bar('vm2-fin-dre', 'Filtrar por mês...');
    echo '<div style="overflow-x:auto">';
    echo '<table id="vm2-fin-dre" style="width:100%;border-collapse:collapse;background:#fff;border-radius:12px;overflow:hidden;box-shadow:0 1px 3px rgba(0,0,0,.08);min-width:800px">';
    vm2_fin_thead(['Mês','Vendas','Custo','Bruto VM','Mkt','Líquido','M.Bruta','ROAS','vs Ant.'], 'vm2-fin-dre', 1);
    echo '<tbody>';
    foreach ($rows as $row) {
        if (!is_array($row)||empty($row['mes'])) continue;
        $is_cur = strtolower($row['mes']) === $sel_mname;
        $bg     = $is_cur ? 'background:#f5f3ff;' : '';
        $fw     = $is_cur ? 'font-weight:700;' : '';
        $bl     = $is_cur ? 'border-left:4px solid #7c3aed;' : 'border-left:4px solid transparent;';
        $liq    = (float)($row['liquido']??0);
        $lc     = $liq>=0 ? '#065f46' : '#991b1b';
        $vs     = isset($row['vs_mes_anterior'])&&$row['vs_mes_anterior']!=='' ? (float)$row['vs_mes_anterior'] : null;
        $vs_s   = $vs!==null ? ($vs>=0?'▲ ':'▼ ').number_format(abs($vs)*100,1,',','.').'%' : '—';
        $vs_c   = $vs!==null&&$vs>=0 ? '#059669' : '#dc2626';
        echo "<tr style='border-bottom:1px solid #f3f4f6;{$bg}{$bl}'>";
        echo "<td style='padding:10px 14px;font-size:13px;{$fw}text-align:right'>".esc_html(ucfirst($row['mes'])).($is_cur?' ◄':'')."</td>";
        echo "<td style='padding:10px 14px;font-size:13px;{$fw}text-align:right'>".vm2_fin_fmt_r($row['vendas']??$row['venda']??0)."</td>";
        echo "<td style='padding:10px 14px;font-size:13px;text-align:right;color:#6b7280'>".vm2_fin_fmt_r($row['custo']??$row['custo_direto']??0)."</td>";
        echo "<td style='padding:10px 14px;font-size:13px;text-align:right'>".vm2_fin_fmt_r($row['bruto']??$row['bruto_vivamais']??0)."</td>";
        echo "<td style='padding:10px 14px;font-size:13px;text-align:right;color:#6b7280'>".vm2_fin_fmt_r($row['mkt']??$row['marketing']??0)."</td>";
        echo "<td style='padding:10px 14px;font-size:13px;text-align:right;color:{$lc};font-weight:600'>".vm2_fin_fmt_r($liq)."</td>";
        echo "<td style='padding:10px 14px;font-size:13px;text-align:right'>".number_format((float)($row['margem_bruta']??0)*100,1,',','.').'%'."</td>";
        echo "<td style='padding:10px 14px;font-size:13px;text-align:right'>".number_format((float)($row['roas']??0),2,',','.').'x'."</td>";
        echo "<td style='padding:10px 14px;font-size:13px;text-align:right;color:{$vs_c}'>{$vs_s}</td>";
        echo "</tr>";
    }
    echo '</tbody></table></div>';
}

// ── TAB A RECEBER ────────────────────────────────────────────────
function vm2_fin_tab_receber( $rows, $sel_month ) {
    if (empty($rows)||!is_array($rows)) {
        echo '<div style="text-align:center;padding:60px;color:#9ca3af">Sem dados — sincronize a planilha.</div>'; return;
    }
    $filtered = array_values(array_filter($rows, function($r) use($sel_month){
        if(isset($r['data_festa_ym'])&&!empty($r['data_festa_ym'])) return $r['data_festa_ym']===$sel_month;
        $df = $r['data_festa']??'';
        if(!$df) return false;
        if(preg_match('#^(\d{1,2})/(\d{1,2})/(\d{2,4})$#',$df,$m)){$y=$m[3];if(strlen($y)===2)$y='20'.$y;return sprintf('%04d-%02d',$y,$m[2])===$sel_month;}
        $ts=strtotime($df); if($ts) return date('Y-m',$ts)===$sel_month;
        return false;
    }));
    if (empty($filtered)) { echo '<div style="text-align:center;padding:40px;color:#9ca3af">Nenhum registro para '.esc_html(vm2_month_label_pt($sel_month)).'.</div>'; return; }
    $tot_e=0; $tot_f=0; $cnt_pago=0;
    vm2_fin_filter_bar('vm2-fin-rec', 'Filtrar por data, WhatsApp...');
    echo '<div style="overflow-x:auto">';
    echo '<table id="vm2-fin-rec" style="width:100%;border-collapse:collapse;background:#fff;border-radius:12px;overflow:hidden;box-shadow:0 1px 3px rgba(0,0,0,.08)">';
    vm2_fin_thead(['Data Festa','WhatsApp','Entrada','Final','Status'], 'vm2-fin-rec', 2);
    echo '<tbody>';
    foreach ($filtered as $r) {
        $e=(float)($r['entrada']??0); $f=(float)($r['final_valor']??$r['final']??0);
        $pago_raw=$r['status_entrada']??($r['pago']??null);
        $pago=($pago_raw===true||$pago_raw===1||strtoupper((string)$pago_raw)==='SIM');
        if($pago)$cnt_pago++;
        $tot_e+=$e; $tot_f+=$f;
        $badge=$pago?'<span style="padding:3px 10px;border-radius:20px;font-size:11px;font-weight:600;background:#d1fae5;color:#065f46">✅ Pago</span>'
                    :'<span style="padding:3px 10px;border-radius:20px;font-size:11px;font-weight:600;background:#fef3c7;color:#92400e">⏳ Pendente</span>';
        echo "<tr style='border-bottom:1px solid #f3f4f6'>";
        echo "<td style='padding:10px 14px;font-size:13px;font-weight:500'>".esc_html($r['data_festa']??'—')."</td>";
        echo "<td style='padding:10px 14px;font-size:13px;color:#6b7280'>".esc_html($r['whatsapp']??'—')."</td>";
        echo "<td style='padding:10px 14px;font-size:13px;font-weight:600'>".vm2_fin_fmt_r($e)."</td>";
        echo "<td style='padding:10px 14px;font-size:13px'>".($f>0?vm2_fin_fmt_r($f):'—')."</td>";
        echo "<td style='padding:10px 14px'>{$badge}</td>";
        echo "</tr>";
    }
    echo '</tbody>';
    echo "<tfoot><tr style='background:#f9fafb;border-top:2px solid #e5e7eb'>";
    echo "<td colspan='2' style='padding:10px 14px;font-weight:700;font-size:13px'>".count($filtered)." registro(s) — {$cnt_pago} pago(s)</td>";
    echo "<td style='padding:10px 14px;font-weight:700;color:#10b981'>".vm2_fin_fmt_r($tot_e)."</td>";
    echo "<td style='padding:10px 14px;font-weight:700;color:#3b82f6'>".($tot_f>0?vm2_fin_fmt_r($tot_f):'—')."</td>";
    echo "<td></td></tr></tfoot></table></div>";
}

// ── TAB A PAGAR ──────────────────────────────────────────────────
function vm2_fin_tab_pagar( $rows, $sel_month ) {
    if (empty($rows)||!is_array($rows)) {
        echo '<div style="text-align:center;padding:60px;color:#9ca3af">Sem dados — sincronize a planilha.</div>'; return;
    }
    $filtered = array_values(array_filter($rows, function($r) use($sel_month){
        if(isset($r['data_festa_ym'])&&!empty($r['data_festa_ym'])) return $r['data_festa_ym']===$sel_month;
        $df = $r['data_festa']??'';
        if(!$df) return false;
        if(preg_match('#^(\d{1,2})/(\d{1,2})/(\d{2,4})$#',$df,$m)){$y=$m[3];if(strlen($y)===2)$y='20'.$y;return sprintf('%04d-%02d',$y,$m[2])===$sel_month;}
        $ts=strtotime($df); if($ts) return date('Y-m',$ts)===$sel_month;
        return false;
    }));
    if (empty($filtered)) { echo '<div style="text-align:center;padding:40px;color:#9ca3af">Nenhum registro para '.esc_html(vm2_month_label_pt($sel_month)).'.</div>'; return; }
    $tot_c=0; $tot_b=0;
    vm2_fin_filter_bar('vm2-fin-pag', 'Filtrar por data, WhatsApp...');
    echo '<div style="overflow-x:auto">';
    echo '<table id="vm2-fin-pag" style="width:100%;border-collapse:collapse;background:#fff;border-radius:12px;overflow:hidden;box-shadow:0 1px 3px rgba(0,0,0,.08)">';
    vm2_fin_thead(['Data Festa','WhatsApp','Preço Venda','Custo','Entrada','Final','Bruto VM'], 'vm2-fin-pag', 2);
    echo '<tbody>';
    foreach ($filtered as $r) {
        $c=(float)($r['custo_parceiro']??$r['custo']??0);
        $b=(float)($r['bruto_vivamais']??0);
        $ent=(float)($r['entrada_recebida']??$r['entrada']??0);
        $fp=(float)($r['final_pagar']??$r['final_valor']??0);
        $tot_c+=$c; $tot_b+=$b;
        echo "<tr style='border-bottom:1px solid #f3f4f6'>";
        echo "<td style='padding:10px 14px;font-size:13px;font-weight:500'>".esc_html($r['data_festa']??'—')."</td>";
        echo "<td style='padding:10px 14px;font-size:13px;color:#6b7280'>".esc_html($r['whatsapp']??$r['cliente']??'—')."</td>";
        echo "<td style='padding:10px 14px;font-size:13px'>".vm2_fin_fmt_r($r['preco_venda']??0)."</td>";
        echo "<td style='padding:10px 14px;font-size:13px;font-weight:600;color:#ef4444'>".vm2_fin_fmt_r($c)."</td>";
        echo "<td style='padding:10px 14px;font-size:13px'>".vm2_fin_fmt_r($ent)."</td>";
        echo "<td style='padding:10px 14px;font-size:13px'>".($fp>0?vm2_fin_fmt_r($fp):'—')."</td>";
        echo "<td style='padding:10px 14px;font-size:13px;font-weight:600;color:#10b981'>".vm2_fin_fmt_r($b)."</td>";
        echo "</tr>";
    }
    echo '</tbody>';
    echo "<tfoot><tr style='background:#f9fafb;border-top:2px solid #e5e7eb'>";
    echo "<td colspan='3' style='padding:10px 14px;font-weight:700;font-size:13px'>".count($filtered)." registro(s)</td>";
    echo "<td style='padding:10px 14px;font-weight:700;color:#ef4444'>".vm2_fin_fmt_r($tot_c)."</td>";
    echo "<td colspan='2'></td>";
    echo "<td style='padding:10px 14px;font-weight:700;color:#10b981'>".vm2_fin_fmt_r($tot_b)."</td>";
    echo "</tr></tfoot></table></div>";
}


// ── HELPER: Dia da semana PT-BR ──────────────────────────────────────────────
function vm2_dia_semana_ptbr( $ts ) {
    $map = [
        'Sunday'    => 'Domingo',
        'Monday'    => 'Segunda-feira',
        'Tuesday'   => 'Terça-feira',
        'Wednesday' => 'Quarta-feira',
        'Thursday'  => 'Quinta-feira',
        'Friday'    => 'Sexta-feira',
        'Saturday'  => 'Sábado',
    ];
    return $map[ date('l', $ts) ] ?? '';
}

// ── HELPER: Extrair data do evento de um pedido WC ───────────────────────────
function vm2_get_order_event_ts( $order ) {
    foreach ( $order->get_items() as $item ) {
        $bd = $item->get_meta('yith_booking_data');
        if ( is_string($bd) ) $bd = maybe_unserialize($bd);
        if ( is_array($bd) && ! empty($bd['from']) ) {
            $ts = is_numeric($bd['from']) ? (int)$bd['from'] : strtotime($bd['from']);
            if ( $ts > 0 ) return $ts;
        }
    }
    foreach ( ['_data_evento','data_evento','_yith_booking_start'] as $mk ) {
        $v = $order->get_meta($mk);
        if ( $v ) {
            $ts = is_numeric($v) ? (int)$v : strtotime($v);
            if ( $ts > 0 ) return $ts;
        }
    }
    return null;
}

// ── TAB Por Evento (Regime de Competência) ───────────────────────
function vm2_fin_tab_competencia( $receber_rows, $pagar_rows, $sel_month ) {
    echo '<div style="display:flex;align-items:center;gap:10px;margin-bottom:12px;flex-wrap:wrap">';
    echo '<span style="background:#dcfce7;color:#15803d;font-size:11px;font-weight:700;padding:3px 10px;border-radius:20px;letter-spacing:.5px">📅 REGIME DE COMPETÊNCIA</span>';
    echo '<span style="color:#6b7280;font-size:12px">Receitas e despesas pelo mês em que o evento acontece</span>';
    echo '</div>';
    [$sel_yr, $sel_mo] = explode('-', $sel_month);
    $sel_key = $sel_yr . $sel_mo; // YYYYMM

    $mnames_pt = [
        '01'=>'Janeiro','02'=>'Fevereiro','03'=>'Março','04'=>'Abril',
        '05'=>'Maio','06'=>'Junho','07'=>'Julho','08'=>'Agosto',
        '09'=>'Setembro','10'=>'Outubro','11'=>'Novembro','12'=>'Dezembro',
    ];

    $by_month = [];

    // Agrupa A RECEBER por mês do evento
    foreach ((array)$receber_rows as $r) {
        $df = trim($r['data_festa'] ?? '');
        if (!$df) continue;
        $parts = explode('/', $df);
        if (count($parts) < 3) continue;
        $mes_num = sprintf('%02d', (int)$parts[1]);
        $ano_num = sprintf('%04d', (int)$parts[2]);
        $key = $ano_num . $mes_num;
        if (!isset($by_month[$key])) {
            $by_month[$key] = [
                'label'     => ($mnames_pt[$mes_num] ?? '?') . ' ' . $ano_num,
                'receita'   => 0, 'recebido'  => 0, 'a_receber' => 0,
                'custo'     => 0, 'pago_parc' => 0, 'a_pagar'   => 0,
                'bruto'     => 0, 'n_eventos' => 0,
            ];
        }
        $entrada = (float)($r['entrada'] ?? 0);
        $final   = (float)($r['final']   ?? 0);
        $pago    = !empty($r['pago']);
        $by_month[$key]['receita']   += $entrada + $final;
        $by_month[$key]['recebido']  += $entrada + ($pago ? $final : 0);
        $by_month[$key]['a_receber'] += $pago ? 0 : $final;
        $by_month[$key]['n_eventos'] += 1;
    }

    // Agrupa A PAGAR por mês do evento
    foreach ((array)$pagar_rows as $r) {
        $df = trim($r['data_festa'] ?? '');
        if (!$df) continue;
        $parts = explode('/', $df);
        if (count($parts) < 3) continue;
        $mes_num = sprintf('%02d', (int)$parts[1]);
        $ano_num = sprintf('%04d', (int)$parts[2]);
        $key = $ano_num . $mes_num;
        if (!isset($by_month[$key])) {
            $by_month[$key] = [
                'label'     => ($mnames_pt[$mes_num] ?? '?') . ' ' . $ano_num,
                'receita'   => 0, 'recebido'  => 0, 'a_receber' => 0,
                'custo'     => 0, 'pago_parc' => 0, 'a_pagar'   => 0,
                'bruto'     => 0, 'n_eventos' => 0,
            ];
        }
        $by_month[$key]['custo']     += (float)($r['custo_parceiro'] ?? 0);
        $by_month[$key]['pago_parc'] += (float)($r['entrada_recebida'] ?? $r['entrada'] ?? 0);
        $by_month[$key]['a_pagar']   += (float)($r['final_pagar'] ?? 0);
        $by_month[$key]['bruto']     += (float)($r['bruto_vivamais'] ?? 0);
    }

    // Inclui eventos futuros da AGENDA (meses sem dados financeiros ainda)
    $gs_events = get_option('vm2_agenda_gsheets', []);
    foreach ((array)$gs_events as $ev) {
        $df = trim($ev['data_festa'] ?? $ev['data'] ?? '');
        if (!$df) continue;
        $parts = explode('/', $df);
        if (count($parts) < 3) continue;
        $mes_num = sprintf('%02d', (int)$parts[1]);
        $ano_num = sprintf('%04d', (int)$parts[2]);
        $key = $ano_num . $mes_num;
        if (!isset($by_month[$key])) {
            $by_month[$key] = [
                'label'       => ($mnames_pt[$mes_num] ?? '?') . ' ' . $ano_num,
                'receita'     => 0, 'recebido'  => 0, 'a_receber' => 0,
                'custo'       => 0, 'pago_parc' => 0, 'a_pagar'   => 0,
                'bruto'       => 0, 'n_eventos' => 0, 'agenda_only' => true,
            ];
        }
        // só conta eventos da agenda — não duplica contagem de A RECEBER
        if ( empty($by_month[$key]['agenda_only']) ) continue;
        $by_month[$key]['n_eventos'] += 1;
    }


    // ─── Fonte WC: pedidos com data do evento via YITH ─────────────────────────
    // Preenche meses que o A RECEBER não cobre (ex: eventos futuros recém-vendidos)
    $receber_months = [];
    foreach ( (array)$receber_rows as $r ) {
        $df = trim($r['data_festa'] ?? '');
        if ( !$df ) continue;
        $parts = explode('/', $df);
        if ( count($parts) < 3 ) continue;
        $receber_months[ sprintf('%04d%02d', (int)$parts[2], (int)$parts[1]) ] = true;
    }

    if ( function_exists('wc_get_orders') ) {
        $wc_statuses = ['processing','contract-signed','signing-pending','on-hold','completed'];
        $wc_orders   = wc_get_orders([
            'status'  => $wc_statuses,
            'limit'   => 1000,
            'orderby' => 'date',
            'order'   => 'DESC',
        ]);
        foreach ( $wc_orders as $worder ) {
            $ev_ts = vm2_get_order_event_ts( $worder );
            if ( ! $ev_ts ) continue;
            $mes_num = sprintf('%02d', (int) wp_date('m', $ev_ts) );
            $ano_num = sprintf('%04d', (int) wp_date('Y', $ev_ts) );
            $key     = $ano_num . $mes_num;
            // Só adiciona se A RECEBER ainda não cobre este mês
            if ( ! empty($receber_months[$key]) ) continue;
            if ( ! isset($by_month[$key]) ) {
                $by_month[$key] = [
                    'label'      => ($mnames_pt[$mes_num] ?? '?') . ' ' . $ano_num,
                    'receita'    => 0, 'recebido'   => 0, 'a_receber' => 0,
                    'custo'      => 0, 'pago_parc'  => 0, 'a_pagar'   => 0,
                    'bruto'      => 0, 'n_eventos'  => 0, 'wc_source' => true,
                ];
            }
            $total = (float) $worder->get_total();
            $st    = $worder->get_status();
            $by_month[$key]['receita']   += $total;
            $by_month[$key]['n_eventos'] += 1;
            if ( in_array($st, ['processing','completed'], true) ) {
                $by_month[$key]['recebido']  += $total;
            } else {
                $by_month[$key]['a_receber'] += $total;
            }
        }
    }

    krsort($by_month); // mais recente primeiro

    if (empty($by_month)) {
        echo '<div style="text-align:center;padding:60px;color:#9ca3af">Sem dados. Clique em 🔄 Sincronizar para carregar.</div>';
        return;
    }

    $sel = $by_month[$sel_key] ?? null;

    // ── KPI Cards do mês selecionado ─────────────────────────────
    if ($sel) {
        $margem   = $sel['receita'] - $sel['custo'];
        $pct_mg   = $sel['receita'] > 0 ? ($margem / $sel['receita'] * 100) : 0;
        $liq_cai  = $sel['recebido'] - $sel['pago_parc'];
        $liq_col  = $liq_cai >= 0 ? '#10b981' : '#ef4444';
        $cards = [
            ['💰 Receita Bruta',      vm2_fin_fmt_r($sel['receita']),    'Faturamento total de eventos', '#10b981'],
            ['💸 CMV',                vm2_fin_fmt_r($sel['custo']),      'Custo das Mercadorias Vendidas', '#ef4444'],
            ['📊 Margem Bruta',       vm2_fin_fmt_r($margem),            number_format($pct_mg,1,',','.').'% de margem', $margem >= 0 ? '#7c3aed' : '#ef4444'],
            ['✅ Recebido',           vm2_fin_fmt_r($sel['recebido']),   'Entradas + finais confirmados', '#3b82f6'],
            ['⏳ A Receber',          vm2_fin_fmt_r($sel['a_receber']),  'Finais pendentes (clientes)', '#f59e0b'],
            ['✅ Pago a Parceiros',   vm2_fin_fmt_r($sel['pago_parc']), 'Entradas pagas a parceiros', '#6366f1'],
            ['⏳ A Pagar a Parceiros',vm2_fin_fmt_r($sel['a_pagar']),   'Finais devidos a parceiros', '#f97316'],
        ];
        echo '<div style="display:grid;grid-template-columns:repeat(auto-fit,minmax(150px,1fr));gap:12px;margin-bottom:20px">';
        foreach ($cards as [$title,$val,$sub,$color]) {
            echo "<div style='background:#fff;border-radius:12px;padding:16px 18px;box-shadow:0 1px 3px rgba(0,0,0,.08);border-left:4px solid {$color}'>";
            echo "<div style='font-size:11px;color:#6b7280;margin-bottom:4px'>".esc_html($title)."</div>";
            echo "<div style='font-size:19px;font-weight:700;color:{$color}'>".esc_html($val)."</div>";
            echo "<div style='font-size:11px;color:#9ca3af;margin-top:4px'>".esc_html($sub)."</div>";
            echo "</div>";
        }
        echo '</div>';

        // Saldo de caixa do mês
        echo "<div style='background:#fff;border-radius:12px;padding:14px 20px;box-shadow:0 1px 3px rgba(0,0,0,.08);margin-bottom:24px;display:flex;flex-wrap:wrap;gap:20px;align-items:center'>";
        echo "<div><span style='font-size:12px;color:#6b7280'>🏦 Saldo líquido de caixa — eventos em ".esc_html($sel['label'])."</span><br>";
        echo "<span style='font-weight:700;font-size:24px;color:{$liq_col}'>".vm2_fin_fmt_r($liq_cai)."</span>";
        echo "<span style='color:#6b7280;font-size:13px;margin-left:10px'>recebido de clientes − pago a parceiros</span></div>";
        echo "<div style='color:#6b7280;font-size:13px'>".intval($sel['n_eventos'])." evento(s)</div>";
        echo "</div>";
    } else {
        echo '<div style="background:#fff;border-radius:12px;padding:14px 20px;box-shadow:0 1px 3px rgba(0,0,0,.08);margin-bottom:24px;color:#9ca3af;text-align:center">Sem eventos em '.esc_html(($mnames_pt[$sel_mo] ?? '').' '.$sel_yr).'.</div>';
    }

    // ── Tabela consolidada de todos os meses ──────────────────────
    vm2_fin_filter_bar('vm2-fin-comp', 'Filtrar por mês...');
    echo '<div style="overflow-x:auto">';
    echo '<table id="vm2-fin-comp" style="width:100%;border-collapse:collapse;background:#fff;border-radius:12px;overflow:hidden;box-shadow:0 1px 3px rgba(0,0,0,.08);min-width:900px">';
    vm2_fin_thead(['Mês Evento','Eventos','Receita Bruta','CMV','Margem Bruta','% Mg','✅ Recebido','⏳ A Receber','✅ Pago Parc.','⏳ A Pagar'], 'vm2-fin-comp', 1);
    echo '<tbody>';

    $tot = ['receita'=>0,'custo'=>0,'recebido'=>0,'a_receber'=>0,'pago_parc'=>0,'a_pagar'=>0,'n_eventos'=>0];

    foreach ($by_month as $key => $row) {
        $mg    = $row['receita'] - $row['custo'];
        $pct   = $row['receita'] > 0 ? ($mg / $row['receita'] * 100) : 0;
        $lc    = $mg >= 0 ? '#10b981' : '#ef4444';
        $is_sel = ($key === $sel_key);
        $bg    = $is_sel ? 'background:#f5f3ff;' : '';
        $fw    = $is_sel ? 'font-weight:700;' : '';
        foreach (['receita','custo','recebido','a_receber','pago_parc','a_pagar','n_eventos'] as $k)
            $tot[$k] += $row[$k];
        $agenda_badge = !empty($row['agenda_only']) ? ' <span style="background:#dbeafe;color:#1d4ed8;font-size:10px;padding:1px 6px;border-radius:10px;font-weight:600">📅 agenda</span>' : '';
        $wc_badge = !empty($row['wc_source']) ? ' <span style="background:#dbeafe;color:#1d4ed8;font-size:10px;padding:1px 6px;border-radius:10px">🛒 WC</span>' : '';
        echo "<tr style='border-bottom:1px solid #f3f4f6;{$bg}'>";
        echo "<td style='padding:10px 14px;font-size:13px;{$fw}'>".esc_html($row['label']).$agenda_badge.$wc_badge."</td>";
        echo "<td style='padding:10px 14px;font-size:13px;text-align:right;color:#6b7280'>".intval($row['n_eventos'])."</td>";
        echo "<td style='padding:10px 14px;font-size:13px;text-align:right;font-weight:600'>".vm2_fin_fmt_r($row['receita'])."</td>";
        echo "<td style='padding:10px 14px;font-size:13px;text-align:right;color:#ef4444'>".vm2_fin_fmt_r($row['custo'])."</td>";
        echo "<td style='padding:10px 14px;font-size:13px;text-align:right;color:{$lc};font-weight:600'>".vm2_fin_fmt_r($mg)."</td>";
        echo "<td style='padding:10px 14px;font-size:13px;text-align:right;color:{$lc}'>".number_format($pct,1,',','.').'%'."</td>";
        echo "<td style='padding:10px 14px;font-size:13px;text-align:right;color:#3b82f6'>".vm2_fin_fmt_r($row['recebido'])."</td>";
        echo "<td style='padding:10px 14px;font-size:13px;text-align:right;color:#f59e0b'>".vm2_fin_fmt_r($row['a_receber'])."</td>";
        echo "<td style='padding:10px 14px;font-size:13px;text-align:right;color:#6366f1'>".vm2_fin_fmt_r($row['pago_parc'])."</td>";
        echo "<td style='padding:10px 14px;font-size:13px;text-align:right;color:#f97316'>".vm2_fin_fmt_r($row['a_pagar'])."</td>";
        echo "</tr>";
    }
    echo '</tbody>';

    // Footer totais
    $tot_mg  = $tot['receita'] - $tot['custo'];
    $tot_pct = $tot['receita'] > 0 ? ($tot_mg / $tot['receita'] * 100) : 0;
    $tot_lc  = $tot_mg >= 0 ? '#10b981' : '#ef4444';
    echo "<tfoot><tr style='background:#f9fafb;border-top:2px solid #e5e7eb'>";
    echo "<td style='padding:10px 14px;font-weight:700;font-size:13px'>TOTAL (".count($by_month)." meses)</td>";
    echo "<td style='padding:10px 14px;font-weight:700;text-align:right'>".intval($tot['n_eventos'])."</td>";
    echo "<td style='padding:10px 14px;font-weight:700;text-align:right'>".vm2_fin_fmt_r($tot['receita'])."</td>";
    echo "<td style='padding:10px 14px;font-weight:700;text-align:right;color:#ef4444'>".vm2_fin_fmt_r($tot['custo'])."</td>";
    echo "<td style='padding:10px 14px;font-weight:700;text-align:right;color:{$tot_lc}'>".vm2_fin_fmt_r($tot_mg)."</td>";
    echo "<td style='padding:10px 14px;font-weight:700;text-align:right;color:{$tot_lc}'>".number_format($tot_pct,1,',','.').'%'."</td>";
    echo "<td style='padding:10px 14px;font-weight:700;text-align:right;color:#3b82f6'>".vm2_fin_fmt_r($tot['recebido'])."</td>";
    echo "<td style='padding:10px 14px;font-weight:700;text-align:right;color:#f59e0b'>".vm2_fin_fmt_r($tot['a_receber'])."</td>";
    echo "<td style='padding:10px 14px;font-weight:700;text-align:right;color:#6366f1'>".vm2_fin_fmt_r($tot['pago_parc'])."</td>";
    echo "<td style='padding:10px 14px;font-weight:700;text-align:right;color:#f97316'>".vm2_fin_fmt_r($tot['a_pagar'])."</td>";
    echo "</tr></tfoot></table></div>";

    // Legenda
    echo "<div style='margin-top:16px;padding:12px 16px;background:#f8fafc;border-radius:8px;font-size:12px;color:#6b7280;line-height:1.8'>";
    echo "<strong>📚 Glossário:</strong>&nbsp;";
    echo "<strong>Receita Bruta</strong> = valor total contratado (entrada + final a receber) dos eventos do mês &nbsp;•&nbsp; ";
    echo "<strong>CMV</strong> = Custo da Mercadoria Vendida (custo parceiros/artistas) &nbsp;•&nbsp; ";
    echo "<strong>Margem Bruta</strong> = Receita − CMV &nbsp;•&nbsp; ";
    echo "<strong>Regime de Competência</strong> = agrupado pela <em>data do evento</em> (≠ data da venda na aba DRE)";
    echo "</div>";
}

// ── TAB WooCommerce ──────────────────────────────────────────────
function vm2_fin_tab_woo( $sel_month ) {
    [$yr,$mo] = explode('-',$sel_month);
    $d_after  = "{$yr}-{$mo}-01";
    $d_before = date('Y-m-t', strtotime($d_after));
    $ids = wc_get_orders(['status'=>['processing','completed'],'limit'=>200,'orderby'=>'date','order'=>'DESC','return'=>'ids',
        'date_after'=>$d_after.'T00:00:00','date_before'=>$d_before.'T23:59:59']);
    if (empty($ids)) {
        echo '<div style="text-align:center;padding:60px;color:#9ca3af">Sem pedidos WooCommerce em '.esc_html(vm2_month_label_pt($sel_month)).'.</div>'; return;
    }
    $total=0;
    vm2_fin_filter_bar('vm2-fin-woo', 'Filtrar por pedido, cliente...');
    echo '<div style="overflow-x:auto">';
    echo '<table id="vm2-fin-woo" style="width:100%;border-collapse:collapse;background:#fff;border-radius:12px;overflow:hidden;box-shadow:0 1px 3px rgba(0,0,0,.08)">';
    vm2_fin_thead(['#Pedido','Cliente','Data Evento','Valor','Forma Pgto','Status','Cadastro'], 'vm2-fin-woo', 2);
    echo '<tbody>';
    foreach ($ids as $oid) {
        $o=wc_get_order($oid); if(!$o)continue;
        $val=(float)$o->get_total(); $total+=$val;
        $ev_raw=$o->get_meta('_billing_event_date'); $ev_ts=vm2_event_date_to_ts($ev_raw);
        $ev_fmt=$ev_ts?date('d/m/Y',$ev_ts):($ev_raw?:$ev_raw);
        $st=$o->get_status();
        if($st==='completed'){$sbg='#d1fae5';$sc='#065f46';$sl='✅ Concluído';}
        elseif($st==='processing'){$sbg='#dbeafe';$sc='#1e40af';$sl='⚙️ Processing';}
        else{$sbg='#f3f4f6';$sc='#374151';$sl=ucfirst($st);}
        $name=esc_html(trim($o->get_billing_first_name().' '.$o->get_billing_last_name()));
        $sale_date=$o->get_date_created()?$o->get_date_created()->date('d/m/Y'):'—';
        $pgto=esc_html($o->get_payment_method_title()?:'—');
        $ourl=admin_url('post.php?post='.intval($oid).'&action=edit');
        echo "<tr style='border-bottom:1px solid #f3f4f6'>";
        echo "<td style='padding:10px 14px;font-size:13px'><a href='".esc_url($ourl)."' style='color:#7c3aed;font-weight:600'>#".intval($oid)."</a></td>";
        echo "<td style='padding:10px 14px;font-size:13px;font-weight:500'>{$name}</td>";
        echo "<td style='padding:10px 14px;font-size:13px'>".esc_html($ev_fmt)."</td>";
        echo "<td style='padding:10px 14px;font-size:13px;font-weight:600'>R\$ ".number_format($val,2,',','.')."</td>";
        echo "<td style='padding:10px 14px;font-size:13px;color:#6b7280'>{$pgto}</td>";
        echo "<td style='padding:10px 14px'><span style='padding:3px 10px;border-radius:20px;font-size:11px;font-weight:600;background:{$sbg};color:{$sc}'>{$sl}</span></td>";
        echo "<td style='padding:10px 14px;font-size:13px;color:#6b7280'>{$sale_date}</td>";
        echo "</tr>";
    }
    echo '</tbody>';
    echo "<tfoot><tr style='background:#f9fafb;border-top:2px solid #e5e7eb'>";
    echo "<td colspan='3' style='padding:10px 14px;font-weight:700;font-size:13px'>TOTAL (".count($ids)." pedidos)</td>";
    echo "<td style='padding:10px 14px;font-weight:700;font-size:14px;color:#7c3aed'>R\$ ".number_format($total,2,',','.')."</td>";
    echo "<td colspan='3'></td></tr></tfoot></table></div>";
}

// ── AJAX: PAGAMENTOS ─────────────────────────────────────────
add_action('wp_ajax_vm2_save_payment', function() {
    check_ajax_referer('vm2_nonce', 'nonce');
    global $wpdb;
    $partner_id = intval($_POST['partner_id'] ?? 0);
    $amount     = floatval($_POST['amount'] ?? 0);
    $due_date   = sanitize_text_field($_POST['due_date'] ?? '');
    $reference  = sanitize_text_field($_POST['reference'] ?? '');
    $notes      = sanitize_textarea_field($_POST['notes'] ?? '');
    if ($amount <= 0) { wp_send_json_error('Valor inválido'); return; }
    $r = $wpdb->insert($wpdb->prefix . 'vm2_payments', [
        'partner_id'  => $partner_id ?: null,
        'amount'      => $amount,
        'due_date'    => $due_date ?: null,
        'reference'   => $reference,
        'notes'       => $notes,
        'status'      => 'pending',
        'created_at'  => current_time('mysql'),
    ]);
    if ($r === false) wp_send_json_error($wpdb->last_error);
    else wp_send_json_success(['id' => $wpdb->insert_id]);
});

add_action('wp_ajax_vm2_confirm_payment', function() {
    check_ajax_referer('vm2_nonce', 'nonce');
    global $wpdb;
    $id = intval($_POST['id'] ?? 0);
    if ($id) $wpdb->update($wpdb->prefix . 'vm2_payments',
        ['status'=>'paid', 'paid_at'=>current_time('mysql')], ['id'=>$id]);
    wp_send_json_success();
});

add_action('wp_ajax_vm2_delete_payment', function() {
    check_ajax_referer('vm2_nonce', 'nonce');
    global $wpdb;
    $id = intval($_POST['id'] ?? 0);
    if ($id) $wpdb->delete($wpdb->prefix . 'vm2_payments', ['id'=>$id]);
    wp_send_json_success();
});


// ── REST: FINANCEIRO SYNC ───────────────────────────────────────
add_action('rest_api_init', function() {
    register_rest_route('vm-crm-v2/v1', '/financeiro/sync', [
        'methods'             => 'POST',
        'callback'            => 'vm2_fin_rest_receive',
        'permission_callback' => 'vm2_fin_rest_auth',
    ]);
    register_rest_route('vm-crm-v2/v1', '/financeiro/sync-status', [
        'methods'             => 'GET',
        'callback'            => function() {
            return rest_ensure_response([
                'last_sync' => get_option('vm2_fin_last_sync', ''),
                'syncing'   => (bool) get_option('vm2_fin_sync_pending', 0),
            ]);
        },
        'permission_callback' => function() { return current_user_can('manage_options'); },
    ]);
});
function vm2_fin_rest_auth( $request ) {
    $auth     = $request->get_header('Authorization');
    $expected = 'Bearer ' . get_option('vm2_fin_sync_token', 'vm2fsync_9kqw3p7x');
    return $auth === $expected;
}
function vm2_fin_rest_receive( $request ) {
    $data = $request->get_json_params();
    if ( !is_array($data) ) return new WP_Error('bad_request','Expected JSON',['status'=>400]);
    if ( isset($data['dre']) )     update_option('vm2_fin_dre',     $data['dre'],     false);
    if ( isset($data['receber']) ) update_option('vm2_fin_receber', $data['receber'], false);
    if ( isset($data['pagar']) )   update_option('vm2_fin_pagar',   $data['pagar'],   false);
    update_option('vm2_fin_last_sync', current_time('mysql'), false);
    delete_option('vm2_fin_sync_pending');
    return rest_ensure_response(['success'=>true,'synced_at'=>current_time('mysql')]);
}

// ── AJAX: TRIGGER SYNC ──────────────────────────────────────────
add_action('wp_ajax_vm2_fin_trigger_sync', function() {
    check_ajax_referer('vm2_fin_sync','nonce');
    if (!current_user_can('manage_options')) { wp_send_json_error('forbidden'); }
    $webhook_url = get_option('vm2_fin_webhook_url','');
    if (!$webhook_url) { wp_send_json_error('Webhook URL não configurado em Configurações.'); }
    update_option('vm2_fin_sync_pending',1,false);
    wp_remote_post($webhook_url,[
        'timeout'  => 0.01,
        'blocking' => false,
        'body'     => json_encode(['source'=>'vivamais-crm-v2','action'=>'sync_financeiro']),
        'headers'  => ['Content-Type'=>'application/json'],
        'sslverify'=> false,
    ]);
    wp_send_json_success(['message'=>'Sincronização iniciada...']);
});

// ── REST: AGENDA SYNC ──────────────────────────────────────────
// ── REST: Encerrar promo ativa (substituindo vm-promo/v1/end deletado) ──────
add_action('rest_api_init', function() {
    register_rest_route('vm-crm-v2/v1', '/promos/end', [
        'methods'             => 'POST',
        'callback'            => 'vm2_rest_promos_end',
        'permission_callback' => function() { return current_user_can('manage_options'); },
    ]);
});
function vm2_rest_promos_end( $request ) {
    global $wpdb;
    $tbl_disc = 'wz_active_discounts';
    $params   = $request->get_json_params();
    $id       = !empty($params['id']) ? intval($params['id']) : 0;
    if ( $id > 0 ) {
        $promo = $wpdb->get_row( $wpdb->prepare("SELECT * FROM {$tbl_disc} WHERE id=%d AND reverted_at IS NULL", $id) );
    } else {
        $promo = $wpdb->get_row( "SELECT * FROM {$tbl_disc} WHERE reverted_at IS NULL ORDER BY applied_at DESC LIMIT 1" );
    }
    if ( ! $promo ) {
        return rest_ensure_response(['success'=>false,'message'=>'Nenhuma promo ativa.']);
    }
    // Reverter preço WooCommerce
    $product = function_exists('wc_get_product') ? wc_get_product($promo->product_id) : null;
    if ( $product ) {
        $product->set_sale_price('');
        $product->save();
    }
    // v1.5.18: Deletar cupom WooCommerce permanentemente (não deixar lixo)
    if ( !empty($promo->coupon_code) ) {
        $coupon_post = get_page_by_title( $promo->coupon_code, OBJECT, 'shop_coupon' );
        if ( $coupon_post ) {
            wp_delete_post( $coupon_post->ID, true );
        }
    }
    // Marcar como encerrada
    $wpdb->update( $tbl_disc, ['reverted_at'=>current_time('mysql')], ['id'=>$promo->id] );
    return rest_ensure_response(['success'=>true]);
}

add_action('rest_api_init', function() {
    register_rest_route('vm-crm-v2/v1', '/agenda/sync', [
        'methods'             => 'POST',
        'callback'            => 'vm2_agenda_rest_receive',
        'permission_callback' => 'vm2_agenda_rest_auth',
    ]);
    register_rest_route('vm-crm-v2/v1', '/agenda/sync-last7', [
        'methods'             => 'POST',
        'callback'            => 'vm2_agenda_rest_receive_last7',
        'permission_callback' => 'vm2_agenda_rest_auth',
    ]);
    register_rest_route('vm-crm-v2/v1', '/agenda/sync-status', [
        'methods'             => 'GET',
        'callback'            => function() {
            return rest_ensure_response([
                'last_sync' => get_option('vm2_agenda_last_sync', ''),
                'count'     => count((array)get_option('vm2_agenda_gsheets', [])),
            ]);
        },
        'permission_callback' => function() { return current_user_can('manage_options'); },
    ]);
    // ── SofIA Intelligence REST ──────────────────────────────────────────────
    register_rest_route('vm-crm-v2/v1', '/sofia/session', [
        'methods'             => 'POST',
        'callback'            => 'vm2_sofia_rest_upsert',
        'permission_callback' => '__return_true',
    ]);
    register_rest_route('vm-crm-v2/v1', '/sofia/sessions', [
        'methods'             => 'GET',
        'callback'            => 'vm2_sofia_rest_list',
        'permission_callback' => function() { return current_user_can('manage_options'); },
    ]);
});
function vm2_agenda_rest_auth( $request ) {
    $auth     = $request->get_header('Authorization');
    $expected = 'Bearer ' . get_option('vm2_fin_sync_token', 'vm2fsync_9kqw3p7x');
    return $auth === $expected;
}
function vm2_agenda_rest_receive( $request ) {
    $data = $request->get_json_params();
    if ( !is_array($data) || !isset($data['events']) ) {
        return new WP_Error('bad_request','Expected JSON with events',['status'=>400]);
    }
    update_option('vm2_agenda_gsheets', $data['events'], false);
    update_option('vm2_agenda_last_sync', current_time('mysql'), false);
    delete_option('vm2_agenda_sync_pending');
    return rest_ensure_response(['success'=>true,'count'=>count($data['events']),'synced_at'=>current_time('mysql')]);
}

function vm2_agenda_rest_receive_last7( $request ) {
    $data = $request->get_json_params();
    if ( !is_array($data) || !isset($data['events']) ) {
        return new WP_Error('bad_request','Expected JSON with events',['status'=>400]);
    }
    update_option('vm2_agenda_last7', $data['events'], false);
    update_option('vm2_agenda_last7_synced', current_time('mysql'), false);
    return rest_ensure_response(['success'=>true,'count'=>count($data['events']),'synced_at'=>current_time('mysql')]);
}

// ── REST: Pedidos Export (para Apps Script sincronizar aba PEDIDOS do GSheets) ──
add_action('rest_api_init', function() {
    register_rest_route('vm-crm-v2/v1', '/pedidos/export', [
        'methods'             => 'GET',
        'callback'            => 'vm2_pedidos_export_rest',
        'permission_callback' => 'vm2_fin_rest_auth',
    ]);
});
function vm2_pedidos_export_rest( $request ) {
    if ( ! function_exists('wc_get_orders') ) {
        return new WP_Error('no_wc', 'WooCommerce not active', ['status' => 500]);
    }
    @ini_set('memory_limit', '512M');
    @set_time_limit(120);

    $since  = sanitize_text_field( $request->get_param('since') ?? '' ); // YYYY-MM-DD
    $all    = (bool) $request->get_param('all');
    $page   = max(1, (int) ($request->get_param('page') ?? 1));
    $limit  = min( 75, max( 10, (int) ( $request->get_param( 'limit' ) ?? 50 ) ) );

    // Buscar apenas IDs (muito mais leve), depois carregar 1 a 1
    $id_args = [
        'status'  => ['wc-processing','wc-contract-signed','wc-signing-pending','wc-on-hold','wc-completed','wc-cancelled','wc-refunded','wc-failed'],
        'limit'   => $limit,
        'paged'   => $page,
        'orderby' => 'date',
        'order'   => 'DESC',
        'return'  => 'ids',
    ];
    if ( $since ) {
        $id_args['date_created'] = '>=' . $since;
    }

    try {
        $order_ids = wc_get_orders( $id_args );
    } catch ( \Throwable $e ) {
        return new WP_Error('query_error', $e->getMessage(), ['status' => 500]);
    }

    if ( ! $order_ids ) {
        return rest_ensure_response( [ 'success' => true, 'pedidos' => [], 'total' => 0, 'page' => $page, 'limit' => $limit ] );
    }

    $rows = [];
    foreach ( $order_ids as $order_id ) {
        try {
            $order   = wc_get_order( (int) $order_id );
            if ( ! $order ) continue;

            $ev_ts   = vm2_get_order_event_ts( $order );
            $atracao = [];
            foreach ( $order->get_items() as $item ) {
                $atracao[] = $item->get_name();
            }
            $billing = $order->get_address('billing');
            $city    = trim( ( $billing['city'] ?? '' ) . ( ! empty( $billing['state'] ) ? ' - ' . $billing['state'] : '' ) );
            $phone   = preg_replace( '/\D/', '', $order->get_billing_phone() ?: '' );
            $created = $order->get_date_created();

            $rows[] = [
                'numero'      => '#' . $order->get_order_number(),
                'data_venda'  => $created ? wp_date( 'd/m/Y', $created->getTimestamp() ) : '',
                'data_evento' => $ev_ts ? wp_date( 'd/m/Y', $ev_ts ) : '',
                'dia_semana'  => $ev_ts ? vm2_dia_semana_ptbr( $ev_ts ) : '',
                'cliente'     => $order->get_formatted_billing_full_name(),
                'whatsapp'    => $phone,
                'atracao'     => implode( ', ', $atracao ),
                'valor'       => (float) $order->get_total(),
                'status'      => $order->get_status(),
                'local'       => $city,
                'tipo_evento' => (string) ( $order->get_meta( 'tipo_evento' ) ?: '' ),
                'assessor'    => (string) ( $order->get_meta( 'assessor' ) ?: '' ),
                'sync_at'     => current_time( 'd/m/Y H:i' ),
            ];
            // liberar memória
            unset( $order );
        } catch ( \Throwable $e ) {
            // Pula pedido com erro — não quebra o batch inteiro
            continue;
        }
    }

    return rest_ensure_response([
        'success' => true,
        'page'    => $page,
        'limit'   => $limit,
        'total'   => count($rows),
        'pedidos' => $rows,
    ]);
}



// ── AJAX: TRIGGER AGENDA SYNC ───────────────────────────────────
add_action('wp_ajax_vm2_send_lead_now', 'vm2_ajax_send_lead_now');

function vm2_ajax_send_lead_now() {
    if ( ! check_ajax_referer('vm2_nonce', 'nonce', false) ) {
        wp_send_json_error('Nonce inválido', 403);
        return;
    }
    if ( ! current_user_can('manage_options') ) {
        wp_send_json_error('Sem permissão', 403);
        return;
    }
    $phone   = sanitize_text_field( $_POST['phone'] ?? '' );
    $name    = sanitize_text_field( $_POST['name']  ?? '' );
    $channel = sanitize_text_field( $_POST['channel'] ?? get_option('vm2_auto_aquecer_channel','zapi_7551') );
    if ( ! $phone ) { wp_send_json_error('Telefone obrigatório'); return; }

    $channels = vm2_channels();
    if ( ! isset($channels[$channel]) ) { wp_send_json_error('Canal inválido'); return; }

    $is_waba  = $channels[$channel]['type'] === 'waba';
    $template = get_option('vm2_auto_aquecer_template', '');
    $msg_tpl  = get_option('vm2_auto_aquecer_msg', 'Oi {nome}! 👋 Vi que você se interessou em nossas atrações. Posso te ajudar a contratar?');

    $ok = false;
    if ( $is_waba && $template ) {
        $res = vm2_send_waba($channel, $phone, $template, []);
        $ok  = is_array($res) ? $res['ok'] : (bool)$res;
    } else {
        $text = str_replace('{nome}', $name ?: 'amigo', $msg_tpl);
        $ok   = vm2_send_zapi($channel, $phone, $text);
    }

    if ( $ok ) {
        vm2_log("leads-aquecer manual→{$phone} via {$channel}", 'info');
        wp_send_json_success(['phone' => $phone]);
    } else {
        wp_send_json_error('Falha no envio — veja o Log');
    }
}

// ─────────────────────────────────────────────────────────────
// CRON — AUTO-AQUECER (hourly)
// ─────────────────────────────────────────────────────────────
add_action( 'init', function() {
    if ( ! wp_next_scheduled( 'vm2_auto_aquecer_cron' ) ) {
        wp_schedule_event( time(), 'hourly', 'vm2_auto_aquecer_cron' );
    }
    if ( ! wp_next_scheduled( 'vm2_hot_cron' ) ) {
        wp_schedule_event( time(), 'hourly', 'vm2_hot_cron' );
    }
    if ( ! wp_next_scheduled( 'vm2_bydate_cron' ) ) {
        wp_schedule_event( time() + 300, 'hourly', 'vm2_bydate_cron' );
    }
    if ( ! wp_next_scheduled( 'vm2_promo_cleanup_cron' ) ) {
        wp_schedule_event( time() + 120, 'hourly', 'vm2_promo_cleanup_cron' );
    }
    // Alertas de agenda — cron diário (08:00 SP via daily WP)
    if ( ! wp_next_scheduled( 'vm2_agenda_alert_cron' ) ) {
        wp_schedule_event( time() + 600, 'daily', 'vm2_agenda_alert_cron' );
    }
} );

add_action( 'vm2_auto_aquecer_cron', 'vm2_auto_aquecer_run' );

// ─────────────────────────────────────────────────────────────
// CRON — PROMO CLEANUP (auto-expira promos vencidas)
// ─────────────────────────────────────────────────────────────
add_action( 'vm2_promo_cleanup_cron', 'vm2_promo_cleanup_run' );

function vm2_promo_cleanup_run() {
    global $wpdb;
    $tbl = 'wz_active_discounts';

    $expired = $wpdb->get_results(
        "SELECT * FROM {$tbl} WHERE reverted_at IS NULL AND expires_at IS NOT NULL AND expires_at != '0000-00-00 00:00:00' AND expires_at < NOW()"
    );
    if ( empty($expired) ) return;

    foreach ( $expired as $promo ) {
        // v1.5.18: Reverter via WC Product API (compatível com HPOS)
        $product = function_exists('wc_get_product') ? wc_get_product( (int)$promo->product_id ) : null;
        if ( $product ) {
            $product->set_sale_price( '' );
            $product->save();
        }
        // v1.5.18: Deletar cupom WooCommerce permanentemente (por código, não coupon_id)
        if ( !empty($promo->coupon_code) ) {
            $coupon_post = get_page_by_title( $promo->coupon_code, OBJECT, 'shop_coupon' );
            if ( $coupon_post ) {
                wp_delete_post( $coupon_post->ID, true );
            }
        }
        // Marcar como revertida
        $wpdb->update( $tbl, ['reverted_at' => current_time('mysql')], ['id' => (int)$promo->id] );
        vm2_log( "promo_cleanup: Promo #{$promo->id} ({$promo->product_name}) auto-expirada + cupom deletado", 'info' );
    }
}

function vm2_auto_aquecer_run() {
    if ( get_option('vm2_auto_aquecer_on', '0') !== '1' ) return;

    $threshold = (int)get_option('vm2_auto_aquecer_threshold', '60');
    $channel   = get_option('vm2_auto_aquecer_channel', 'zapi_7551');
    $template  = get_option('vm2_auto_aquecer_template', '');
    $cooldown  = (int)get_option('vm2_auto_aquecer_cooldown', '24');
    $batch      = max(1, (int)get_option('vm2_auto_aquecer_batch', '20'));
    $max_weekly = (int)get_option('vm2_contact_weekly_limit', '0');
    $msg_tpl   = get_option('vm2_auto_aquecer_msg', 'Oi {nome}! 👋 Vi que você se interessou em nossas atrações. Posso te ajudar a contratar?');

    $channels = vm2_channels();
    if ( ! isset($channels[$channel]) ) {
        vm2_log("auto_aquecer: canal {$channel} não encontrado", 'error');
        return;
    }
    $is_waba = $channels[$channel]['type'] === 'waba';

    // Kill switch global
    if ( get_option('vm2_aquecer_kill', '1') === '1' ) {
        vm2_log("auto_aquecer: kill switch ON — pulando cron", 'info');
        return;
    }

    // Quiet Hours — não envia em horário silencioso
    if ( vm2_is_quiet_time() ) {
        vm2_log("auto_aquecer: quiet hours ativo — pulando cron", 'info');
        return;
    }
    // Cap Global Diário
    if ( vm2_daily_cap_reached() ) {
        vm2_log("auto_aquecer: cap global diário atingido — pulando cron", 'info');
        return;
    }

    $leads = vm2_get_leads_para_aquecer(['score_min' => $threshold, 'limit' => 50, 'cache' => false]);
    if ( empty($leads) ) return;

    global $wpdb;
    $sent = 0;

    foreach ( $leads as $lead ) {
        $phone = $lead['phone'];
        $name  = $lead['name'] ?? '';

        // Dedup central — usa vm2_sends como árbitro (cooldown + limite semanal)
        if ( ! vm2_can_send( $phone, $cooldown, $max_weekly ) ) continue;

        $text_with_link = str_replace( '{link}', vm2_tracking_url( $phone, 'aquecer' ), $msg_tpl );
        $ok = false;
        if ( $is_waba && $template ) {
            $res = vm2_send_waba( $channel, $phone, $template, [] );
            $ok  = is_array($res) ? $res['ok'] : (bool)$res;
        } else {
            $text = str_replace( '{nome}', $name ?: 'amigo', $text_with_link );
            $ok   = vm2_send_zapi( $channel, $phone, $text );
        }

        if ( $ok ) {
            vm2_record_send( $phone, 'aquecer', $channel );
            vm2_log( "auto_aquecer→{$phone} score={$lead['score']} via {$channel}", 'info' );
            $sent++;
        }

        // [v1.5.94] Email paralelo / fallback — Por Data
        if ( get_option('vm2_auto_aquecer_email_on', '0') === '1' ) {
            $contact_row = $wpdb->get_row($wpdb->prepare(
                "SELECT email, name FROM {$wpdb->prefix}vm2_contacts WHERE phone = %s LIMIT 1",
                $phone
            ));
            $contact_email_aq = $contact_row->email ?? '';
            if ( $contact_email_aq && is_email($contact_email_aq) ) {
                $subj_aq   = get_option('vm2_auto_aquecer_email_subject', 'Você tem um evento chegando! Vamos fechar as atrações? 🎉');
                $body_tpl  = get_option('vm2_auto_aquecer_email_body', '');
                $nm_aq     = $contact_row->name ?: ($name ?: 'amigo');
                $link_aq   = vm2_tracking_url( $phone, 'aquecer' );
                $body_aq   = str_replace(['{nome}','{link}'], [$nm_aq, $link_aq], $body_tpl);
                $body_aq   = nl2br(esc_html($body_aq));
                $headers   = ['Content-Type: text/html; charset=UTF-8', 'From: VivaMais Eventos <noreply@vivamaiseventos.com>'];
                $mail_ok   = wp_mail($contact_email_aq, $subj_aq, $body_aq, $headers);
                if ( $mail_ok ) {
                    vm2_record_send( $phone, 'aquecer_email', 'email' );
                    vm2_log( "auto_aquecer_email→{$contact_email_aq} ({$phone})", 'info' );
                }
            }
        }

        if ( $sent >= $batch ) break; // batch limit configurável
    }

    if ( $sent > 0 ) {
        vm2_log( "auto_aquecer_cron: {$sent} mensagens enviadas (threshold={$threshold})", 'info' );
        delete_transient( 'vm2_leads_aq_v2' );
    }
}

// ─────────────────────────────────────────────────────────────
// AUTO-HOT — disparo automático para leads Kommo HOT (Incoming)
// ─────────────────────────────────────────────────────────────
function vm2_hot_run() {
    if ( get_option( 'vm2_hot_on',   '0' ) !== '1' ) return;
    if ( get_option( 'vm2_hot_kill', '1' ) === '1' ) return;
    if ( get_option( 'vm2_kill_switch', '0' ) === '1' ) return;
    // Quiet Hours — não envia em horário silencioso
    if ( vm2_is_quiet_time() ) {
        vm2_log( 'vm2_hot_run: quiet hours ativo — pulando cron', 'info' );
        return;
    }
    // Cap Global Diário
    if ( vm2_daily_cap_reached() ) {
        vm2_log( 'vm2_hot_run: cap global diário atingido — pulando cron', 'info' );
        return;
    }

    $preferred = get_option( 'vm2_hot_channel',  'waba_5039' );
    $channel   = vm2_get_best_channel( $preferred );
    if ( ! $channel ) {
        vm2_log( 'vm2_hot_run: todos os canais atingiram limite diário', 'info' );
        return;
    }

    $channels  = vm2_channels();
    $is_waba   = isset( $channels[ $channel ] ) && $channels[ $channel ]['type'] === 'waba';
    $template  = get_option( 'vm2_hot_template', '' );
    $msg_tpl   = get_option( 'vm2_hot_msg',
        "Oi {nome}! 👋 Aqui é da VivaMais — você tem um evento em vista?\nAinda dá tempo de fechar as atrações perfeitas. Posso ajudar! 🎉\n{link}" );
    $cooldown   = (int) get_option( 'vm2_hot_cooldown', '72' );
    $batch      = (int) get_option( 'vm2_hot_batch', '10' );
    $max_weekly = (int) get_option( 'vm2_contact_weekly_limit', '0' );

    global $wpdb;
    // Leads HOT = pipeline Incoming (status_id 94305664) que ainda não contrataram
    $leads = $wpdb->get_results(
        "SELECT phone, name, data_evento
         FROM {$wpdb->prefix}vm_kommo_leads
         WHERE phone != ''
           AND status_id = 94305664
         ORDER BY last_synced DESC
         LIMIT 100"
    );

    $sent = 0;
    foreach ( $leads as $lead ) {
        if ( $sent >= $batch ) break;
        $phone = $lead->phone;
        $name  = $lead->name ?: 'amigo';

        if ( ! vm2_can_send( $phone, $cooldown, $max_weekly ) ) continue;

        $link = vm2_tracking_url( $phone, 'hot' );
        $ok   = false;
        if ( $is_waba && $template ) {
            $components = [];
            if ( strpos( $template, '{{1}}' ) !== false ) {
                $components = [ [ 'type' => 'body', 'parameters' => [ [ 'type' => 'text', 'text' => $name ] ] ] ];
            }
            $res = vm2_send_waba( $channel, $phone, $template, $components );
            $ok  = is_array( $res ) ? $res['ok'] : (bool) $res;
        } else {
            $text = str_replace( [ '{nome}', '{link}' ], [ $name, $link ], $msg_tpl );
            $ok   = vm2_send_zapi( $channel, $phone, $text );
        }

        if ( $ok ) {
            vm2_record_send( $phone, 'hot', $channel );
            vm2_log( "vm2_hot→{$phone} via {$channel}", 'info' );
            $sent++;
        }

        // [v1.5.94] Email paralelo / fallback — HOT
        if ( get_option('vm2_hot_email_on', '0') === '1' ) {
            $contact_hot = $wpdb->get_row($wpdb->prepare(
                "SELECT email, name FROM {$wpdb->prefix}vm2_contacts WHERE phone = %s LIMIT 1",
                $phone
            ));
            $hot_email_addr = $contact_hot->email ?? '';
            if ( $hot_email_addr && is_email($hot_email_addr) ) {
                $subj_hot  = get_option('vm2_hot_email_subject', 'Você está procurando atrações para sua festa? 🎉');
                $body_hot_tpl = get_option('vm2_hot_email_body', '');
                $nm_hot    = $contact_hot->name ?: ($name ?: 'amigo');
                $link_hot  = vm2_tracking_url( $phone, 'hot' );
                $body_hot  = str_replace(['{nome}','{link}'], [$nm_hot, $link_hot], $body_hot_tpl);
                $body_hot  = nl2br(esc_html($body_hot));
                $headers   = ['Content-Type: text/html; charset=UTF-8', 'From: VivaMais Eventos <noreply@vivamaiseventos.com>'];
                $mail_ok   = wp_mail($hot_email_addr, $subj_hot, $body_hot, $headers);
                if ( $mail_ok ) {
                    vm2_record_send( $phone, 'hot_email', 'email' );
                    vm2_log( "vm2_hot_email→{$hot_email_addr} ({$phone})", 'info' );
                }
            }
        }
    }

    if ( $sent > 0 ) vm2_log( "vm2_hot_cron: {$sent} msgs HOT enviadas", 'info' );
}
add_action( 'vm2_hot_cron', 'vm2_hot_run' );

// ─────────────────────────────────────────────────────────────
// AUTO-BYDATE — disparo por proximidade de data do evento
// ─────────────────────────────────────────────────────────────
function vm2_bydate_run() {
    if ( get_option( 'vm2_bydate_kill', '1' ) === '1' ) return;
    if ( get_option( 'vm2_kill_switch', '0' ) === '1' ) return;
    // Quiet Hours — não envia em horário silencioso
    if ( vm2_is_quiet_time() ) {
        vm2_log( 'vm2_bydate_run: quiet hours ativo — pulando cron', 'info' );
        return;
    }
    // Cap Global Diário
    if ( vm2_daily_cap_reached() ) {
        vm2_log( 'vm2_bydate_run: cap global diário atingido — pulando cron', 'info' );
        return;
    }

    $channel  = get_option( 'vm2_bydate_channel', 'zapi_7551' );
    $channels = vm2_channels();
    $is_waba  = isset( $channels[ $channel ] ) && $channels[ $channel ]['type'] === 'waba';

    // Grupos de data: chave => [min_dias, max_dias, cooldown_h]
    $bd_groups = [
        'mes'      => [ 25, 35,  48 ],
        'quinzena' => [ 12, 18,  48 ],
        'semana'   => [  5,  9,  24 ],
        'dias3'    => [  1,  4,  12 ],
    ];

    global $wpdb;
    $sent       = 0;
    $batch      = 20;
    $max_weekly = (int) get_option( 'vm2_contact_weekly_limit', '0' );

    foreach ( $bd_groups as $gkey => [ $dmin, $dmax, $cool ] ) {
        $g_on = get_option( "vm2_bydate_{$gkey}_on", '0' );
        if ( $g_on !== '1' ) continue;

        $g_tmpl = get_option( "vm2_bydate_{$gkey}_template", '' );
        $g_msg  = get_option( "vm2_bydate_{$gkey}_msg",
            "Oi {nome}! 🎉 Sua festa em {data_evento} está chegando!\nAinda precisa de alguma atração? Posso ajudar! 🎊\n{link}" );

        // Leads com data_evento entre $dmin e $dmax dias a partir de hoje, excluindo quem já contratou
        $leads = $wpdb->get_results( $wpdb->prepare(
            "SELECT phone, name, data_evento
             FROM {$wpdb->prefix}vm_kommo_leads
             WHERE phone != ''
               AND data_evento IS NOT NULL AND data_evento != ''
               AND DATEDIFF( STR_TO_DATE(data_evento, '%%d/%%m/%%Y'), CURDATE() ) BETWEEN %d AND %d
               AND status_id != 94325167
             LIMIT 50",
            $dmin, $dmax
        ) );

        foreach ( $leads as $lead ) {
            if ( $sent >= $batch ) break 2;
            $phone = $lead->phone;
            $name  = $lead->name ?: 'amigo';
            $data  = $lead->data_evento;

            if ( ! vm2_can_send( $phone, $cool, $max_weekly ) ) continue;

            $link = vm2_tracking_url( $phone, 'bydate_' . $gkey );
            $ok   = false;
            if ( $is_waba && $g_tmpl ) {
                $res = vm2_send_waba( $channel, $phone, $g_tmpl, [] );
                $ok  = is_array( $res ) ? $res['ok'] : (bool) $res;
            } else {
                $text = str_replace(
                    [ '{nome}', '{data_evento}', '{link}' ],
                    [ $name, $data, $link ],
                    $g_msg
                );
                $ok = vm2_send_zapi( $channel, $phone, $text );
            }

            if ( $ok ) {
                vm2_record_send( $phone, 'bydate_' . $gkey, $channel );
                vm2_log( "vm2_bydate_{$gkey}→{$phone} via {$channel}", 'info' );
                $sent++;
            }

            // [v1.5.95] Email paralelo
            if ( get_option('vm2_bydate_email_on','0') === '1' ) {
                $bd_contact = $wpdb->get_row( $wpdb->prepare(
                    "SELECT email FROM {$wpdb->prefix}vm2_contacts WHERE phone=%s AND email!='' LIMIT 1", $phone
                ) );
                if ( $bd_contact && $bd_contact->email ) {
                    $subj_bd  = get_option('vm2_bydate_email_subject','Sua festa está chegando! Vamos fechar as atrações? 🎉');
                    $body_bd  = get_option('vm2_bydate_email_body','');
                    $body_bd  = str_replace(['{nome}','{link}'],[$name,$link],$body_bd);
                    wp_mail( $bd_contact->email, $subj_bd, $body_bd );
                    vm2_log( "vm2_bydate_email→{$bd_contact->email} ({$phone})", 'info' );
                }
            }
        }
    }

    if ( $sent > 0 ) vm2_log( "vm2_bydate_cron: {$sent} mensagens enviadas", 'info' );
}
add_action( 'vm2_bydate_cron', 'vm2_bydate_run' );

add_action('wp_ajax_vm2_agenda_trigger_sync', function() {
    check_ajax_referer('vm2_agenda_sync','nonce');
    if (!current_user_can('manage_options')) { wp_send_json_error('forbidden'); }
    $webhook_url = get_option('vm2_agenda_webhook_url','');
    if (!$webhook_url) { wp_send_json_error('Webhook URL não configurado em Configurações → Agenda.'); }
    update_option('vm2_agenda_sync_pending',1,false);
    wp_remote_post($webhook_url,[
        'timeout'   => 0.01,
        'blocking'  => false,
        'body'      => json_encode(['source'=>'vivamais-crm-v2','action'=>'sync_agenda']),
        'headers'   => ['Content-Type'=>'application/json'],
        'sslverify' => false,
    ]);
    wp_send_json_success(['message'=>'Sincronização iniciada!']);
});

// Esconder menu separado Exit-Intent (integrado ao V2)
add_action('admin_menu', function() {
    remove_menu_page('vm-exit-intent');
}, 999);

// ══════════════════════════════════════════════════════

// ══════════════════════════════════════════════════════
// ONE-TIME MIGRATION: Fix unicode escapes em vm_ei_config
// (causado por defaults PHP com \uXXXX literal — v1.4.5 e anteriores)
// ══════════════════════════════════════════════════════
add_action('admin_init', function() {
    if (get_option('vm2_ei_unicode_fixed_v1')) return;
    $cfg = get_option('vm_ei_config', []);
    if (is_array($cfg)) {
        $needs_update = false;
        foreach (['title', 'subtitle', 'cta_text', 'dismiss_text'] as $key) {
            if (!isset($cfg[$key])) continue;
            if (strpos($cfg[$key], '\\u') === false) continue;
            // Decode \uXXXX (including surrogate pairs) via json_decode trick
            $escaped = str_replace(['"', '\\\\'], ['\\"', '\\\\\\\\'], $cfg[$key]);
            $decoded = json_decode('"' . $escaped . '"');
            if ($decoded !== null && $decoded !== $cfg[$key]) {
                $cfg[$key]    = $decoded;
                $needs_update = true;
            }
        }
        if ($needs_update) update_option('vm_ei_config', $cfg);
    }
    update_option('vm2_ei_unicode_fixed_v1', 1);
}, 5);

// AJAX: Exit-Intent config (V2)
// ══════════════════════════════════════════════════════
add_action('wp_ajax_vm2_ei_save', function() {
    check_ajax_referer('vm2_ei_save', 'nonce');
    if (!current_user_can('manage_options')) wp_send_json_error('unauthorized');
    $saved = get_option('vm_ei_config', []);
    if (!is_array($saved)) $saved = [];
    $saved['kill_switch']   = (int)($_POST['kill_switch'] ?? 0);
    if (!empty($_POST['grupo_url']))     $saved['grupo_url']     = esc_url_raw($_POST['grupo_url']);
    if (isset($_POST['title']))          $saved['title']         = sanitize_text_field($_POST['title']);
    if (isset($_POST['subtitle']))       $saved['subtitle']      = wp_kses_post($_POST['subtitle']);
    if (isset($_POST['cta_text']))       $saved['cta_text']      = sanitize_text_field($_POST['cta_text']);
    if (isset($_POST['cooldown_days']))  $saved['cooldown_days'] = max(0, (int)$_POST['cooldown_days']);
    if (isset($_POST['timer_delay']))    $saved['timer_delay']   = max(0, (int)$_POST['timer_delay']);
    update_option('vm_ei_config', $saved);
    wp_send_json_success();
});

add_action('wp_ajax_vm2_ei_reset_stats', function() {
    check_ajax_referer('vm2_ei_save', 'nonce');
    if (!current_user_can('manage_options')) wp_send_json_error('unauthorized');
    update_option('vm_ei_stat_shows', 0);
    update_option('vm_ei_stat_clicks', 0);
    wp_send_json_success();
});

// ══════════════════════════════════════════════════════
// AJAX: WA Recovery config/actions (V2 Carrinho tab)
// ══════════════════════════════════════════════════════
add_action('wp_ajax_vm2_wa_save_config', function() {
    check_ajax_referer('vm2_wa_config', 'nonce');
    if (!current_user_can('manage_options')) wp_send_json_error('unauthorized');
    if (isset($_POST['vm_wa_kill_switch']))     update_option('vm_wa_kill_switch',     sanitize_text_field($_POST['vm_wa_kill_switch']));
    if (isset($_POST['vm_wa_send_channel']))    update_option('vm_wa_send_channel',    sanitize_text_field($_POST['vm_wa_send_channel']));
    if (isset($_POST['vm_wa_batch_size']))      update_option('vm_wa_batch_size',      (int)$_POST['vm_wa_batch_size']);
    if (isset($_POST['vm_wa_quiet_start']))     update_option('vm_wa_quiet_start',     (int)$_POST['vm_wa_quiet_start']);
    if (isset($_POST['vm_wa_quiet_end']))       update_option('vm_wa_quiet_end',       (int)$_POST['vm_wa_quiet_end']);
    if (isset($_POST['vm_wa_interval_sec']))    update_option('vm_wa_interval_sec',    (int)$_POST['vm_wa_interval_sec']);
    if (isset($_POST['vm_wa_waba_template']))   update_option('vm_wa_waba_template',   sanitize_text_field($_POST['vm_wa_waba_template']));
    if (isset($_POST['vm_wa_recovery_message'])) update_option('vm_wa_recovery_message', sanitize_textarea_field($_POST['vm_wa_recovery_message']));
    wp_send_json_success(['message' => 'Configurações salvas!']);
});

add_action('wp_ajax_vm2_wa_resend', function() {
    check_ajax_referer('vm_wa_resend', 'nonce');
    if (!current_user_can('manage_options')) wp_send_json_error('unauthorized');
    $id = (int)($_POST['id'] ?? 0);
    if (!$id) wp_send_json_error('ID inválido');
    global $wpdb;
    $table = $wpdb->prefix . 'vm_wa_captures';
    $row   = $wpdb->get_row($wpdb->prepare("SELECT * FROM $table WHERE id=%d", $id));
    if (!$row) wp_send_json_error('Registro não encontrado');

    $channel  = get_option('vm_wa_send_channel', 'zapi_1886');
    $channels = vm2_channels();
    $ch_info  = $channels[$channel] ?? null;
    $is_waba  = ($ch_info && ($ch_info['type'] === 'waba'));
    $phone    = vm2_format_phone($row->phone);

    if ($is_waba) {
        // ── Envio WABA via pool dinâmico V2 ──────────────────────
        $template = get_option('vm_wa_waba_template', 'recupera_carrinho_woo');
        $name     = $row->name     ?: 'Cliente';
        // Garante URL absoluta: page_url tem prioridade (sempre absoluta), cart_url pode ser relativa
        $raw_url  = !empty($row->page_url) ? $row->page_url : ($row->cart_url ?? '');
        $cart_url = $raw_url
            ? (str_starts_with($raw_url, 'http') ? $raw_url : home_url('/' . ltrim($raw_url, '/')))
            : 'https://loja.vivamaiseventos.com';
        $result = vm2_send_waba($channel, $phone, $template, [
            ['type' => 'body', 'parameters' => [
                ['type' => 'text', 'text' => $name],
                ['type' => 'text', 'text' => $cart_url],
            ]],
            ['type' => 'button', 'sub_type' => 'url', 'index' => '0', 'parameters' => [
                ['type' => 'text', 'text' => $cart_url],
            ]],
        ]);
        if (!empty($result['ok'])) {
            $wpdb->update($table, ['status' => 'sent', 'sent_at' => current_time('mysql')], ['id' => $id]);
            vm2_record_send($phone, 'carrinho', $channel); // registra no árbitro central
            wp_send_json_success(['message' => '✅ WABA enviado com sucesso!']);
        } else {
            $meta_body = $result['body'] ?? '(sem resposta)';
            $meta_code = $result['code'] ?? 0;
            $decoded   = json_decode($meta_body, true);
            $meta_err  = isset($decoded['error']['message']) ? $decoded['error']['message'] : $meta_body;
            wp_send_json_error(['message' => "❌ Meta API HTTP {$meta_code}: {$meta_err}"]);
        }
    } else {
        // ── Envio Z-API via pool dinâmico V2 ─────────────────────
        // Garante URL absoluta: page_url tem prioridade (sempre absoluta), cart_url pode ser relativa
        $raw_url_zapi = !empty($row->page_url) ? $row->page_url : ($row->cart_url ?? '');
        $cart_link    = $raw_url_zapi
            ? (str_starts_with($raw_url_zapi, 'http') ? $raw_url_zapi : home_url('/' . ltrim($raw_url_zapi, '/')))
            : home_url('/');
        $msg = function_exists('vm_wa_compose_text_message')
            ? vm_wa_compose_text_message($row->name, $row->product_name, $cart_link, $row->cart_total)
            : "Oi {$row->name}! 🛒 Você deixou itens no carrinho. Finalize aqui: {$cart_link}";
        $ok = vm2_send_zapi($channel, $phone, $msg);
        if ($ok) {
            $wpdb->update($table, ['status' => 'sent', 'sent_at' => current_time('mysql')], ['id' => $id]);
            vm2_record_send($phone, 'carrinho', $channel); // registra no árbitro central
            wp_send_json_success(['message' => '✅ Enviado via Z-API!']);
        } else {
            wp_send_json_error(['message' => '❌ Falha no envio Z-API. Verifique o Log.']);
        }
    }
});


// ─── DIAGNÓSTICO WABA (temporário) ──────────────────────────────────────────
add_action('wp_ajax_vm2_waba_diag', function() {
    if (!current_user_can('manage_options')) wp_send_json_error('unauthorized');
    $channel  = get_option('vm_wa_send_channel', 'zapi_1886');
    $channels = vm2_channels();
    $ch_info  = $channels[$channel] ?? null;
    $pool_raw = get_option('vm2_channel_pool', []);

    $diag = [
        'vm_wa_send_channel'  => $channel,
        'kill_switch'         => get_option('vm_wa_kill_switch', '?'),
        'channel_found'       => !empty($ch_info),
        'channel_type'        => $ch_info['type'] ?? 'N/A',
        'channel_instance'    => $ch_info['instance'] ?? 'VAZIO',
        'token_set'           => !empty($ch_info['token']),
        'token_preview'       => $ch_info ? (substr($ch_info['token'] ?? '', 0, 20) . '...') : 'N/A',
        'pool_keys'           => array_keys(is_array($pool_raw) ? $pool_raw : []),
    ];

    // Testa credenciais na Meta API (só GET — não envia mensagem)
    if ($ch_info && !empty($ch_info['instance']) && !empty($ch_info['token'])) {
        $pid  = $ch_info['instance'];
        $tok  = $ch_info['token'];
        $test = wp_remote_get("https://graph.facebook.com/v21.0/{$pid}?fields=display_phone_number,verified_name,quality_rating,status", [
            'headers' => ['Authorization' => 'Bearer ' . $tok],
            'timeout' => 10,
        ]);
        if (is_wp_error($test)) {
            $diag['meta_test'] = 'WP_Error: ' . $test->get_error_message();
        } else {
            $diag['meta_test_code'] = wp_remote_retrieve_response_code($test);
            $diag['meta_test_body'] = wp_remote_retrieve_body($test);
        }
    } else {
        $diag['meta_test'] = 'SKIP — credenciais ausentes';
    }

    // Pendentes e falhos
    global $wpdb;
    $table  = $wpdb->prefix . 'vm_wa_captures';
    $rows   = $wpdb->get_results("SELECT id, phone, name, status, cart_url, captured_at FROM $table WHERE status IN ('pending','failed') ORDER BY id DESC LIMIT 5");
    $diag['pending_failed'] = $rows;

    // Colunas da tabela
    $cols = $wpdb->get_results("SHOW COLUMNS FROM $table");
    $diag['table_columns'] = array_column($cols, 'Field');

    wp_send_json_success($diag);
});

add_action('wp_ajax_vm2_popup_save_config', function() {
    check_ajax_referer('vm2_popup_save', 'nonce');
    if (!current_user_can('manage_options')) wp_send_json_error();
    $cfg = [
        'kill_switch'  => (int)$_POST['kill_switch'],
        'banner_topo'  => sanitize_text_field($_POST['banner_topo'] ?? ''),
        'titulo'       => sanitize_text_field($_POST['titulo'] ?? ''),
        'subtitulo'    => sanitize_text_field($_POST['subtitulo'] ?? ''),
        'urgencia'     => sanitize_text_field($_POST['urgencia'] ?? ''),
        'cta_text'     => sanitize_text_field($_POST['cta_text'] ?? ''),
        'delay_sec'    => (int)($_POST['delay_sec'] ?? 5),
        'show_on'      => sanitize_key($_POST['show_on'] ?? 'produto'),
        'session_expiry_hours' => max(1, min(720, (int)($_POST['session_expiry_hours'] ?? 24))),
    ];
    update_option('vm2_popup_config', $cfg);
    // Sync kill switch also to wa-capture force_gate (inverse: gate=on when popup=active)
    update_option('vm_wa_force_gate', $cfg['kill_switch'] ? '0' : '1');
    wp_send_json_success(['message' => 'Configurações salvas com sucesso!']);
});

add_action('wp_ajax_vm2_wa_ignore', function() {
    check_ajax_referer('vm_wa_resend', 'nonce');
    if (!current_user_can('manage_options')) wp_send_json_error('unauthorized');
    $id = (int)($_POST['id'] ?? 0);
    if (!$id) wp_send_json_error('ID inválido');
    global $wpdb;
    $table = $wpdb->prefix . 'vm_wa_captures';
    $wpdb->update($table, ['status' => 'cancelled'], ['id' => $id]);
    wp_send_json_success(['message' => 'Ignorado.']);
});


// ═══════════════════════════════════════════════════════════════════════════════
// GATILHOS VISUAIS (Social Proof) — v1.5.36
// ═══════════════════════════════════════════════════════════════════════════════

// ── AJAX: Salvar configurações de Gatilhos Visuais ───────────────────────────
add_action('wp_ajax_vm2_gatilhos_save', function() {
    check_ajax_referer('vm2_gatilhos_save', 'nonce');
    if (!current_user_can('manage_options')) wp_send_json_error('unauthorized');

    update_option('vm2_sp_reservas_enabled',       (int) ($_POST['reservas_enabled']       ?? 1));
    update_option('vm2_sp_stars_enabled',          (int) ($_POST['stars_enabled']          ?? 1));
    update_option('vm2_sp_disp_enabled',           (int) ($_POST['disp_enabled']           ?? 1));
    update_option('vm2_sp_discount_badge_enabled', (int) ($_POST['discount_badge_enabled'] ?? 1));
    update_option('vm2_wa_countdown_enabled',      (int) ($_POST['countdown_enabled']      ?? 1));
    update_option('vm2_wa_combo_enabled',          (int) ($_POST['combo_enabled']           ?? 0));
    update_option('vm2_sticky_cta_enabled',        (int) ($_POST['sticky_cta_enabled']      ?? 0));
    update_option('vm2_sp_offset_min',             max(0,  (int) ($_POST['offset_min'] ?? 12)));
    update_option('vm2_sp_offset_max',             max(1,  (int) ($_POST['offset_max'] ?? 47)));

    // Limpar transients de cache para que novos valores reflitam imediatamente
    global $wpdb;
    $wpdb->query("DELETE FROM {$wpdb->options} WHERE option_name LIKE '_transient_vmsp_%' OR option_name LIKE '_transient_timeout_vmsp_%'");

    wp_send_json_success(['message' => '✅ Configurações salvas! Cache limpo.']);
});

// ── Página: Gatilhos Visuais ─────────────────────────────────────────────────
function vm2_gatilhos_page() {
    $reservas_on  = (bool) get_option('vm2_sp_reservas_enabled',       1);
    $stars_on     = (bool) get_option('vm2_sp_stars_enabled',          1);
    $disp_on      = (bool) get_option('vm2_sp_disp_enabled',           1);
    $discount_on   = (bool) get_option('vm2_sp_discount_badge_enabled', 1);
    $countdown_on  = (bool) get_option('vm2_wa_countdown_enabled',      1);
    $combo_on      = (bool) get_option('vm2_wa_combo_enabled',          0);
    $sticky_cta_on = (bool) get_option('vm2_sticky_cta_enabled',        0);
    $offset_min    = (int)  get_option('vm2_sp_offset_min',             12);
    $offset_max    = (int)  get_option('vm2_sp_offset_max',             47);
    $nonce         = wp_create_nonce('vm2_gatilhos_save');

    // Contar ativos
    $ativos = (int)$reservas_on + (int)$stars_on + (int)$disp_on + (int)$discount_on + (int)$countdown_on + (int)$combo_on + (int)$sticky_cta_on;

    ?>
    <div class="wrap" style="max-width:900px">
        <h1 style="display:flex;align-items:center;gap:10px">
            ✨ Gatilhos Visuais
            <span style="font-size:13px;font-weight:400;background:#f0fdf4;color:#166534;border:1px solid #bbf7d0;padding:3px 10px;border-radius:20px">
                Social Proof
            </span>
        </h1>
        <p style="color:#6b7280;margin-top:-8px;margin-bottom:20px">
            Controle os elementos de prova social exibidos nas páginas de produto.
            Plugin: <code>vivamais-social-proof-v1.2</code> → <strong>v1.3</strong>
        </p>

        <?php if ($ativos === 0) : ?>
        <div class="notice notice-warning" style="border-left:4px solid #f59e0b;padding:10px 15px;margin-bottom:20px">
            <p>⚠️ <strong>Todos os gatilhos estão desligados.</strong> Nenhum elemento de social proof está sendo exibido nos produtos.</p>
        </div>
        <?php endif; ?>

        <!-- Cards de Status (clicáveis) -->
        <div style="display:grid;grid-template-columns:repeat(auto-fit,minmax(200px,1fr));gap:12px;margin-bottom:24px">

            <div onclick="document.getElementById('section-reservas').scrollIntoView({behavior:'smooth'})"
                 style="cursor:pointer;background:<?php echo $reservas_on ? '#f0fdf4' : '#fef2f2'; ?>;border:1px solid <?php echo $reservas_on ? '#86efac' : '#fca5a5'; ?>;border-radius:12px;padding:16px 20px;transition:transform .15s"
                 onmouseover="this.style.transform='scale(1.02)'" onmouseout="this.style.transform='scale(1)'">
                <div style="font-size:28px;margin-bottom:4px">🟢</div>
                <div style="font-weight:700;font-size:14px;color:<?php echo $reservas_on ? '#166534' : '#991b1b'; ?>">
                    Reservas Confirmadas
                </div>
                <div style="font-size:12px;color:#6b7280;margin-top:2px">
                    <?php echo $reservas_on ? '✅ Ativo' : '🔴 Desligado'; ?>
                </div>
                <div style="font-size:11px;color:#9ca3af;margin-top:4px">
                    Offset: <?php echo $offset_min; ?>–<?php echo $offset_max; ?>
                </div>
            </div>

            <div onclick="document.getElementById('section-stars').scrollIntoView({behavior:'smooth'})"
                 style="cursor:pointer;background:<?php echo $stars_on ? '#fffbeb' : '#fef2f2'; ?>;border:1px solid <?php echo $stars_on ? '#fde047' : '#fca5a5'; ?>;border-radius:12px;padding:16px 20px;transition:transform .15s"
                 onmouseover="this.style.transform='scale(1.02)'" onmouseout="this.style.transform='scale(1)'">
                <div style="font-size:28px;margin-bottom:4px">⭐</div>
                <div style="font-weight:700;font-size:14px;color:<?php echo $stars_on ? '#92400e' : '#991b1b'; ?>">
                    Estrelas & Avaliações
                </div>
                <div style="font-size:12px;color:#6b7280;margin-top:2px">
                    <?php echo $stars_on ? '✅ Ativo' : '🔴 Desligado'; ?>
                </div>
                <div style="font-size:11px;color:#9ca3af;margin-top:4px">
                    Rating baseado em reservas
                </div>
            </div>

            <div onclick="document.getElementById('section-disp').scrollIntoView({behavior:'smooth'})"
                 style="cursor:pointer;background:<?php echo $disp_on ? '#eff6ff' : '#fef2f2'; ?>;border:1px solid <?php echo $disp_on ? '#93c5fd' : '#fca5a5'; ?>;border-radius:12px;padding:16px 20px;transition:transform .15s"
                 onmouseover="this.style.transform='scale(1.02)'" onmouseout="this.style.transform='scale(1)'">
                <div style="font-size:28px;margin-bottom:4px">📅</div>
                <div style="font-weight:700;font-size:14px;color:<?php echo $disp_on ? '#1e40af' : '#991b1b'; ?>">
                    Disponibilidade
                </div>
                <div style="font-size:12px;color:#6b7280;margin-top:2px">
                    <?php echo $disp_on ? '✅ Ativo' : '🔴 Desligado'; ?>
                </div>
                <div style="font-size:11px;color:#9ca3af;margin-top:4px">
                    Requer WC Bookings
                </div>
            </div>

            <div onclick="document.getElementById('section-discount').scrollIntoView({behavior:'smooth'})"
                 style="cursor:pointer;background:<?php echo $discount_on ? '#fff7ed' : '#fef2f2'; ?>;border:1px solid <?php echo $discount_on ? '#fed7aa' : '#fca5a5'; ?>;border-radius:12px;padding:16px 20px;transition:transform .15s"
                 onmouseover="this.style.transform='scale(1.02)'" onmouseout="this.style.transform='scale(1)'">
                <div style="font-size:28px;margin-bottom:4px">🏷️</div>
                <div style="font-weight:700;font-size:14px;color:<?php echo $discount_on ? '#9a3412' : '#991b1b'; ?>">
                    Badge de Desconto
                </div>
                <div style="font-size:12px;color:#6b7280;margin-top:2px">
                    <?php echo $discount_on ? '✅ Ativo' : '🔴 Desligado'; ?>
                </div>
                <div style="font-size:11px;color:#9ca3af;margin-top:4px">
                    -50% OFF / preço riscado
                </div>
            </div>

            <div onclick="document.getElementById('section-countdown').scrollIntoView({behavior:'smooth'})"
                 style="cursor:pointer;background:<?php echo $countdown_on ? '#f0f9ff' : '#fef2f2'; ?>;border:1px solid <?php echo $countdown_on ? '#bae6fd' : '#fca5a5'; ?>;border-radius:12px;padding:16px 20px;transition:transform .15s"
                 onmouseover="this.style.transform='scale(1.02)'" onmouseout="this.style.transform='scale(1)'">
                <div style="font-size:28px;margin-bottom:4px">⏱️</div>
                <div style="font-weight:700;font-size:14px;color:<?php echo $countdown_on ? '#0369a1' : '#991b1b'; ?>">
                    Countdown Carrinho
                </div>
                <div style="font-size:12px;color:#6b7280;margin-top:2px">
                    <?php echo $countdown_on ? '✅ Ativo' : '🔴 Desligado'; ?>
                </div>
                <div style="font-size:11px;color:#9ca3af;margin-top:4px">
                    3 min → "Tempo Esgotado!"
                </div>
            </div>

            <div onclick="document.getElementById('section-combo').scrollIntoView({behavior:'smooth'})"
                 style="cursor:pointer;background:<?php echo $combo_on ? '#fefce8' : '#f9fafb'; ?>;border:1px solid <?php echo $combo_on ? '#fde68a' : '#e5e7eb'; ?>;border-radius:12px;padding:16px 20px;transition:transform .15s"
                 onmouseover="this.style.transform='scale(1.02)'" onmouseout="this.style.transform='scale(1)'">
                <div style="font-size:28px;margin-bottom:4px">🎁</div>
                <div style="font-weight:700;font-size:14px;color:<?php echo $combo_on ? '#92400e' : '#6b7280'; ?>">
                    Combo Upsell
                </div>
                <div style="font-size:12px;color:#6b7280;margin-top:2px">
                    <?php echo $combo_on ? '✅ Ativo' : '⭕ Desligado'; ?>
                </div>
                <div style="font-size:11px;color:#9ca3af;margin-top:4px">
                    "Adicione + 1 atração 10% OFF"
                </div>
            </div>

            <div onclick="document.getElementById('section-sticky-cta').scrollIntoView({behavior:'smooth'})"
                 style="cursor:pointer;background:<?php echo $sticky_cta_on ? '#f0f9ff' : '#f9fafb'; ?>;border:1px solid <?php echo $sticky_cta_on ? '#93c5fd' : '#e5e7eb'; ?>;border-radius:12px;padding:16px 20px;transition:transform .15s"
                 onmouseover="this.style.transform='scale(1.02)'" onmouseout="this.style.transform='scale(1)'">
                <div style="font-size:28px;margin-bottom:4px">📆</div>
                <div style="font-weight:700;font-size:14px;color:<?php echo $sticky_cta_on ? '#0369a1' : '#6b7280'; ?>">
                    Barra VER DATAS
                </div>
                <div style="font-size:12px;color:#6b7280;margin-top:2px">
                    <?php echo $sticky_cta_on ? '✅ Ativo' : '⭕ Desligado'; ?>
                </div>
                <div style="font-size:11px;color:#9ca3af;margin-top:4px">
                    Sticky bar na página de produto
                </div>
            </div>

        </div>

        <!-- Formulário de configuração -->
        <form id="vm2-gatilhos-form">

            <!-- SEÇÃO: Reservas -->
            <div id="section-reservas" style="background:#fff;border:1px solid #e5e7eb;border-radius:12px;padding:24px;margin-bottom:16px">
                <div style="display:flex;align-items:center;justify-content:space-between;flex-wrap:wrap;gap:12px;margin-bottom:16px">
                    <div>
                        <h3 style="margin:0;font-size:16px">🟢 Reservas Confirmadas</h3>
                        <p style="margin:4px 0 0;color:#6b7280;font-size:13px">
                            Exibe <em>"🟢 X reservas confirmadas"</em> em cada produto. O número = pedidos reais + offset por produto.
                        </p>
                    </div>
                    <label style="display:flex;align-items:center;gap:8px;cursor:pointer;background:<?php echo $reservas_on ? '#dcfce7' : '#f3f4f6'; ?>;padding:8px 16px;border-radius:8px;border:1px solid <?php echo $reservas_on ? '#86efac' : '#d1d5db'; ?>">
                        <input type="checkbox" name="reservas_enabled" id="reservas_enabled" value="1" <?php checked($reservas_on); ?>
                               style="width:18px;height:18px;cursor:pointer" onchange="updateToggleStyle(this,'reservas')">
                        <span id="lbl-reservas" style="font-weight:600;font-size:13px;color:<?php echo $reservas_on ? '#166534' : '#6b7280'; ?>">
                            <?php echo $reservas_on ? '✅ Ativo' : '⭕ Inativo'; ?>
                        </span>
                    </label>
                </div>

                <div style="display:grid;grid-template-columns:repeat(auto-fit,minmax(180px,1fr));gap:16px;background:#f9fafb;border-radius:8px;padding:16px">
                    <div>
                        <label style="font-size:12px;font-weight:600;color:#374151;display:block;margin-bottom:6px">
                            📏 Offset mínimo
                        </label>
                        <input type="number" name="offset_min" value="<?php echo esc_attr($offset_min); ?>" min="0" max="999"
                               style="width:100%;padding:8px 10px;border:1px solid #d1d5db;border-radius:6px;font-size:14px">
                        <p style="font-size:11px;color:#9ca3af;margin:4px 0 0">Mínimo somado ao real (padrão: 12)</p>
                    </div>
                    <div>
                        <label style="font-size:12px;font-weight:600;color:#374151;display:block;margin-bottom:6px">
                            📏 Offset máximo
                        </label>
                        <input type="number" name="offset_max" value="<?php echo esc_attr($offset_max); ?>" min="1" max="999"
                               style="width:100%;padding:8px 10px;border:1px solid #d1d5db;border-radius:6px;font-size:14px">
                        <p style="font-size:11px;color:#9ca3af;margin:4px 0 0">Máximo somado ao real (padrão: 47)</p>
                    </div>
                    <div style="display:flex;flex-direction:column;justify-content:center;background:#fff;border:1px solid #e5e7eb;border-radius:8px;padding:12px">
                        <div style="font-size:11px;color:#6b7280;margin-bottom:4px">🔮 Como funciona:</div>
                        <div style="font-size:12px;color:#374151">
                            Cada produto tem um <strong>offset fixo</strong> determinístico (crc32 do ID).<br>
                            Ex: produto ID 42 → sempre mesmo offset no intervalo definido.
                        </div>
                    </div>
                </div>
            </div>

            <!-- SEÇÃO: Estrelas -->
            <div id="section-stars" style="background:#fff;border:1px solid #e5e7eb;border-radius:12px;padding:24px;margin-bottom:16px">
                <div style="display:flex;align-items:center;justify-content:space-between;flex-wrap:wrap;gap:12px;margin-bottom:8px">
                    <div>
                        <h3 style="margin:0;font-size:16px">⭐ Estrelas &amp; Avaliações</h3>
                        <p style="margin:4px 0 0;color:#6b7280;font-size:13px">
                            Exibe rating (4.2–4.8★) e contagem de avaliações calculados automaticamente a partir das reservas.
                            <strong>Não usa reviews reais do WooCommerce.</strong>
                        </p>
                    </div>
                    <label style="display:flex;align-items:center;gap:8px;cursor:pointer;background:<?php echo $stars_on ? '#dcfce7' : '#f3f4f6'; ?>;padding:8px 16px;border-radius:8px;border:1px solid <?php echo $stars_on ? '#86efac' : '#d1d5db'; ?>">
                        <input type="checkbox" name="stars_enabled" id="stars_enabled" value="1" <?php checked($stars_on); ?>
                               style="width:18px;height:18px;cursor:pointer" onchange="updateToggleStyle(this,'stars')">
                        <span id="lbl-stars" style="font-weight:600;font-size:13px;color:<?php echo $stars_on ? '#166534' : '#6b7280'; ?>">
                            <?php echo $stars_on ? '✅ Ativo' : '⭕ Inativo'; ?>
                        </span>
                    </label>
                </div>

                <div style="background:#f9fafb;border-radius:8px;padding:12px 16px;font-size:12px;color:#6b7280">
                    <strong>Fórmula de rating:</strong>
                    &lt;15 reservas → 4.2★ &nbsp;|&nbsp;
                    15–25 → 4.4★ &nbsp;|&nbsp;
                    26–35 → 4.6★ &nbsp;|&nbsp;
                    36–45 → 4.7★ &nbsp;|&nbsp;
                    46+ → 4.8★
                    <em>(±0.0/0.1/0.2 variação por produto)</em>
                </div>
            </div>

            <!-- SEÇÃO: Disponibilidade -->
            <div id="section-disp" style="background:#fff;border:1px solid #e5e7eb;border-radius:12px;padding:24px;margin-bottom:24px">
                <div style="display:flex;align-items:center;justify-content:space-between;flex-wrap:wrap;gap:12px;margin-bottom:8px">
                    <div>
                        <h3 style="margin:0;font-size:16px">📅 Disponibilidade do Mês</h3>
                        <p style="margin:4px 0 0;color:#6b7280;font-size:13px">
                            Exibe datas disponíveis no mês atual. <strong>Requer plugin WooCommerce Bookings ativo.</strong>
                            Se Bookings não estiver ativo, este badge não aparece automaticamente.
                        </p>
                    </div>
                    <label style="display:flex;align-items:center;gap:8px;cursor:pointer;background:<?php echo $disp_on ? '#dcfce7' : '#f3f4f6'; ?>;padding:8px 16px;border-radius:8px;border:1px solid <?php echo $disp_on ? '#86efac' : '#d1d5db'; ?>">
                        <input type="checkbox" name="disp_enabled" id="disp_enabled" value="1" <?php checked($disp_on); ?>
                               style="width:18px;height:18px;cursor:pointer" onchange="updateToggleStyle(this,'disp')">
                        <span id="lbl-disp" style="font-weight:600;font-size:13px;color:<?php echo $disp_on ? '#166534' : '#6b7280'; ?>">
                            <?php echo $disp_on ? '✅ Ativo' : '⭕ Inativo'; ?>
                        </span>
                    </label>
                </div>

                <div style="background:#f9fafb;border-radius:8px;padding:12px 16px;font-size:12px;color:#6b7280">
                    <strong>Cores:</strong>
                    🔴 1–2 datas restantes &nbsp;|&nbsp;
                    🟡 3–5 datas &nbsp;|&nbsp;
                    🟢 6+ datas
                    &nbsp;|&nbsp; Cache: 1 hora
                </div>
            </div>

            <!-- SEÇÃO: Badge de Desconto -->
            <div id="section-discount" style="background:#fff;border:1px solid #e5e7eb;border-radius:12px;padding:24px;margin-bottom:24px">
                <div style="display:flex;align-items:center;justify-content:space-between;flex-wrap:wrap;gap:12px;margin-bottom:8px">
                    <div>
                        <h3 style="margin:0;font-size:16px">🏷️ Badge de Desconto (-X% OFF)</h3>
                        <p style="margin:4px 0 0;color:#6b7280;font-size:13px">
                            Exibe o badge <strong style="background:#e25020;color:#fff;padding:1px 6px;border-radius:3px;font-size:11px">-50% OFF</strong>
                            e o preço original riscado nos cards de produto com preço promocional.
                            <strong>Plugin: VivaMais Hub</strong> (classes <code>vmap-badge</code> e <code>vmap-de</code>).
                        </p>
                    </div>
                    <label style="display:flex;align-items:center;gap:8px;cursor:pointer;background:<?php echo $discount_on ? '#dcfce7' : '#f3f4f6'; ?>;padding:8px 16px;border-radius:8px;border:1px solid <?php echo $discount_on ? '#86efac' : '#d1d5db'; ?>">
                        <input type="checkbox" name="discount_badge_enabled" id="discount_badge_enabled" value="1" <?php checked($discount_on); ?>
                               style="width:18px;height:18px;cursor:pointer" onchange="updateToggleStyle(this,'discount')">
                        <span id="lbl-discount" style="font-weight:600;font-size:13px;color:<?php echo $discount_on ? '#166534' : '#6b7280'; ?>">
                            <?php echo $discount_on ? '✅ Ativo' : '⭕ Inativo'; ?>
                        </span>
                    </label>
                </div>

                <div style="background:#f9fafb;border-radius:8px;padding:12px 16px;font-size:12px;color:#6b7280">
                    <strong>Como funciona:</strong> Quando ativo, o Hub exibe o preço original riscado (<del>R$ 3.800</del>) e o badge colorido com a % de desconto
                    calculada automaticamente a partir do preço regular × preço de venda do produto WooCommerce.
                    Quando <em>desligado</em>, o CRM V2 injeta <code>display:none</code> via <code>wp_head</code> para ocultar ambos os elementos.
                </div>
            </div>

            <!-- SEÇÃO: Countdown Carrinho -->
            <div id="section-countdown" style="background:#fff;border:1px solid #e5e7eb;border-radius:12px;padding:24px;margin-bottom:24px">
                <div style="display:flex;align-items:center;justify-content:space-between;flex-wrap:wrap;gap:12px;margin-bottom:16px">
                    <div>
                        <h3 style="margin:0;font-size:16px">⏱️ Countdown do Carrinho</h3>
                        <p style="margin:4px 0 0;color:#6b7280;font-size:13px">
                            Exibe barra de contagem regressiva de 3 minutos na página do carrinho. Quando expira, mostra
                            <em>&#34;😱 Tempo esgotado!&#34;</em> e esvazia o carrinho automaticamente.
                            <br><strong>Plugin: VivaMais WA Capture</strong> (elemento <code>#vm-wa-countdown-bar</code>).
                        </p>
                    </div>
                    <label style="display:flex;align-items:center;gap:8px;cursor:pointer;background:<?php echo $countdown_on ? '#dcfce7' : '#f3f4f6'; ?>;padding:8px 16px;border-radius:8px;border:1px solid <?php echo $countdown_on ? '#86efac' : '#d1d5db'; ?>">
                        <input type="checkbox" name="countdown_enabled" id="countdown_enabled" value="1" <?php checked($countdown_on); ?>
                               style="width:18px;height:18px;cursor:pointer" onchange="updateToggleStyle(this,'countdown')">
                        <span id="lbl-countdown" style="font-weight:600;font-size:13px;color:<?php echo $countdown_on ? '#166534' : '#6b7280'; ?>">
                            <?php echo $countdown_on ? '✅ Ativo' : '⭕ Inativo'; ?>
                        </span>
                    </label>
                </div>

                <div style="background:#f9fafb;border-radius:8px;padding:12px 16px;font-size:12px;color:#6b7280">
                    <strong>Como funciona:</strong> Quando ativo, o wa-capture injeta uma barra roxa no topo do carrinho com contador regressivo de 3 minutos.
                    Se o cliente não finalizar a compra antes do tempo, o carrinho é esvaziado e aparece a tela <em>&#34;Tempo esgotado!&#34;</em> com botão
                    <em>&#34;Escolher Novamente&#34;</em>. O timer reinicia a cada nova sessão (baseado em sessionStorage).
                    Quando <em>desligado</em> (via <code>vm2_wa_countdown_enabled = 0</code>), o wa-capture não injeta o HTML — o timer nunca aparece.
                </div>
            </div>

            <!-- SEÇÃO: Combo Upsell -->
            <div id="section-combo" style="background:#fff;border:1px solid #e5e7eb;border-radius:12px;padding:24px;margin-bottom:24px">
                <div style="display:flex;align-items:center;justify-content:space-between;flex-wrap:wrap;gap:12px;margin-bottom:16px">
                    <div>
                        <h3 style="margin:0;font-size:16px">🎁 Combo Upsell</h3>
                        <p style="margin:4px 0 0;color:#6b7280;font-size:13px">
                            Exibe bloco "Adicione mais uma atração e ganhe 10% OFF" na página do carrinho,
                            com sugestões de produtos populares e cupom <code>COMBO10</code>.<br>
                            <strong>Plugin: VivaMais WA Capture</strong> (elemento <code>#vm-wa-combo-section</code>).
                            <strong style="color:#dc2626">Por padrão: desligado.</strong>
                        </p>
                    </div>
                    <label style="display:flex;align-items:center;gap:8px;cursor:pointer;background:<?php echo $combo_on ? '#fefce8' : '#f3f4f6'; ?>;padding:8px 16px;border-radius:8px;border:1px solid <?php echo $combo_on ? '#fde68a' : '#d1d5db'; ?>">
                        <input type="checkbox" name="combo_enabled" id="combo_enabled" value="1" <?php checked($combo_on); ?>
                               style="width:18px;height:18px;cursor:pointer" onchange="updateToggleStyle(this,'combo')">
                        <span id="lbl-combo" style="font-weight:600;font-size:13px;color:<?php echo $combo_on ? '#92400e' : '#6b7280'; ?>">
                            <?php echo $combo_on ? '✅ Ativo' : '⭕ Inativo'; ?>
                        </span>
                    </label>
                </div>
                <div style="background:#f9fafb;border-radius:8px;padding:12px 16px;font-size:12px;color:#6b7280">
                    <strong>Como funciona:</strong> Quando ativo, o wa-capture exibe um bloco escuro/dourado no carrinho com
                    3 sugestões de atrações populares. O cliente pode clicar em "+ ADICIONAR AO COMBO" para incluir mais produtos.
                    Ao usar o cupom <code>COMBO10</code>, o desconto de 10% é aplicado automaticamente (válido apenas com 2+ atrações).
                    Quando <em>desligado</em> (padrão), o bloco não é renderizado — nenhuma confusão no carrinho.
                </div>
            </div>

            <!-- SEÇÃO: Barra VER DATAS -->
            <div id="section-sticky-cta" style="background:#fff;border:1px solid #e5e7eb;border-radius:12px;padding:24px;margin-bottom:24px">
                <div style="display:flex;align-items:center;justify-content:space-between;flex-wrap:wrap;gap:12px;margin-bottom:16px">
                    <div>
                        <h3 style="margin:0;font-size:16px">📆 Barra VER DATAS</h3>
                        <p style="margin:4px 0 0;color:#6b7280;font-size:13px">
                            Barra sticky no rodapé das páginas de produto com preço e botão <strong>VER DATAS ›</strong> que rola até o calendário de disponibilidade.<br>
                            <strong>Plugin: VivaMais Hub</strong> (elemento <code>#vm-sticky-product-cta</code>).
                            <strong style="color:#dc2626">Por padrão: desligada</strong> — pode competir com a SofIA.
                        </p>
                    </div>
                    <label style="display:flex;align-items:center;gap:8px;cursor:pointer;background:<?php echo $sticky_cta_on ? '#dcfce7' : '#f3f4f6'; ?>;padding:8px 16px;border-radius:8px;border:1px solid <?php echo $sticky_cta_on ? '#86efac' : '#d1d5db'; ?>">
                        <input type="checkbox" name="sticky_cta_enabled" id="sticky_cta_enabled" value="1" <?php checked($sticky_cta_on); ?>
                               style="width:18px;height:18px;cursor:pointer" onchange="updateToggleStyle(this,'sticky-cta')">
                        <span id="lbl-sticky-cta" style="font-weight:600;font-size:13px;color:<?php echo $sticky_cta_on ? '#166534' : '#6b7280'; ?>">
                            <?php echo $sticky_cta_on ? '✅ Ativo' : '⭕ Inativo'; ?>
                        </span>
                    </label>
                </div>
                <div style="background:#f9fafb;border-radius:8px;padding:12px 16px;font-size:12px;color:#6b7280">
                    <strong>Como funciona:</strong> Quando ativa, o Hub exibe uma barra roxa fixa no rodapé das páginas de produto com o preço e o botão <em>"VER DATAS ›"</em>,
                    que ao clicar rola a página até o calendário do WooCommerce Bookings.
                    Quando <em>desligada</em> (padrão), o CRM V2 injeta <code>#vm-sticky-product-cta{display:none!important}</code> via <code>wp_head</code> — a barra nunca aparece,
                    deixando a SofIA como único CTA flutuante.
                </div>
            </div>

            <!-- Botão Salvar -->
            <div style="display:flex;align-items:center;gap:16px;flex-wrap:wrap">
                <button type="button" id="btn-save-gatilhos"
                        onclick="vm2SaveGatilhos()"
                        style="background:#2563eb;color:#fff;border:none;padding:12px 28px;border-radius:8px;font-size:15px;font-weight:600;cursor:pointer;display:flex;align-items:center;gap:8px">
                    💾 Salvar Configurações
                </button>
                <div id="gatilhos-msg" style="font-size:13px"></div>
            </div>

        </form>

        <!-- Preview estático -->
        <div style="margin-top:32px;background:#fff;border:1px solid #e5e7eb;border-radius:12px;padding:24px">
            <h3 style="margin:0 0 16px;font-size:15px">👁️ Preview — Como aparece no produto</h3>
            <div style="display:flex;flex-wrap:wrap;gap:24px">
                <!-- Single product -->
                <div style="border:1px solid #e5e7eb;border-radius:8px;padding:16px;min-width:220px">
                    <div style="font-size:11px;font-weight:600;color:#9ca3af;margin-bottom:12px;text-transform:uppercase;letter-spacing:.05em">Página do Produto</div>
                    <?php if ($reservas_on) : ?>
                    <div style="font-size:13px;color:#276749;font-weight:600;margin-bottom:4px">🟢 <?php echo $offset_min + 5; ?> reservas confirmadas</div>
                    <?php endif; ?>
                    <?php if ($stars_on) : ?>
                    <div style="display:flex;align-items:center;gap:5px;margin-bottom:8px">
                        <span style="color:#f5a623;font-size:14px">★★★★★</span>
                        <span style="font-size:12px;color:#555;font-weight:600">4,6 <span style="font-weight:400;color:#888">(18 avaliações)</span></span>
                    </div>
                    <?php endif; ?>
                    <?php if ($disp_on) : ?>
                    <div style="background:#276749;color:#fff;font-size:11px;font-weight:700;padding:4px 10px;border-radius:4px;display:inline-block">
                        🟢 Agenda aberta para <?php echo ucfirst(date_i18n('F')); ?>
                    </div>
                    <?php endif; ?>
                    <?php if ($discount_on) : ?>
                    <div style="margin-top:8px;display:flex;align-items:center;gap:8px">
                        <del style="font-size:12px;color:#9ca3af">R$ 3.800</del>
                        <span style="background:#e25020;color:#fff;font-size:11px;font-weight:700;padding:2px 7px;border-radius:3px">-50% OFF</span>
                    </div>
                    <?php endif; ?>
                    <?php if (!$reservas_on && !$stars_on && !$disp_on && !$discount_on) : ?>
                    <div style="color:#9ca3af;font-size:13px">Nenhum elemento ativo</div>
                    <?php endif; ?>
                </div>
                <!-- Loop / catálogo -->
                <div style="border:1px solid #e5e7eb;border-radius:8px;padding:16px;min-width:160px">
                    <div style="font-size:11px;font-weight:600;color:#9ca3af;margin-bottom:12px;text-transform:uppercase;letter-spacing:.05em">Catálogo / Loja</div>
                    <div style="font-size:13px;color:#374151;font-weight:500;margin-bottom:8px">🎤 Nome do Produto</div>
                    <?php if ($reservas_on) : ?>
                    <div style="font-size:11px;color:#276749;font-weight:600;text-align:center;margin-bottom:3px">🟢 <?php echo $offset_min + 5; ?> reservas confirmadas</div>
                    <?php endif; ?>
                    <?php if ($stars_on) : ?>
                    <div style="display:flex;align-items:center;justify-content:center;gap:4px">
                        <span style="color:#f5a623;font-size:12px">★★★★★</span>
                        <span style="font-size:11px;color:#555;font-weight:600">4,6</span>
                        <span style="font-size:10px;color:#888">(18)</span>
                    </div>
                    <?php endif; ?>
                    <?php if ($discount_on) : ?>
                    <div style="display:flex;align-items:center;justify-content:center;gap:6px;margin-top:6px">
                        <del style="font-size:11px;color:#9ca3af">R$ 3.800</del>
                        <span style="background:#e25020;color:#fff;font-size:10px;font-weight:700;padding:1px 5px;border-radius:3px">-50% OFF</span>
                    </div>
                    <?php endif; ?>
                    <?php if (!$reservas_on && !$stars_on && !$discount_on) : ?>
                    <div style="color:#9ca3af;font-size:12px;text-align:center">Nenhum elemento ativo</div>
                    <?php endif; ?>
                </div>
            </div>
            <p style="font-size:11px;color:#9ca3af;margin-top:12px">
                * Preview estático com valores de exemplo. Os valores reais variam por produto (calculados automaticamente).
                <?php if ($countdown_on) : ?>
                <br><br><strong>Carrinho ativo:</strong>
                <div style="background:#1e0b4b;border-radius:8px;padding:10px 14px;margin-top:8px;display:flex;align-items:center;gap:10px">
                    <span style="font-size:18px">⏱️</span>
                    <span style="color:#fff;font-size:13px">Seus itens estão reservados por <strong>03:00</strong></span>
                </div>
                <?php else : ?>
                <br><br><em style="color:#ef4444;font-size:12px">⏱️ Countdown do carrinho <strong>desligado</strong></em>
                <?php endif; ?>
            </p>
        </div>

    </div>

    <script>
    function updateToggleStyle(el, key) {
        var lbl = document.getElementById('lbl-' + key);
        var wrap = el.parentElement;
        if (el.checked) {
            wrap.style.background = '#dcfce7';
            wrap.style.borderColor = '#86efac';
            lbl.style.color = '#166534';
            lbl.textContent = '✅ Ativo';
        } else {
            wrap.style.background = '#f3f4f6';
            wrap.style.borderColor = '#d1d5db';
            lbl.style.color = '#6b7280';
            lbl.textContent = '⭕ Inativo';
        }
    }

    function vm2SaveGatilhos() {
        var btn = document.getElementById('btn-save-gatilhos');
        var msg = document.getElementById('gatilhos-msg');
        var form = document.getElementById('vm2-gatilhos-form');
        btn.disabled = true;
        btn.textContent = '⏳ Salvando...';
        msg.textContent = '';

        var data = new FormData();
        data.append('action', 'vm2_gatilhos_save');
        data.append('nonce', '<?php echo esc_js($nonce); ?>');
        data.append('reservas_enabled',       form.querySelector('[name=reservas_enabled]').checked ? '1' : '0');
        data.append('stars_enabled',          form.querySelector('[name=stars_enabled]').checked ? '1' : '0');
        data.append('disp_enabled',           form.querySelector('[name=disp_enabled]').checked ? '1' : '0');
        data.append('discount_badge_enabled', form.querySelector('[name=discount_badge_enabled]').checked ? '1' : '0');
        data.append('countdown_enabled',      form.querySelector('[name=countdown_enabled]').checked      ? '1' : '0');
        data.append('combo_enabled',          form.querySelector('[name=combo_enabled]').checked          ? '1' : '0');
        data.append('sticky_cta_enabled',     form.querySelector('[name=sticky_cta_enabled]').checked     ? '1' : '0');
        data.append('offset_min', form.querySelector('[name=offset_min]').value);
        data.append('offset_max', form.querySelector('[name=offset_max]').value);

        fetch('<?php echo esc_js(admin_url('admin-ajax.php')); ?>', {method:'POST', body:data})
            .then(r => r.json())
            .then(res => {
                btn.disabled = false;
                btn.textContent = '💾 Salvar Configurações';
                if (res.success) {
                    msg.innerHTML = '<span style="color:#166534;font-weight:600">' + res.data.message + '</span>';
                    setTimeout(() => location.reload(), 1200);
                } else {
                    msg.innerHTML = '<span style="color:#991b1b">❌ Erro ao salvar.</span>';
                }
            })
            .catch(() => {
                btn.disabled = false;
                btn.textContent = '💾 Salvar Configurações';
                msg.innerHTML = '<span style="color:#991b1b">❌ Erro de conexão.</span>';
            });
    }
    </script>
    <?php
}

// ── SuperPWA — Tradução das mensagens offline/online ─────────────────────────
add_action('wp_footer', function() {
    if (is_admin()) return;
    
?>
<script>
(function() {
    function fixSuperpwaMsgs() {
        if (typeof superpwa_sw !== 'undefined') {
            superpwa_sw.offline_message_txt = 'Você está sem conexão com a internet.';
            superpwa_sw.online_message_txt  = 'Você voltou a ter conexão! <a href="javascript:location.reload()">Atualizar</a>';
        }
    }
    fixSuperpwaMsgs();
    document.addEventListener('DOMContentLoaded', fixSuperpwaMsgs);
})();
</script>
    <?php
}, 99);


// ═══════════════════════════════════════════════════════════════════════════════
// SOFIA INTELLIGENCE — CRM V2 v1.5.50
// ═══════════════════════════════════════════════════════════════════════════════

// ── Criação da tabela ──────────────────────────────────────────────────────────
function vm2_create_sofia_table() {
    global $wpdb;
    $t   = $wpdb->prefix . 'vm2_sofia_sessions';
    $sql = "CREATE TABLE IF NOT EXISTS $t (
      id                  bigint(20) NOT NULL AUTO_INCREMENT,
      session_id          varchar(64) NOT NULL,
      persistent_uid      varchar(64) DEFAULT NULL,
      started_at          datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
      ended_at            datetime DEFAULT NULL,
      product_id          bigint(20) DEFAULT NULL,
      product_name        varchar(255) DEFAULT NULL,
      whatsapp            varchar(30) DEFAULT NULL,
      wa_captured_at      datetime DEFAULT NULL,
      wa_capture_trigger  varchar(50) DEFAULT NULL,
      categoria           varchar(60) DEFAULT NULL,
      tipo_evento         varchar(120) DEFAULT NULL,
      data_evento_str     varchar(30) DEFAULT NULL,
      urgencia            varchar(20) DEFAULT NULL,
      mensagens_count     int NOT NULL DEFAULT 0,
      signals             longtext DEFAULT NULL,
      historico           longtext DEFAULT NULL,
      converted           tinyint(1) NOT NULL DEFAULT 0,
      source_url          varchar(512) DEFAULT NULL,
      email               varchar(100) DEFAULT NULL,
      PRIMARY KEY (id),
      UNIQUE KEY session_id (session_id),
      KEY whatsapp (whatsapp),
      KEY started_at (started_at),
      KEY categoria (categoria),
      KEY persistent_uid (persistent_uid),
      KEY converted (converted)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;";
    require_once ABSPATH . 'wp-admin/includes/upgrade.php';
    dbDelta($sql);
    // Garantir colunas adicionadas em versões posteriores (defensive migration)
    $existing_cols = $wpdb->get_col("DESCRIBE $t");
    if ( is_array($existing_cols) ) {
        if ( ! in_array('persistent_uid', $existing_cols) ) {
            $wpdb->query("ALTER TABLE $t ADD COLUMN persistent_uid varchar(64) DEFAULT NULL");
            $wpdb->query("ALTER TABLE $t ADD KEY persistent_uid_idx (persistent_uid)");
        }
        if ( ! in_array('wa_captured_at', $existing_cols) ) {
            $wpdb->query("ALTER TABLE $t ADD COLUMN wa_captured_at datetime DEFAULT NULL");
        }
        if ( ! in_array('utm_source', $existing_cols) ) {
            $wpdb->query("ALTER TABLE $t ADD COLUMN utm_source varchar(100) DEFAULT NULL");
        }
        if ( ! in_array('utm_medium', $existing_cols) ) {
            $wpdb->query("ALTER TABLE $t ADD COLUMN utm_medium varchar(100) DEFAULT NULL");
        }
        if ( ! in_array('utm_campaign', $existing_cols) ) {
            $wpdb->query("ALTER TABLE $t ADD COLUMN utm_campaign varchar(255) DEFAULT NULL");
        }
        if ( ! in_array('canal_origem', $existing_cols) ) {
            $wpdb->query("ALTER TABLE $t ADD COLUMN canal_origem varchar(60) DEFAULT NULL");
        }
        // v1.5.91: email capture
        if ( ! in_array('email', $existing_cols) ) {
            $wpdb->query("ALTER TABLE $t ADD COLUMN email varchar(100) DEFAULT NULL");
        }
    }
    // init em runtime também
    add_action('init', function() {
        static $done = false;
        if ($done) return; $done = true;
        global $wpdb;
        $t = $wpdb->prefix . 'vm2_sofia_sessions';
        if ($wpdb->get_var("SHOW TABLES LIKE '$t'") !== $t) {
            vm2_create_sofia_table();
        }
    });
}
add_action('plugins_loaded', 'vm2_create_sofia_table', 5);

// ═══════════════════════════════════════════════════════════════════════════════
// SOFIA KNOWLEDGE BASE
// ═══════════════════════════════════════════════════════════════════════════════
function vm2_create_sofia_knowledge_table() {
    global $wpdb;
    $t = $wpdb->prefix . 'vm2_sofia_knowledge';
    if ( $wpdb->get_var("SHOW TABLES LIKE '$t'") === $t ) return;
    $charset = $wpdb->get_charset_collate();
    $sql = "CREATE TABLE $t (
        id BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
        tipo VARCHAR(20) NOT NULL DEFAULT 'texto',
        titulo VARCHAR(255) NOT NULL DEFAULT '',
        conteudo LONGTEXT,
        url VARCHAR(512) DEFAULT NULL,
        ativo TINYINT(1) NOT NULL DEFAULT 1,
        criado_em DATETIME DEFAULT NULL,
        PRIMARY KEY (id)
    ) $charset;";
    require_once ABSPATH . 'wp-admin/includes/upgrade.php';
    dbDelta( $sql );
}
add_action( 'plugins_loaded', 'vm2_create_sofia_knowledge_table', 6 );

function vm2_sofia_kb_scrape_url( $url ) {
    // Google Docs → exportar como texto plano
    if ( preg_match( '#docs\.google\.com/document/d/([a-zA-Z0-9_-]+)#', $url, $m ) ) {
        $export = 'https://docs.google.com/document/d/' . $m[1] . '/export?format=txt';
        $resp   = wp_remote_get( $export, array( 'timeout' => 20, 'sslverify' => false ) );
        if ( ! is_wp_error( $resp ) && wp_remote_retrieve_response_code( $resp ) === 200 ) {
            $text = wp_remote_retrieve_body( $resp );
            $text = preg_replace( '/\s+/', ' ', $text );
            return array( 'titulo' => 'Google Doc importado', 'conteudo' => mb_substr( trim( $text ), 0, 15000 ) );
        }
    }
    // Google Drive file (not Doc) — drive.google.com/file/d/ID
    if ( preg_match( '#drive\.google\.com/file/d/([a-zA-Z0-9_-]+)#', $url, $m ) ) {
        return array( 'erro' => 'Arquivos do Google Drive precisam ser convertidos para Google Docs ou ter o texto colado diretamente. Dica: abra o arquivo, copie o texto e use o tipo "Texto livre".' );
    }
    // URL normal
    $resp = wp_remote_get( $url, array(
        'timeout'   => 20,
        'sslverify' => false,
        'headers'   => array( 'User-Agent' => 'Mozilla/5.0 (compatible; VivaMaisBot/1.0)' ),
    ) );
    if ( is_wp_error( $resp ) ) {
        return array( 'erro' => 'Erro ao acessar URL: ' . $resp->get_error_message() );
    }
    $code = wp_remote_retrieve_response_code( $resp );
    if ( $code !== 200 ) {
        return array( 'erro' => "URL retornou HTTP {$code} — verifique se é pública." );
    }
    $html  = wp_remote_retrieve_body( $resp );
    $titulo = '';
    if ( preg_match( '#<title[^>]*>(.*?)</title>#si', $html, $tm ) ) {
        $titulo = html_entity_decode( strip_tags( $tm[1] ), ENT_QUOTES, 'UTF-8' );
        $titulo = trim( $titulo );
    }
    // Remove script/style/nav/footer
    $html = preg_replace( '#<(script|style|nav|footer|header|aside)[^>]*>.*?</\1>#si', ' ', $html );
    $text = strip_tags( $html );
    $text = html_entity_decode( $text, ENT_QUOTES, 'UTF-8' );
    $text = preg_replace( '/\s+/', ' ', $text );
    $text = trim( $text );
    return array(
        'titulo'   => $titulo ?: ( parse_url( $url, PHP_URL_HOST ) ?: $url ),
        'conteudo' => mb_substr( $text, 0, 15000 ),
    );
}

// AJAX: salvar item
add_action( 'wp_ajax_vm2_sofia_kb_save', 'vm2_sofia_kb_save_handler' );

// ─────────────────────────────────────────────────────────────
// PIPELINE TAB — Funil visual Fontes → Segmentos → Automações
// ─────────────────────────────────────────────────────────────
function vm2_render_pipeline_tab() {
    global $wpdb;
    $table = $wpdb->prefix . 'vm2_contacts';
    $sends = $wpdb->prefix . 'vm2_sends';

    // ── Fontes ──
    $total_contacts = (int)$wpdb->get_var("SELECT COUNT(*) FROM $table");
    $cnt_pedido   = (int)$wpdb->get_var("SELECT COUNT(*) FROM $table WHERE origens LIKE '%\"pedido\"%'");
    $cnt_sofia    = (int)$wpdb->get_var("SELECT COUNT(*) FROM $table WHERE origens LIKE '%\"sofia\"%'");
    $cnt_galeria  = (int)$wpdb->get_var("SELECT COUNT(*) FROM $table WHERE origens LIKE '%\"galeria\"%'");
    $cnt_carrinho = (int)$wpdb->get_var("SELECT COUNT(*) FROM $table WHERE origens LIKE '%\"carrinho\"%'");
    $cnt_kommo    = (int)$wpdb->get_var("SELECT COUNT(*) FROM $table WHERE origens LIKE '%\"kommo\"%'");

    // ── Segmentos ──
    $cnt_hot     = (int)$wpdb->get_var("SELECT COUNT(*) FROM $table WHERE score >= 70");
    $cnt_urgente = (int)$wpdb->get_var("SELECT COUNT(*) FROM $table WHERE data_evento >= CURDATE() AND data_evento <= DATE_ADD(CURDATE(), INTERVAL 7 DAY)");
    $cnt_warm    = (int)$wpdb->get_var("SELECT COUNT(*) FROM $table WHERE score >= 40 AND score < 70");
    $cnt_semdata = (int)$wpdb->get_var("SELECT COUNT(*) FROM $table WHERE (data_evento IS NULL OR data_evento = '') AND score < 70");
    $cnt_clientes= $cnt_pedido;

    // ── Automações: status ──
    $aquecer_kill = get_option('vm2_aquecer_kill', '1');
    $aa_on        = get_option('vm2_auto_aquecer_on', '0');
    $hot_kill     = get_option('vm2_hot_kill', '1');
    $bydate_kill  = get_option('vm2_bydate_kill', '1');
    $cart_kill    = (bool)get_option('vm_wa_kill_switch', 0);

    // ── Envios hoje por módulo ──
    $today     = current_time('Y-m-d');
    $today_rows = $wpdb->get_results($wpdb->prepare(
        "SELECT module, COUNT(*) as cnt FROM $sends WHERE DATE(sent_at) = %s GROUP BY module",
        $today
    ), OBJECT_K);
    $get_today = function($mod) use ($today_rows) {
        return isset($today_rows[$mod]) ? (int)$today_rows[$mod]->cnt : 0;
    };
    $today_total = (int)$wpdb->get_var($wpdb->prepare(
        "SELECT COUNT(*) FROM $sends WHERE DATE(sent_at) = %s", $today
    ));

    // ── Log recente ──
    $log_rows = $wpdb->get_results(
        "SELECT s.phone, s.module, s.sent_at, c.name
         FROM {$wpdb->prefix}vm2_sends s
         LEFT JOIN $table c ON c.phone = s.phone
         ORDER BY s.id DESC LIMIT 20"
    );

    $mod_labels = [
        'aquecer'      => ['label' => '🔥 Aquecer D+X',  'color' => '#e74c3c'],
        'auto_aquecer' => ['label' => '🤖 Auto-Aquecer', 'color' => '#9b59b6'],
        'leads'        => ['label' => '🎯 Leads HOT',    'color' => '#e67e22'],
        'bydate'       => ['label' => '📅 Por Data',     'color' => '#3498db'],
        'carrinho'     => ['label' => '🛒 Carrinho',     'color' => '#27ae60'],
    ];

    $contacts_url = admin_url('admin.php?page=vm2-contacts');
    $auto_url     = admin_url('admin.php?page=vm2-automacoes');
    ?>
    <style>
    .vm2pl-total{text-align:center;background:#fffbeb;border:1px solid #fcd34d;border-radius:8px;padding:10px 16px;margin-bottom:16px;font-size:13px}
    .vm2pl-total strong{font-size:22px;color:#b45309}
    .vm2pl-grid{display:grid;grid-template-columns:1fr 36px 1fr 36px 1fr;gap:0;align-items:start;margin-bottom:20px}
    @media(max-width:900px){.vm2pl-grid{grid-template-columns:1fr}.vm2pl-arrow{transform:rotate(90deg);margin:6px auto!important;padding-top:0!important}}
    .vm2pl-col{background:#fff;border:1px solid #e8eaed;border-radius:10px;padding:14px 16px}
    .vm2pl-col h3{font-size:11px;font-weight:800;color:#1a1a2e;margin:0 0 10px;padding-bottom:8px;border-bottom:2px solid #f0f0f0;text-transform:uppercase;letter-spacing:.6px}
    .vm2pl-card{display:flex;align-items:center;justify-content:space-between;padding:7px 10px;border-radius:7px;margin-bottom:5px;background:#f8f9fa;cursor:pointer;transition:all .15s;text-decoration:none;color:inherit}
    .vm2pl-card:hover{background:#eef2ff;transform:translateX(2px)}
    .vm2pl-card-auto{flex-direction:column;align-items:flex-start;gap:3px}
    .vm2pl-left{display:flex;align-items:center;gap:7px;font-size:12px;font-weight:600}
    .vm2pl-badge{font-size:12px;font-weight:800;background:#1a1a2e;color:#FFD700;padding:2px 8px;border-radius:12px;min-width:26px;text-align:center}
    .vm2pl-arrow{display:flex;align-items:center;justify-content:center;color:#9ca3af;font-size:20px;padding-top:44px}
    .vm2pl-status{display:inline-flex;align-items:center;gap:3px;font-size:10px;font-weight:700;padding:2px 7px;border-radius:10px}
    .vm2pl-status.on{background:#dcfce7;color:#16a34a}
    .vm2pl-status.off{background:#fee2e2;color:#dc2626}
    .vm2pl-auto-row{display:flex;align-items:center;justify-content:space-between;width:100%}
    .vm2pl-sub{font-size:10px;color:#6b7280;padding-left:2px}
    .vm2pl-col-footer{margin-top:8px;padding-top:8px;border-top:1px solid #f0f0f0;font-size:11px;color:#9ca3af;text-align:center}
    .vm2pl-log{background:#fff;border:1px solid #e8eaed;border-radius:10px;padding:16px}
    .vm2pl-log h3{font-size:11px;font-weight:800;color:#1a1a2e;margin:0 0 10px;text-transform:uppercase;letter-spacing:.6px}
    .vm2pl-log-row{display:flex;align-items:center;gap:8px;padding:5px 0;border-bottom:1px solid #f4f4f4;font-size:12px}
    .vm2pl-log-row:last-child{border-bottom:none}
    .vm2pl-log-mod{width:105px;flex-shrink:0}
    .vm2pl-log-time{color:#9ca3af;white-space:nowrap;margin-left:auto;font-size:11px}
    .vm2pl-log-name{flex:1;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;font-weight:500}
    .vm2pl-log-phone{color:#6b7280;font-size:11px;white-space:nowrap}
    </style>

    <div class="vm2pl-total">
        Total de mensagens enviadas hoje: <strong><?php echo $today_total; ?></strong>
        &nbsp;·&nbsp; <?php echo $total_contacts; ?> contatos na base
    </div>

    <div class="vm2pl-grid">

        <!-- ── COLUNA 1: FONTES ── -->
        <div class="vm2pl-col">
            <h3>📥 Fontes de Leads</h3>
            <?php
            $fontes = [
                ['🛒 WooCommerce',  $cnt_pedido,   $contacts_url . '&source=pedido'],
                ['🧠 SofIA',        $cnt_sofia,    $contacts_url . '&source=sofia'],
                ['📸 Galeria',      $cnt_galeria,  $contacts_url . '&source=galeria'],
                ['🛒 Carrinho',     $cnt_carrinho, $contacts_url . '&source=carrinho'],
                ['🔥 Kommo',        $cnt_kommo,    $contacts_url . '&source=kommo'],
            ];
            foreach ($fontes as [$label, $count, $url]):
            ?>
            <a class="vm2pl-card" href="<?php echo esc_url($url); ?>">
                <span class="vm2pl-left"><?php echo $label; ?></span>
                <span class="vm2pl-badge"><?php echo $count; ?></span>
            </a>
            <?php endforeach; ?>
            <div class="vm2pl-col-footer">
                <a href="<?php echo esc_url($contacts_url); ?>" style="color:#3b82f6;text-decoration:none">
                    Ver todos os <?php echo $total_contacts; ?> contatos →
                </a>
            </div>
        </div>

        <!-- seta -->
        <div class="vm2pl-arrow">→</div>

        <!-- ── COLUNA 2: SEGMENTOS ── -->
        <div class="vm2pl-col">
            <h3>👥 Segmentos</h3>
            <?php
            $segs = [
                ['🔥 HOT (score ≥ 70)',   $cnt_hot,     $contacts_url . '&score_f=hot'],
                ['⚡ Urgente (≤ 7 dias)', $cnt_urgente, $contacts_url . '&dp=urgente'],
                ['🌡️ Warm (score 40–69)', $cnt_warm,    $contacts_url . '&score_f=warm'],
                ['📅 Sem data',           $cnt_semdata, $contacts_url . '&dp=semdata'],
                ['🎉 Clientes WC',        $cnt_clientes,$contacts_url . '&source=pedido'],
            ];
            foreach ($segs as [$label, $count, $url]):
            ?>
            <a class="vm2pl-card" href="<?php echo esc_url($url); ?>">
                <span class="vm2pl-left"><?php echo $label; ?></span>
                <span class="vm2pl-badge"><?php echo $count; ?></span>
            </a>
            <?php endforeach; ?>
            <div class="vm2pl-col-footer">Clique para filtrar os contatos</div>
        </div>

        <!-- seta -->
        <div class="vm2pl-arrow">→</div>

        <!-- ── COLUNA 3: AUTOMAÇÕES ── -->
        <div class="vm2pl-col">
            <h3>🤖 Automações</h3>
            <?php
            $autos = [
                ['🔥 Aquecer D+X',  $aquecer_kill === '0', 'aquecer',      $auto_url . '&tab=aquecer'],
                ['🤖 Auto-Aquecer', $aa_on === '1',        'auto_aquecer', $auto_url . '&tab=aquecer'],
                ['🎯 Leads HOT',    $hot_kill === '0',     'leads',        $auto_url . '&tab=leads'],
                ['📅 Por Data',     $bydate_kill === '0',  'bydate',       $auto_url . '&tab=bydate'],
                ['🛒 Carrinho',     !$cart_kill,           'carrinho',     $auto_url . '&tab=carrinho'],
            ];
            foreach ($autos as [$label, $is_on, $mod, $url]):
                $n_today = $get_today($mod);
            ?>
            <a class="vm2pl-card vm2pl-card-auto" href="<?php echo esc_url($url); ?>">
                <div class="vm2pl-auto-row">
                    <span class="vm2pl-left"><?php echo $label; ?></span>
                    <span class="vm2pl-status <?php echo $is_on ? 'on' : 'off'; ?>"><?php echo $is_on ? '🟢 ATIVO' : '🔴 PARADO'; ?></span>
                </div>
                <span class="vm2pl-sub"><?php echo $n_today; ?> envio(s) hoje · clique para configurar</span>
            </a>
            <?php endforeach; ?>
        </div>

    </div><!-- .vm2pl-grid -->

    <!-- LOG RECENTE -->
    <div class="vm2pl-log">
        <h3>📋 Envios Recentes — Todas as Automações</h3>
        <?php if ($log_rows): ?>
        <div style="overflow-x:auto">
        <?php foreach ($log_rows as $row):
            $ml    = $mod_labels[$row->module] ?? ['label' => esc_html($row->module), 'color' => '#6b7280'];
            $dt    = get_date_from_gmt($row->sent_at, 'd/m H:i');
        ?>
        <div class="vm2pl-log-row">
            <span class="vm2pl-log-mod">
                <span style="background:<?php echo $ml['color']; ?>;color:#fff;padding:2px 7px;border-radius:10px;font-size:10px;font-weight:700"><?php echo $ml['label']; ?></span>
            </span>
            <span class="vm2pl-log-name"><?php echo esc_html($row->name ?: '—'); ?></span>
            <span class="vm2pl-log-phone"><?php echo esc_html($row->phone); ?></span>
            <span class="vm2pl-log-time"><?php echo $dt; ?></span>
        </div>
        <?php endforeach; ?>
        </div>
        <?php else: ?>
        <p style="color:#9ca3af;font-size:13px;text-align:center;padding:20px 0">Nenhum envio registrado ainda. Os logs aparecem aqui após os primeiros disparos.</p>
        <?php endif; ?>
    </div>
    <?php
}

// ─────────────────────────────────────────────────────────────
// AJAX — Bulk action: adicionar contatos a automação
// ─────────────────────────────────────────────────────────────
add_action('wp_ajax_vm2_bulk_aquecer', function() {
    check_ajax_referer('vm2_bulk_aquecer', 'nonce');
    if (!current_user_can('manage_options')) wp_die();

    global $wpdb;
    $phones = isset($_POST['phones']) ? array_map('sanitize_text_field', (array)$_POST['phones']) : [];
    $module = sanitize_key($_POST['module'] ?? 'aquecer');
    if (!in_array($module, ['aquecer','bydate'])) $module = 'aquecer';
    if (empty($phones)) {
        wp_send_json_error(['msg' => 'Nenhum contato selecionado.']);
    }

    $sends = $wpdb->prefix . 'vm2_sends';
    $ph_in = implode(',', array_fill(0, count($phones), '%s'));

    // Remove cooldown recente para esses phones nesse módulo
    $args_del = array_merge([$module], $phones);
    $deleted  = $wpdb->query($wpdb->prepare(
        "DELETE FROM $sends WHERE module = %s AND phone IN ($ph_in) AND sent_at > DATE_SUB(NOW(), INTERVAL 30 DAY)",
        ...$args_del
    ));

    $label = $module === 'aquecer' ? 'Aquecer D+X' : 'Por Data';
    wp_send_json_success([
        'msg'     => count($phones) . ' contato(s) adicionado(s) à fila de ' . $label . '. Cooldown removido — serão incluídos no próximo disparo.',
        'deleted' => (int)$deleted,
        'module'  => $module,
    ]);
});
function vm2_sofia_kb_save_handler() {
    if ( ! current_user_can( 'manage_options' ) ) wp_die( 'Sem permissão' );
    check_ajax_referer( 'vm2_sofia_kb', 'nonce' );
    global $wpdb;
    $t        = $wpdb->prefix . 'vm2_sofia_knowledge';
    $tipo     = sanitize_text_field( $_POST['tipo'] ?? 'texto' );
    $titulo   = sanitize_text_field( $_POST['titulo'] ?? '' );
    $url      = esc_url_raw( $_POST['url'] ?? '' );
    $conteudo = sanitize_textarea_field( $_POST['conteudo'] ?? '' );
    if ( in_array( $tipo, array( 'url', 'drive' ), true ) && ! empty( $url ) ) {
        $scraped = vm2_sofia_kb_scrape_url( $url );
        if ( isset( $scraped['erro'] ) ) {
            wp_send_json_error( $scraped['erro'] );
        }
        if ( empty( $titulo ) ) $titulo = $scraped['titulo'];
        if ( empty( $conteudo ) ) $conteudo = $scraped['conteudo'];
    }
    if ( empty( $titulo ) )   wp_send_json_error( 'Título é obrigatório.' );
    if ( empty( $conteudo ) ) wp_send_json_error( 'Conteúdo não pode estar vazio.' );
    $wpdb->insert( $t, array(
        'tipo'      => $tipo,
        'titulo'    => $titulo,
        'conteudo'  => $conteudo,
        'url'       => $url ?: null,
        'ativo'     => 1,
        'criado_em' => current_time( 'mysql' ),
    ) );
    if ( $wpdb->last_error ) wp_send_json_error( 'Erro BD: ' . $wpdb->last_error );
    wp_send_json_success( array(
        'id'      => $wpdb->insert_id,
        'titulo'  => $titulo,
        'tipo'    => $tipo,
        'preview' => mb_substr( $conteudo, 0, 200 ),
        'chars'   => mb_strlen( $conteudo ),
    ) );
}

// AJAX: deletar item
add_action( 'wp_ajax_vm2_sofia_kb_delete', 'vm2_sofia_kb_delete_handler' );
function vm2_sofia_kb_delete_handler() {
    if ( ! current_user_can( 'manage_options' ) ) wp_die( 'Sem permissão' );
    check_ajax_referer( 'vm2_sofia_kb', 'nonce' );
    global $wpdb;
    $id = intval( $_POST['id'] ?? 0 );
    if ( ! $id ) wp_send_json_error( 'ID inválido' );
    $wpdb->delete( $wpdb->prefix . 'vm2_sofia_knowledge', array( 'id' => $id ) );
    wp_send_json_success();
}

// AJAX: toggle ativo/inativo
add_action( 'wp_ajax_vm2_sofia_kb_toggle', 'vm2_sofia_kb_toggle_handler' );
function vm2_sofia_kb_toggle_handler() {
    if ( ! current_user_can( 'manage_options' ) ) wp_die( 'Sem permissão' );
    check_ajax_referer( 'vm2_sofia_kb', 'nonce' );
    global $wpdb;
    $id  = intval( $_POST['id'] ?? 0 );
    if ( ! $id ) wp_send_json_error( 'ID inválido' );
    $t   = $wpdb->prefix . 'vm2_sofia_knowledge';
    $cur = (int) $wpdb->get_var( $wpdb->prepare( "SELECT ativo FROM $t WHERE id=%d", $id ) );
    $new = $cur ? 0 : 1;
    $wpdb->update( $t, array( 'ativo' => $new ), array( 'id' => $id ) );
    wp_send_json_success( array( 'ativo' => $new ) );
}

// AJAX: preview de scraping (antes de salvar)
add_action( 'wp_ajax_vm2_sofia_kb_preview', 'vm2_sofia_kb_preview_handler' );
function vm2_sofia_kb_preview_handler() {
    if ( ! current_user_can( 'manage_options' ) ) wp_die( 'Sem permissão' );
    check_ajax_referer( 'vm2_sofia_kb', 'nonce' );
    $url = esc_url_raw( $_POST['url'] ?? '' );
    if ( ! $url ) wp_send_json_error( 'URL inválida' );
    $result = vm2_sofia_kb_scrape_url( $url );
    if ( isset( $result['erro'] ) ) wp_send_json_error( $result['erro'] );
    $result['chars'] = mb_strlen( $result['conteudo'] );
    wp_send_json_success( $result );
}

// ── REST: upsert sessão ───────────────────────────────────────────────────────
function vm2_sofia_rest_upsert( WP_REST_Request $request ) {
    global $wpdb;
    $d = $request->get_json_params();
    if ( empty($d['session_id']) ) {
        return new WP_Error('bad_request', 'session_id required', ['status'=>400]);
    }
    $t   = $wpdb->prefix . 'vm2_sofia_sessions';
    $sid = sanitize_text_field($d['session_id']);
    $row = $wpdb->get_row($wpdb->prepare("SELECT id FROM $t WHERE session_id=%s", $sid));
    $data = [
        'session_id'         => $sid,
        'persistent_uid'     => isset($d['persistent_uid']) ? sanitize_text_field($d['persistent_uid']) : null,
        'product_id'         => isset($d['product_id']) ? intval($d['product_id']) : null,
        'product_name'       => isset($d['product_name']) ? sanitize_text_field($d['product_name']) : null,
        'whatsapp'           => isset($d['whatsapp']) ? sanitize_text_field($d['whatsapp']) : null,
        'wa_capture_trigger' => isset($d['wa_capture_trigger']) ? sanitize_text_field($d['wa_capture_trigger']) : null,
        'categoria'          => isset($d['categoria']) ? sanitize_text_field($d['categoria']) : null,
        'tipo_evento'        => ! empty($d['tipo_evento']) ? sanitize_text_field($d['tipo_evento']) : ( isset($d['signals']['tipo_evento']) ? sanitize_text_field($d['signals']['tipo_evento']) : null ),
        'data_evento_str'    => isset($d['data_evento_str']) ? sanitize_text_field($d['data_evento_str']) : null,
        'urgencia'           => isset($d['urgencia']) ? sanitize_text_field($d['urgencia']) : null,
        'mensagens_count'    => isset($d['mensagens_count']) ? intval($d['mensagens_count']) : 0,
        'signals'            => isset($d['signals']) ? wp_json_encode($d['signals']) : null,
        'historico'          => isset($d['historico']) ? wp_json_encode($d['historico']) : null,
        'converted'          => isset($d['converted']) ? intval($d['converted']) : 0,
        'source_url'         => isset($d['source_url']) ? esc_url_raw($d['source_url']) : null,
        'utm_source'         => isset($d['utm_source']) ? sanitize_text_field($d['utm_source']) : sanitize_text_field($request->get_param('utm_source') ?? ''),
        'utm_medium'         => isset($d['utm_medium']) ? sanitize_text_field($d['utm_medium']) : sanitize_text_field($request->get_param('utm_medium') ?? ''),
        'utm_campaign'       => isset($d['utm_campaign']) ? sanitize_text_field($d['utm_campaign']) : sanitize_text_field($request->get_param('utm_campaign') ?? ''),
        'canal_origem'       => isset($d['canal_origem']) ? sanitize_text_field($d['canal_origem']) : sanitize_text_field($request->get_param('canal_origem') ?? ''),
        'email'              => isset($d['email']) ? sanitize_email($d['email']) : null,
    ];
    // Remove email null para não sobrescrever valor existente com NULL
    if ( $data['email'] === null ) unset($data['email']);
    if ( !empty($d['whatsapp']) && !$row ) {
        $data['wa_captured_at'] = current_time('mysql');
    }
    if ( !empty($d['ended']) ) {
        $data['ended_at'] = current_time('mysql');
    }
    if ( $row ) {
        $result = $wpdb->update($t, $data, ['session_id' => $sid]);
    } else {
        $data['started_at'] = current_time('mysql');
        $result = $wpdb->insert($t, $data);
    }
    if ( $result === false && $wpdb->last_error ) {
        error_log('[vm2_sofia_session] DB error: ' . $wpdb->last_error . ' | data keys: ' . implode(',', array_keys($data)));
        return new WP_Error('db_error', 'Falha ao salvar sessão: ' . $wpdb->last_error, ['status' => 500]);
    }
    // ── Sync para vm2_contacts quando WhatsApp capturado ────────────────────
    if ( !empty($d['whatsapp']) ) {
        $raw_wa  = preg_replace('/\D/', '', sanitize_text_field($d['whatsapp']));
        // Normalizar: garantir DDI 55
        if ( strlen($raw_wa) <= 11 ) {
            $raw_wa = '55' . $raw_wa;
        }
        if ( $raw_wa ) {
            $ct = $wpdb->prefix . 'vm2_contacts';
            $existing = $wpdb->get_row($wpdb->prepare(
                "SELECT id, origens, tipo_evento FROM $ct WHERE phone = %s", $raw_wa
            ));
            if ( $existing ) {
                // Atualizar origem: adicionar 'sofia' se não existir
                $origens = json_decode($existing->origens, true) ?: [];
                if ( ! in_array('sofia', $origens) ) {
                    $origens[] = 'sofia';
                }
                $update_data = [
                    'origens'       => wp_json_encode($origens),
                    'last_activity' => current_time('mysql'),
                ];
                // Preencher tipo_evento se ainda vazio e SofIA detectou
                if ( empty($existing->tipo_evento) && !empty($d['signals']['tipo_evento']) ) {
                    $update_data['tipo_evento'] = sanitize_text_field($d['signals']['tipo_evento']);
                }
                // Preencher UTMs se vieram e contato não tem
                if ( !empty($d['utm_source']) && empty($existing->utm_source) ) {
                    $update_data['utm_source']   = sanitize_text_field($d['utm_source']);
                    $update_data['utm_medium']   = isset($d['utm_medium']) ? sanitize_text_field($d['utm_medium']) : '';
                    $update_data['utm_campaign'] = isset($d['utm_campaign']) ? sanitize_text_field($d['utm_campaign']) : '';
                }
                // v1.5.91: preencher email se capturado pela SofIA e contato não tem
                if ( !empty($d['email']) && empty($existing->email) ) {
                    $update_data['email'] = sanitize_email($d['email']);
                }
                $wpdb->update($ct, $update_data, ['id' => $existing->id]);
            } else {
                // Criar novo contato
                $origens = ['sofia'];
                $new_contact = [
                    'phone'         => $raw_wa,
                    'name'          => 'SofIA Lead',
                    'email'         => !empty($d['email']) ? sanitize_email($d['email']) : '',
                    'origens'       => wp_json_encode($origens),
                    'tipo_evento'   => isset($d['signals']['tipo_evento']) ? sanitize_text_field($d['signals']['tipo_evento']) : '',
                    'data_evento'   => isset($d['data_evento_str']) ? sanitize_text_field($d['data_evento_str']) : '',
                    'utm_source'    => isset($d['utm_source']) ? sanitize_text_field($d['utm_source']) : '',
                    'utm_medium'    => isset($d['utm_medium']) ? sanitize_text_field($d['utm_medium']) : '',
                    'utm_campaign'  => isset($d['utm_campaign']) ? sanitize_text_field($d['utm_campaign']) : '',
                    'last_activity' => current_time('mysql'),
                    'created_at'    => current_time('mysql'),
                ];
                $wpdb->insert($ct, $new_contact);
            }
        }
    }
    // ── Chamar Claude quando há mensagem do usuário ──────────────────────────
    if ( ! empty( $d['mensagem'] ) ) {
        $api_key  = get_option( 'vmbnav_claude_key', '' );
        $mensagem = sanitize_text_field( $d['mensagem'] );

        if ( $api_key ) {
            $system_prompt = get_option( 'vm2_sofia_system_prompt',
                'Você é SofIA, assessora de eventos da VivaMais Eventos — o maior marketplace de atrações para eventos ao vivo do Brasil. Ajude o cliente a contratar a atração perfeita de forma amigável, consultiva e objetiva. Entenda tipo de evento, data, orçamento e quantidade de convidados. Sugira atrações disponíveis quando pertinente. Respostas curtas (2-3 frases), tom caloroso e profissional. Nunca invente preços ou disponibilidade — diga para o cliente acessar o site para valores exatos.'
            );
            // [v1.5.93] Injetar instrução de captura de email se toggle ativo e sessão ainda não tem email
            if ( get_option('vm2_sofia_ask_email','0') === '1' && empty($d['email']) ) {
                $system_prompt .= "\n\nINSTRUÇÃO ESPECIAL: Após o cliente fornecer o WhatsApp, pergunte o e-mail usando exatamente esta frase: 'Seu e-mail? Assim a gente garante o contato mesmo se o WhatsApp travar 🔒'. Não invente e-mails. Não repita o pedido se o cliente já forneceu.";
            }

            $historico = isset( $d['historico'] ) && is_array( $d['historico'] ) ? $d['historico'] : [];

            // Montar mensagens (historico já inclui a msg atual no final)
            $messages = [];
            foreach ( $historico as $msg ) {
                if ( isset( $msg['role'], $msg['content'] ) ) {
                    $role       = $msg['role'] === 'user' ? 'user' : 'assistant';
                    $messages[] = [ 'role' => $role, 'content' => (string) $msg['content'] ];
                }
            }
            // Garantir que termina com mensagem do usuário
            if ( empty( $messages ) || $messages[ count($messages) - 1 ]['role'] !== 'user' ) {
                $messages[] = [ 'role' => 'user', 'content' => $mensagem ];
            }

            $resp = wp_remote_post( 'https://api.anthropic.com/v1/messages', [
                'timeout' => 22,
                'headers' => [
                    'x-api-key'         => $api_key,
                    'anthropic-version' => '2023-06-01',
                    'content-type'      => 'application/json',
                ],
                'body' => wp_json_encode( [
                    'model'      => 'claude-haiku-4-5-20251001',
                    'max_tokens' => 350,
                    'system'     => $system_prompt,
                    'messages'   => $messages,
                ] ),
            ] );

            if ( ! is_wp_error( $resp ) && wp_remote_retrieve_response_code( $resp ) === 200 ) {
                $body  = json_decode( wp_remote_retrieve_body( $resp ), true );
                $reply = $body['content'][0]['text'] ?? '';
                if ( $reply ) {
                    return rest_ensure_response( [ 'ok' => true, 'mensagem' => trim( $reply ) ] );
                }
            }
        }
        // Fallback se API indisponível ou chave ausente
        return rest_ensure_response( [ 'ok' => true, 'mensagem' => 'Pode me contar mais sobre seu evento? 🎪' ] );
    }

    return rest_ensure_response(['ok' => true]);
}

// ── REST: listar sessões ──────────────────────────────────────────────────────
function vm2_sofia_rest_list( WP_REST_Request $request ) {
    global $wpdb;
    $t     = $wpdb->prefix . 'vm2_sofia_sessions';
    $limit = intval($request->get_param('limit') ?: 100);
    $rows  = $wpdb->get_results("SELECT * FROM $t ORDER BY started_at DESC LIMIT $limit");
    return rest_ensure_response($rows);
}

// ── Admin Page ────────────────────────────────────────────────────────────────
function vm2_sofia_page() {
    global $wpdb;
    $t = $wpdb->prefix . 'vm2_sofia_sessions';
    $table_exists = ($wpdb->get_var("SHOW TABLES LIKE '$t'") === $t);
    if (!$table_exists) { vm2_create_sofia_table(); }

    // Stats
    $total    = $table_exists ? (int)$wpdb->get_var("SELECT COUNT(*) FROM $t") : 0;
    $wa_cap   = $table_exists ? (int)$wpdb->get_var("SELECT COUNT(*) FROM $t WHERE whatsapp IS NOT NULL AND whatsapp != ''") : 0;
    $conv     = $table_exists ? (int)$wpdb->get_var("SELECT COUNT(*) FROM $t WHERE converted=1") : 0;
    $com_data = $table_exists ? (int)$wpdb->get_var("SELECT COUNT(*) FROM $t WHERE data_evento_str IS NOT NULL AND data_evento_str != ''") : 0;
    $hoje_tot = $table_exists ? (int)$wpdb->get_var("SELECT COUNT(*) FROM $t WHERE DATE(started_at)=CURDATE()") : 0;
    $hoje_wa  = $table_exists ? (int)$wpdb->get_var("SELECT COUNT(*) FROM $t WHERE DATE(started_at)=CURDATE() AND whatsapp IS NOT NULL") : 0;
    $taxa_cap  = $total > 0 ? round($wa_cap/$total*100,1) : 0;
    $taxa_conv = $wa_cap > 0 ? round($conv/$wa_cap*100,1) : 0;

    // Categorias
    $cats_raw = $table_exists ? $wpdb->get_results("SELECT categoria, COUNT(*) as n FROM $t WHERE categoria IS NOT NULL AND categoria!='' GROUP BY categoria ORDER BY n DESC LIMIT 8") : [];
    $cats = [];
    foreach ($cats_raw as $c) { $cats[$c->categoria] = (int)$c->n; }

    // Sessões recentes
    $sessions = $table_exists ? $wpdb->get_results("SELECT * FROM $t ORDER BY started_at DESC LIMIT 50") : [];

    // Config kill switch
    $sofia_enabled = get_option('vm2_sofia_captura_enabled', '1');
    $trigger_msgs  = get_option('vm2_sofia_trigger_msgs', '1');
    $trigger_intencao = get_option('vm2_sofia_trigger_intencao', '1');
    $trigger_quero    = get_option('vm2_sofia_trigger_quero', '1');
    $keywords_raw     = get_option('vm2_sofia_keywords', 'quanto custa,quero contratar,valor,preço,disponível,disponibilidade,agendar');
    $sofia_wa_msg     = get_option('vm2_sofia_wa_msg', 'Sua data ainda está disponível! 🎉 Para garantir antes que outra pessoa reserve, me passa seu WhatsApp e confirmo em minutos 😊');
    $sofia_wa_confirm = get_option('vmbnav_sofia_wa_confirm', 'Perfeito! 🎉 Vou te enviar o portfólio completo e disponibilidade pelo WhatsApp. Pode aguardar!');

    // Save settings
    if ($_SERVER['REQUEST_METHOD']==='POST' && isset($_POST['vm2_sofia_save']) && check_admin_referer('vm2_sofia_nonce')) {
        update_option('vm2_sofia_captura_enabled', isset($_POST['sofia_enabled']) ? '1' : '0');
        update_option('vm2_sofia_trigger_msgs',    intval($_POST['trigger_msgs'] ?? 2));
        update_option('vm2_sofia_trigger_intencao',isset($_POST['trigger_intencao']) ? '1' : '0');
        update_option('vm2_sofia_trigger_quero',   isset($_POST['trigger_quero']) ? '1' : '0');
        update_option('vm2_sofia_keywords',        sanitize_textarea_field($_POST['sofia_keywords'] ?? ''));
        update_option('vm2_sofia_wa_msg',          sanitize_textarea_field($_POST['sofia_wa_msg'] ?? ''));
        update_option('vmbnav_sofia_wa_confirm',   sanitize_textarea_field($_POST['sofia_wa_confirm'] ?? ''));
        echo '<div class="notice notice-success"><p>✅ Configurações salvas!</p></div>';
        // reload values
        $sofia_enabled    = get_option('vm2_sofia_captura_enabled', '1');
        $trigger_msgs     = get_option('vm2_sofia_trigger_msgs', '1');
        $trigger_intencao = get_option('vm2_sofia_trigger_intencao', '1');
        $trigger_quero    = get_option('vm2_sofia_trigger_quero', '1');
        $keywords_raw     = get_option('vm2_sofia_keywords', '');
        $sofia_wa_msg     = get_option('vm2_sofia_wa_msg', '');
        $sofia_wa_confirm = get_option('vmbnav_sofia_wa_confirm', '');
    }

    $active_tab = isset($_GET['tab']) ? sanitize_text_field($_GET['tab']) : 'analytics';
    $base_url   = admin_url('admin.php?page=vm2-sofia');
    ?>
<div class="wrap vm2-wrap">
<style>
.vm2-sofia-header{background:linear-gradient(135deg,#1a0a2e,#2d1b69);border-radius:12px;padding:20px 24px;margin-bottom:20px;display:flex;align-items:center;gap:14px;border:1px solid #3d2b6d}
.vm2-sofia-header h1{margin:0;color:#fff;font-size:22px;font-weight:800}
.vm2-sofia-header p{margin:4px 0 0;color:#a78bfa;font-size:13px}
.vm2-sofia-badge{margin-left:auto;background:#7c3aed;color:#fff;padding:5px 14px;border-radius:20px;font-size:12px;font-weight:700}
.vm2-sofia-tabs{display:flex;gap:0;border-bottom:2px solid #e5e7eb;margin-bottom:20px;overflow-x:auto}
.vm2-sofia-tab{padding:10px 18px;text-decoration:none;font-weight:600;font-size:13px;color:#6b7280;border-bottom:3px solid transparent;white-space:nowrap;transition:all .2s}
.vm2-sofia-tab:hover{color:#7c3aed;background:#f5f3ff}
.vm2-sofia-tab.active{color:#7c3aed;border-bottom-color:#7c3aed}
.sofia-kpi-grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(140px,1fr));gap:12px;margin-bottom:20px}
.sofia-kpi{background:#fff;border:1px solid #e5e7eb;border-radius:10px;padding:16px;text-align:center;cursor:pointer;transition:all .2s}
.sofia-kpi:hover{border-color:#7c3aed;box-shadow:0 4px 12px rgba(124,58,237,.1)}
.sofia-kpi-val{font-size:28px;font-weight:800;color:#1f2937;display:block}
.sofia-kpi-lbl{font-size:11px;color:#6b7280;margin-top:4px}
.sofia-kpi-sub{font-size:10px;color:#9ca3af;margin-top:2px}
.sofia-kpi.purple .sofia-kpi-val{color:#7c3aed}
.sofia-kpi.green .sofia-kpi-val{color:#059669}
.sofia-kpi.amber .sofia-kpi-val{color:#d97706}
.sofia-table-wrap{background:#fff;border:1px solid #e5e7eb;border-radius:10px;overflow-x:auto}
.sofia-table-wrap table{width:100%;border-collapse:collapse;min-width:600px}
.sofia-table-wrap th{padding:10px 12px;font-size:12px;color:#6b7280;text-align:left;border-bottom:1px solid #f3f4f6;background:#f9fafb}
.sofia-table-wrap td{padding:10px 12px;font-size:13px;border-bottom:1px solid #f9fafb;vertical-align:middle}
.sofia-table-wrap tr:last-child td{border-bottom:none}
.sofia-table-wrap tr:hover td{background:#faf5ff}
.sofia-badge{padding:3px 9px;border-radius:20px;font-size:11px;font-weight:600}
.sofia-badge-infantil{background:#dbeafe;color:#1d4ed8}
.sofia-badge-casamento{background:#ede9fe;color:#6d28d9}
.sofia-badge-15anos{background:#fce7f3;color:#9d174d}
.sofia-badge-adulto{background:#f3f4f6;color:#374151}
.sofia-badge-corporativo{background:#d1fae5;color:#065f46}
.sofia-badge-formatura{background:#fed7aa;color:#92400e}
.sofia-badge-alta{background:#fee2e2;color:#991b1b}
.sofia-badge-media{background:#fef3c7;color:#92400e}
.sofia-badge-baixa{background:#f3f4f6;color:#6b7280}
.sofia-badge-capturado{background:#d1fae5;color:#065f46}
.sofia-badge-nao{background:#f3f4f6;color:#6b7280}
.sofia-bar-row{display:flex;align-items:center;gap:10px;margin-bottom:10px}
.sofia-bar-label{width:100px;font-size:12px;color:#374151;flex-shrink:0}
.sofia-bar-track{flex:1;height:24px;background:#f3f4f6;border-radius:6px;overflow:hidden}
.sofia-bar-fill{height:100%;border-radius:6px;display:flex;align-items:center;padding-left:8px;font-size:11px;font-weight:700;color:#fff}
.sofia-bar-count{width:40px;font-size:12px;text-align:right;color:#6b7280}
.sofia-funnel-step{display:flex;align-items:center;gap:12px;margin-bottom:10px}
.sofia-funnel-bar{flex:1;height:38px;border-radius:8px;display:flex;align-items:center;padding:0 14px;font-size:13px;font-weight:600;color:#fff}
.sofia-funnel-num{width:55px;font-size:20px;font-weight:800;text-align:right;color:#1f2937}
.sofia-funnel-pct{width:45px;font-size:11px;color:#6b7280}
.sofia-section{background:#fff;border:1px solid #e5e7eb;border-radius:10px;padding:20px;margin-bottom:16px}
.sofia-section h3{font-size:15px;font-weight:700;margin:0 0 14px;color:#1f2937}
.sofia-trigger-row{display:flex;align-items:center;gap:12px;padding:12px 0;border-bottom:1px solid #f3f4f6}
.sofia-trigger-row:last-child{border-bottom:none}
.sofia-trigger-label{flex:1;font-size:13px;font-weight:600;color:#374151}
.sofia-trigger-desc{font-size:11px;color:#6b7280;margin-top:2px}
.sofia-toggle{position:relative;display:inline-block;width:42px;height:24px;flex-shrink:0}
.sofia-toggle input{opacity:0;width:0;height:0}
.sofia-toggle-slider{position:absolute;cursor:pointer;inset:0;background:#d1d5db;border-radius:24px;transition:.3s}
.sofia-toggle-slider::before{content:'';position:absolute;height:18px;width:18px;left:3px;bottom:3px;background:#fff;border-radius:50%;transition:.3s}
.sofia-toggle input:checked+.sofia-toggle-slider{background:#7c3aed}
.sofia-toggle input:checked+.sofia-toggle-slider::before{transform:translateX(18px)}
.sofia-rule-row{background:#f9fafb;border:1px solid #e5e7eb;border-radius:8px;padding:14px;margin-bottom:10px}
.sofia-rule-title{font-size:13px;font-weight:700;color:#374151;margin-bottom:6px}
.sofia-rule-body{font-size:12px;color:#6b7280}
.sofia-rule-badge{display:inline-block;background:#ede9fe;color:#6d28d9;font-size:10px;font-weight:700;padding:2px 8px;border-radius:12px;margin-right:4px}
.sofia-plan-phase{border-left:3px solid #7c3aed;padding:12px 16px;margin-bottom:12px;background:#faf5ff;border-radius:0 8px 8px 0}
.sofia-plan-phase h4{font-size:13px;font-weight:700;margin:0 0 6px;color:#6d28d9}
.sofia-plan-phase p{font-size:12px;color:#4b5563;margin:0}
.sofia-plan-done{border-left-color:#059669;background:#f0fdf4}
.sofia-plan-done h4{color:#065f46}
.sofia-plan-doing{border-left-color:#d97706;background:#fffbeb}
.sofia-plan-doing h4{color:#92400e}
@media(max-width:600px){.sofia-kpi-grid{grid-template-columns:1fr 1fr}.sofia-kpi-val{font-size:22px}}
</style>

<div class="vm2-sofia-header">
  <span style="font-size:32px">🧠</span>
  <div>
    <h1>SofIA Intelligence</h1>
    <p>Captura sinais das conversas para vender mais automaticamente</p>
  </div>
  <span class="vm2-sofia-badge">⚡ v1.0</span>
</div>

<div class="vm2-sofia-tabs">
  <a href="<?php echo esc_url($base_url.'&tab=analytics'); ?>" class="vm2-sofia-tab <?php echo $active_tab==='analytics'?'active':''; ?>">📊 Analytics</a>
  <a href="<?php echo esc_url($base_url.'&tab=captura'); ?>" class="vm2-sofia-tab <?php echo $active_tab==='captura'?'active':''; ?>">📲 Captura WA</a>
  <a href="<?php echo esc_url($base_url.'&tab=automacoes'); ?>" class="vm2-sofia-tab <?php echo $active_tab==='automacoes'?'active':''; ?>">🤖 Automações</a>
  <a href="<?php echo esc_url($base_url.'&tab=plano'); ?>" class="vm2-sofia-tab <?php echo $active_tab==='plano'?'active':''; ?>">🏗️ Plano</a>
  <a href="<?php echo esc_url($base_url.'&tab=conhecimento'); ?>" class="vm2-sofia-tab <?php echo $active_tab==='conhecimento'?'active':''; ?>">📚 Base de Conhecimento</a>
  <a href="<?php echo esc_url($base_url.'&tab=prompt'); ?>" class="vm2-sofia-tab <?php echo $active_tab==='prompt'?'active':''; ?>">⚙️ Prompt</a>
  <a href="<?php echo esc_url($base_url.'&tab=setup'); ?>" class="vm2-sofia-tab <?php echo $active_tab==='setup'?'active':''; ?>">🔧 Setup</a>
</div>

<?php if ($active_tab === 'analytics'): ?>
<!-- ═══ ANALYTICS v2 ══════════════════════════════════════════════════════════ -->
<?php
// ── Período ────────────────────────────────────────────────────────────────
$period  = isset($_GET['period']) ? sanitize_text_field($_GET['period']) : '30d';
$ana_url = admin_url('admin.php?page=vm2-sofia&tab=analytics');
// Calcular limites em UTC com base no horário de Brasília (started_at é salvo em UTC)
$tz_sp  = new DateTimeZone('America/Sao_Paulo');
$tz_utc = new DateTimeZone('UTC');
$now_sp = new DateTime('now', $tz_sp);
$where_p = '';
switch ($period) {
    case 'today':
        $d0 = new DateTime($now_sp->format('Y-m-d') . ' 00:00:00', $tz_sp); $d0->setTimezone($tz_utc);
        $d1 = new DateTime($now_sp->format('Y-m-d') . ' 23:59:59', $tz_sp); $d1->setTimezone($tz_utc);
        $where_p = "AND started_at >= '{$d0->format('Y-m-d H:i:s')}' AND started_at <= '{$d1->format('Y-m-d H:i:s')}'";
        break;
    case '7d':
        $d0 = new DateTime('now', $tz_sp); $d0->modify('-7 days'); $d0->setTimezone($tz_utc);
        $where_p = "AND started_at >= '{$d0->format('Y-m-d H:i:s')}'";
        break;
    case '30d':
        $d0 = new DateTime('now', $tz_sp); $d0->modify('-30 days'); $d0->setTimezone($tz_utc);
        $where_p = "AND started_at >= '{$d0->format('Y-m-d H:i:s')}'";
        break;
    case 'month':
        $d0 = new DateTime($now_sp->format('Y-m') . '-01 00:00:00', $tz_sp); $d0->setTimezone($tz_utc);
        $where_p = "AND started_at >= '{$d0->format('Y-m-d H:i:s')}'";
        break;
    default: $where_p = '';
}

// ── Stats período ──────────────────────────────────────────────────────────
$p_total    = $table_exists ? (int)$wpdb->get_var("SELECT COUNT(*) FROM $t WHERE 1=1 $where_p") : 0;
$p_engaj    = $table_exists ? (int)$wpdb->get_var("SELECT COUNT(*) FROM $t WHERE mensagens_count >= 3 $where_p") : 0;
$p_wa       = $table_exists ? (int)$wpdb->get_var("SELECT COUNT(*) FROM $t WHERE whatsapp IS NOT NULL AND whatsapp != '' $where_p") : 0;
$p_data_ev  = $table_exists ? (int)$wpdb->get_var("SELECT COUNT(*) FROM $t WHERE data_evento_str IS NOT NULL AND data_evento_str != '' $where_p") : 0;
$p_msgs_sum = $table_exists ? (int)$wpdb->get_var("SELECT COALESCE(SUM(mensagens_count),0) FROM $t WHERE 1=1 $where_p") : 0;
$p_early    = $table_exists ? (int)$wpdb->get_var("SELECT COUNT(*) FROM $t WHERE mensagens_count <= 2 $where_p") : 0;
$taxa_abandono = $p_total > 0 ? round($p_early / $p_total * 100) : 0;

// ── Receita atribuída (HPOS) — apenas pedidos criados APÓS a sessão SofIA ──
// Mapa: phone_normalizado => started_at_utc (sessão mais antiga no período)
$phone_session_map = [];
if ($table_exists && $p_wa > 0) {
    $rows_ph = $wpdb->get_results("SELECT whatsapp, started_at FROM $t WHERE whatsapp IS NOT NULL AND whatsapp != '' $where_p ORDER BY started_at ASC");
    foreach ($rows_ph as $row) {
        $c = preg_replace('/[^0-9]/', '', $row->whatsapp ?? '');
        if (strlen($c) >= 10 && !isset($phone_session_map[$c])) {
            $phone_session_map[$c] = $row->started_at; // primeira sessão no período
        }
    }
}
$sofia_phones  = array_keys($phone_session_map);
$receita_sofia = 0.0;
$pedidos_sofia = 0;
$ticket_medio  = 0.0;
$wco = $wpdb->prefix . 'wc_orders';
$wca = $wpdb->prefix . 'wc_order_addresses';
if (!empty($phone_session_map) && $wpdb->get_var("SHOW TABLES LIKE '$wco'") === $wco) {
    // Busca apenas pedidos wc-processing, com data e telefone
    $all_ords = $wpdb->get_results(
        "SELECT o.id, o.total_amount, o.date_created_gmt, a.phone FROM $wco o
         INNER JOIN $wca a ON a.order_id = o.id AND a.address_type = 'billing'
         WHERE o.status = 'wc-processing'"
    );
    $seen_ids = [];
    foreach ($all_ords as $ord) {
        if (in_array($ord->id, $seen_ids)) continue;
        $cp = preg_replace('/[^0-9]/', '', $ord->phone ?? '');
        if ($cp && isset($phone_session_map[$cp])) {
            // Pedido deve ter sido criado DEPOIS do início da sessão SofIA
            if ($ord->date_created_gmt >= $phone_session_map[$cp]) {
                $receita_sofia += floatval($ord->total_amount);
                $pedidos_sofia++;
                $seen_ids[] = $ord->id;
            }
        }
    }
    $ticket_medio = $pedidos_sofia > 0 ? round($receita_sofia / $pedidos_sofia, 2) : 0;
}

// ── Cupons SofIA ─────────────────────────────────────────────────────────────
$date_where_cupom = '';
if (!empty($where_p)) {
    // reutiliza o mesmo intervalo do período, mas sobre post_date (BRT)
    if ($period === 'today') {
        $date_where_cupom = "AND DATE(post_date) = '{$now_sp->format('Y-m-d')}'";
    } elseif ($period === '7d') {
        $date_where_cupom = "AND post_date >= DATE_SUB(NOW(), INTERVAL 7 DAY)";
    } elseif ($period === '30d') {
        $date_where_cupom = "AND post_date >= DATE_SUB(NOW(), INTERVAL 30 DAY)";
    } elseif ($period === 'month') {
        $date_where_cupom = "AND DATE_FORMAT(post_date,'%Y-%m') = '{$now_sp->format('Y-m')}'";
    }
}
$p_cupons = (int)$wpdb->get_var(
    "SELECT COUNT(*) FROM {$wpdb->posts}
     WHERE post_type='shop_coupon' AND post_status='publish'
     AND post_title LIKE 'SOFIA-%' $date_where_cupom"
);
$p_cupons_used = (int)$wpdb->get_var(
    "SELECT COUNT(*) FROM {$wpdb->posts} p
     INNER JOIN {$wpdb->postmeta} pm ON pm.post_id = p.ID AND pm.meta_key = 'usage_count'
     WHERE p.post_type='shop_coupon' AND p.post_status='publish'
     AND p.post_title LIKE 'SOFIA-%' AND CAST(pm.meta_value AS UNSIGNED) > 0
     $date_where_cupom"
);
$taxa_cupom_conv = $p_cupons > 0 ? round($p_cupons_used / $p_cupons * 100) : 0;

// ── Custo IA e ROAS ─────────────────────────────────────────────────────────
// Custo estimado: Claude Haiku ~$0.0013/msg (sem tracking de tokens reais)
$custo_usd = round($p_msgs_sum * 0.0013, 2);
$custo_brl = round($custo_usd * 5.70, 2);
$roas      = $custo_brl > 0 ? round($receita_sofia / $custo_brl, 1) : 0;

// ── Taxas ───────────────────────────────────────────────────────────────────
$taxa_cap_p  = $p_total > 0 ? round($p_wa / $p_total * 100, 1) : 0;
$taxa_eng_p  = $p_total > 0 ? round($p_engaj / $p_total * 100, 1) : 0;
$taxa_conv_p = $p_wa > 0 ? round($pedidos_sofia / $p_wa * 100, 1) : 0;

// ── Tendência 7 dias ─────────────────────────────────────────────────────────
$trend7 = $table_exists ? $wpdb->get_results(
    "SELECT DATE(CONVERT_TZ(started_at, '+00:00', '-03:00')) as dia, COUNT(*) as n FROM $t
     WHERE started_at >= DATE_SUB(UTC_TIMESTAMP(), INTERVAL 7 DAY)
     GROUP BY DATE(CONVERT_TZ(started_at, '+00:00', '-03:00')) ORDER BY dia"
) : [];
$trend7_map = [];
foreach ($trend7 as $r) $trend7_map[$r->dia] = (int)$r->n;
$trend7_max = $trend7_map ? max(array_values($trend7_map)) : 1;

// ── Horários de pico ─────────────────────────────────────────────────────────
$peak = $table_exists ? $wpdb->get_results(
    "SELECT HOUR(CONVERT_TZ(started_at, '+00:00', '-03:00')) as hora, COUNT(*) as n FROM $t GROUP BY HOUR(CONVERT_TZ(started_at, '+00:00', '-03:00')) ORDER BY hora"
) : [];
$peak_map = [];
foreach ($peak as $r) $peak_map[(int)$r->hora] = (int)$r->n;
$peak_max = $peak_map ? max(array_values($peak_map)) : 1;

// ── Categorias ───────────────────────────────────────────────────────────────
$cat_colors_an = ['infantil'=>'#3b82f6','casamento'=>'#8b5cf6','15 anos'=>'#ec4899','adulto'=>'#6b7280','corporativo'=>'#10b981','formatura'=>'#f59e0b'];
$cats_p = $table_exists ? $wpdb->get_results(
    "SELECT categoria, COUNT(*) as n FROM $t WHERE categoria IS NOT NULL AND categoria != '' $where_p GROUP BY categoria ORDER BY n DESC LIMIT 8"
) : [];
$cats_arr = [];
foreach ($cats_p as $c) $cats_arr[$c->categoria] = (int)$c->n;
$cats_max = $cats_arr ? max(array_values($cats_arr)) : 1;

// ── Sessões para tabela ──────────────────────────────────────────────────────
$sessions_p = $table_exists ? $wpdb->get_results(
    "SELECT * FROM $t WHERE 1=1 $where_p ORDER BY started_at DESC LIMIT 100"
) : [];

// ── Insights automáticos ─────────────────────────────────────────────────────
$insights = [];
if ($taxa_cap_p < 20 && $p_total > 10)
    $insights[] = ['warn','🔴','Taxa de captura baixa ('.$taxa_cap_p.'%)',
        'Meta e 30%+. Revisar o gatilho de captura de WhatsApp — pode estar aparecendo tarde demais na conversa.'];
if ($taxa_eng_p < 40 && $p_total > 10)
    $insights[] = ['warn','🟡','Muitos abandonos precoces ('.(100-$taxa_eng_p).'%)',
        'Mais da metade dos visitantes enviou menos de 3 mensagens. Considere uma saudacao mais acolhedora ou chips mais claros.'];
if (!empty($peak_map)) {
    $peak_sorted = $peak_map; arsort($peak_sorted); $top_hora = key($peak_sorted);
    $insights[] = ['info','⏰','Pico de atendimento: '.sprintf('%02d:00-%02d:00',$top_hora,$top_hora+1),
        'Concentre campanhas e follow-ups perto desse horario para maximizar resposta.'];
}
if (!empty($cats_arr)) {
    $top_cat = array_key_first($cats_arr);
    $insights[] = ['info','🎯','Categoria mais popular: '.ucfirst($top_cat),
        'Garanta que o portfolio de '.ucfirst($top_cat).' esta completo, com fotos e precos atualizados.'];
}
if ($roas > 0)
    $insights[] = ['ok','💚','ROAS de '.$roas.'x — cada R$1 em IA gera R$'.$roas.' em receita',
        'Excelente retorno. Considere ampliar o alcance da SofIA com trafego pago.'];
if (empty($insights))
    $insights[] = ['info','📊','Aguardando mais dados para gerar insights',
        'Os insights aparecem automaticamente conforme as sessoes aumentam.'];
?>

<!-- Seletor de período -->
<div style="display:flex;gap:8px;margin-bottom:18px;flex-wrap:wrap;align-items:center">
  <span style="font-size:12px;color:#6b7280;font-weight:600">Período:</span>
  <?php foreach (['today'=>'Hoje','7d'=>'7 dias','30d'=>'30 dias','month'=>'Este mês','all'=>'Tudo'] as $k=>$lbl): ?>
  <a href="<?php echo esc_url($ana_url.'&period='.$k); ?>"
     style="padding:5px 14px;border-radius:20px;font-size:12px;font-weight:600;text-decoration:none;
            <?php echo $period===$k ? 'background:#7c3aed;color:#fff' : 'background:#f3f4f6;color:#374151'; ?>">
    <?php echo esc_html($lbl); ?>
  </a>
  <?php endforeach; ?>
</div>

<!-- KPIs Linha 1 -->
<div style="display:grid;grid-template-columns:repeat(auto-fit,minmax(130px,1fr));gap:10px;margin-bottom:12px">
  <div class="sofia-kpi" style="border-top:3px solid #7c3aed">
    <span class="sofia-kpi-val"><?php echo number_format($p_total); ?></span>
    <div class="sofia-kpi-lbl">💬 Sessões</div>
    <div class="sofia-kpi-sub"><?php echo $p_engaj; ?> engajaram (3+ msgs)</div>
  </div>
  <div class="sofia-kpi" style="border-top:3px solid #3b82f6">
    <span class="sofia-kpi-val purple"><?php echo number_format($p_wa); ?></span>
    <div class="sofia-kpi-lbl">📲 WA capturados</div>
    <div class="sofia-kpi-sub"><?php echo $taxa_cap_p; ?>% das sessões</div>
  </div>
  <div class="sofia-kpi" style="border-top:3px solid #f59e0b">
    <span class="sofia-kpi-val" style="color:<?php echo $p_data_ev>0?'#d97706':'#9ca3af'; ?>"><?php echo number_format($p_data_ev); ?></span>
    <div class="sofia-kpi-lbl">📅 Com data evento</div>
    <div class="sofia-kpi-sub">Leads quentes</div>
  </div>
  <div class="sofia-kpi" style="border-top:3px solid #10b981">
    <span class="sofia-kpi-val green"><?php echo number_format($pedidos_sofia); ?></span>
    <div class="sofia-kpi-lbl">🛒 Pedidos atrib.</div>
    <div class="sofia-kpi-sub"><?php echo $taxa_conv_p; ?>% dos capturados</div>
  </div>
  <div class="sofia-kpi" style="border-top:3px solid #059669">
    <span class="sofia-kpi-val green">R$<?php echo number_format($receita_sofia,0,',','.'); ?></span>
    <div class="sofia-kpi-lbl">💰 Receita atrib.</div>
    <div class="sofia-kpi-sub">Pedidos wc-processing pós-chat</div>
  </div>
  <div class="sofia-kpi" style="border-top:3px solid <?php echo $roas>=5?'#059669':($roas>=2?'#d97706':'#6b7280'); ?>">
    <span class="sofia-kpi-val" style="color:<?php echo $roas>=5?'#059669':($roas>=2?'#d97706':'#6b7280'); ?>"><?php echo $roas>0?$roas.'x':'—'; ?></span>
    <div class="sofia-kpi-lbl">📈 ROAS <span style="font-size:9px;color:#9ca3af;font-weight:400">(est.)</span></div>
    <div class="sofia-kpi-sub">Custo IA est.: R$<?php echo number_format($custo_brl,2,',','.'); ?></div>
  </div>
  <div class="sofia-kpi" style="border-top:3px solid #8b5cf6">
    <span class="sofia-kpi-val" style="color:#8b5cf6">R$<?php echo $ticket_medio>0?number_format($ticket_medio,0,',','.'):'—'; ?></span>
    <div class="sofia-kpi-lbl">🎟️ Ticket Médio</div>
    <div class="sofia-kpi-sub">Por pedido atrib.</div>
  </div>
  <?php
  $abandon_color = $taxa_abandono > 60 ? '#ef4444' : ($taxa_abandono > 40 ? '#d97706' : '#059669');
  $abandon_icon  = $taxa_abandono > 60 ? '⚠️' : ($taxa_abandono > 40 ? '🟡' : '✅');
  ?>
  <div class="sofia-kpi" style="border-top:3px solid <?php echo $abandon_color ?>">
    <span class="sofia-kpi-val" style="color:<?php echo $abandon_color ?>"><?php echo $taxa_abandono ?>%</span>
    <div class="sofia-kpi-lbl">🚪 Abandono Precoce</div>
    <div class="sofia-kpi-sub"><?php echo $p_early ?> sessões (≤2 msgs) <?php echo $abandon_icon ?></div>
  </div>
  <?php
  $cupom_color = $p_cupons_used > 0 ? '#f59e0b' : '#9ca3af';
  $cupom_sub   = $p_cupons > 0
      ? $p_cupons_used . ' usados (' . $taxa_cupom_conv . '%)'
      : 'Nenhum gerado';
  ?>
  <div class="sofia-kpi" style="border-top:3px solid <?php echo $cupom_color ?>"
       onclick="location.href='<?php echo admin_url('edit.php?post_type=shop_coupon&s=SOFIA-'); ?>'"
       title="Ver cupons no WooCommerce">
    <span class="sofia-kpi-val" style="color:<?php echo $cupom_color ?>"><?php echo number_format($p_cupons); ?></span>
    <div class="sofia-kpi-lbl">🏷️ Cupons gerados</div>
    <div class="sofia-kpi-sub"><?php echo esc_html($cupom_sub); ?></div>
  </div>
</div>

<!-- Funil + Categorias -->
<div style="display:grid;grid-template-columns:1fr 1fr;gap:16px;margin-bottom:16px">
  <div class="sofia-section">
    <h3>🔽 Funil Completo</h3>
    <?php
    $funnel_steps = [
        ['💬 Iniciaram chat',  $p_total,   100,         '#7c3aed'],
        ['📩 Engajaram (3+)',  $p_engaj,   $p_total>0?round($p_engaj/$p_total*100,1):0,   '#6d28d9'],
        ['📅 Informaram data', $p_data_ev, $p_total>0?round($p_data_ev/$p_total*100,1):0, '#5b21b6'],
        ['📲 WA capturado',    $p_wa,      $p_total>0?round($p_wa/$p_total*100,1):0,      '#3b82f6'],
        ['🛒 Gerou pedido',    $pedidos_sofia, $p_total>0?round($pedidos_sofia/$p_total*100,1):0,'#10b981'],
    ];
    foreach ($funnel_steps as $fi => $f):
        $bw = max(8, (int)$f[2]);
    ?>
    <div style="display:flex;align-items:center;gap:10px;margin-bottom:<?php echo $fi<4?'10':'0'; ?>px">
      <div style="flex:1;height:34px;background:#f3f4f6;border-radius:7px;overflow:hidden">
        <div style="width:<?php echo $bw; ?>%;height:100%;background:<?php echo $f[3]; ?>;border-radius:7px;display:flex;align-items:center;padding-left:10px;font-size:12px;font-weight:600;color:#fff;white-space:nowrap;overflow:hidden"><?php echo $f[0]; ?></div>
      </div>
      <div style="min-width:42px;font-size:18px;font-weight:800;color:#1f2937;text-align:right"><?php echo number_format($f[1]); ?></div>
      <div style="width:40px;font-size:11px;color:#6b7280"><?php echo $f[2]; ?>%</div>
    </div>
    <?php endforeach; ?>
  </div>

  <div class="sofia-section">
    <h3>📊 Sessões por Categoria</h3>
    <?php if (empty($cats_arr)): ?>
    <p style="color:#9ca3af;font-size:13px">Sem dados no período.</p>
    <?php else: foreach ($cats_arr as $cat => $n):
        $pct_c = round($n / $cats_max * 100);
        $col_c = $cat_colors_an[$cat] ?? '#7c3aed';
    ?>
    <div class="sofia-bar-row">
      <div class="sofia-bar-label"><?php echo esc_html(ucfirst($cat)); ?></div>
      <div class="sofia-bar-track"><div class="sofia-bar-fill" style="width:<?php echo $pct_c; ?>%;background:<?php echo $col_c; ?>"><?php echo $n; ?></div></div>
      <div class="sofia-bar-count"><?php echo $n; ?></div>
    </div>
    <?php endforeach; endif; ?>
  </div>
</div>

<!-- Tendência 7d + Horários de pico -->
<div style="display:grid;grid-template-columns:1fr 1fr;gap:16px;margin-bottom:16px">
  <div class="sofia-section">
    <h3>📅 Tendência — últimos 7 dias</h3>
    <div style="display:flex;align-items:flex-end;gap:4px;height:80px">
    <?php for ($ddd = 6; $ddd >= 0; $ddd--):
        $dia_key = date('Y-m-d', strtotime("-{$ddd} days"));
        $n_d     = $trend7_map[$dia_key] ?? 0;
        $h_pct   = $trend7_max > 0 ? max(4, round($n_d / $trend7_max * 100)) : 4;
        $day_lbl = date('d/m', strtotime("-{$ddd} days"));
    ?>
    <div style="flex:1;display:flex;flex-direction:column;align-items:center;gap:3px">
      <div style="font-size:10px;color:#374151;font-weight:700"><?php echo $n_d ?: ''; ?></div>
      <div style="width:100%;height:<?php echo $h_pct; ?>%;background:<?php echo $n_d>0?'#7c3aed':'#e5e7eb'; ?>;border-radius:4px 4px 0 0;min-height:4px"></div>
      <div style="font-size:10px;color:#9ca3af"><?php echo $day_lbl; ?></div>
    </div>
    <?php endfor; ?>
    </div>
  </div>

  <div class="sofia-section">
    <h3>⏰ Horários de Pico</h3>
    <div style="display:flex;align-items:flex-end;gap:2px;height:80px">
    <?php
    $peak_top_val = $peak_map ? max(array_values($peak_map)) : 0;
    for ($hhh = 0; $hhh < 24; $hhh++):
        $n_h   = $peak_map[$hhh] ?? 0;
        $h_pct = $peak_max > 0 ? max(4, round($n_h / $peak_max * 100)) : 4;
        $is_top = ($n_h > 0 && $n_h === $peak_top_val);
        $color_h = $is_top ? '#f59e0b' : ($n_h > 0 ? '#8b5cf6' : '#e5e7eb');
    ?>
    <div style="flex:1;display:flex;flex-direction:column;align-items:center" title="<?php echo sprintf('%02d:00 — %d sess.',$hhh,$n_h); ?>">
      <div style="width:100%;height:<?php echo $h_pct; ?>%;background:<?php echo $color_h; ?>;border-radius:2px 2px 0 0;min-height:4px"></div>
      <?php if ($hhh % 6 === 0): ?><div style="font-size:8px;color:#9ca3af"><?php echo sprintf('%02dh',$hhh); ?></div><?php else: ?><div style="font-size:8px;color:transparent">.</div><?php endif; ?>
    </div>
    <?php endfor; ?>
    </div>
  </div>
</div>

<!-- Insights automáticos -->
<div style="margin-bottom:16px">
  <h3 style="font-size:15px;font-weight:700;margin:0 0 12px">💡 Insights Automáticos</h3>
  <div style="display:grid;grid-template-columns:repeat(auto-fit,minmax(220px,1fr));gap:10px">
  <?php foreach ($insights as $ins):
    $bg_i = $ins[0]==='ok' ? '#f0fdf4' : ($ins[0]==='warn' ? '#fff7ed' : '#f5f3ff');
    $bc_i = $ins[0]==='ok' ? '#bbf7d0' : ($ins[0]==='warn' ? '#fed7aa' : '#ddd6fe');
  ?>
  <div style="background:<?php echo $bg_i; ?>;border:1px solid <?php echo $bc_i; ?>;border-radius:10px;padding:14px">
    <div style="font-size:18px;margin-bottom:4px"><?php echo $ins[1]; ?></div>
    <div style="font-size:13px;font-weight:700;color:#1f2937;margin-bottom:4px"><?php echo esc_html($ins[2]); ?></div>
    <div style="font-size:12px;color:#4b5563"><?php echo esc_html($ins[3]); ?></div>
  </div>
  <?php endforeach; ?>
  </div>
</div>

<!-- Tabela de sessões -->
<div style="display:flex;align-items:center;justify-content:space-between;margin-bottom:10px;flex-wrap:wrap;gap:8px">
  <h3 style="margin:0;font-size:15px;font-weight:700">🗂️ Sessões — <?php echo number_format($p_total); ?> registros</h3>
  <input type="text" id="sofia-tbl-filter" placeholder="Filtrar por WA, categoria..."
    style="border:1px solid #d1d5db;border-radius:7px;padding:6px 12px;font-size:13px;width:260px;max-width:100%"
    oninput="vm2SofiaFilter(this.value)">
</div>
<div class="sofia-table-wrap">
  <table id="sofia-sessions-tbl">
    <thead>
      <tr>
        <th>Data/Hora</th><th>Atração</th><th>Categoria</th><th>Tipo Evento</th><th>Data Evento</th><th>Urgência</th><th>📲 WhatsApp</th><th>Msgs</th><th>Status</th>
      </tr>
    </thead>
    <tbody>
    <?php if (empty($sessions_p)): ?>
      <tr><td colspan="9" style="text-align:center;padding:30px;color:#9ca3af">
        <div style="font-size:32px;margin-bottom:8px">🧠</div>
        Nenhuma sessão no período selecionado.<br>
        <small>Troque o filtro de período acima ou aguarde novas conversas.</small>
      </td></tr>
    <?php else:
      foreach ($sessions_p as $s):
        $cat_slug_s = strtolower(str_replace(' ','-',$s->categoria ?: 'adulto'));
        $urg_slug_s = strtolower($s->urgencia ?: 'baixa');
        $wa_ok_s    = !empty($s->whatsapp);
        $wa_clean_s = preg_replace('/[^0-9]/', '', $s->whatsapp ?? '');
        if ($wa_clean_s && $pedidos_sofia > 0 && in_array($wa_clean_s, $sofia_phones)) {
            $slbl = '🛒 Pedido'; $scol = '#059669'; $sbg = '#d1fae5';
        } elseif ($wa_ok_s) {
            $slbl = '📲 Capturado'; $scol = '#1d4ed8'; $sbg = '#dbeafe';
        } elseif (intval($s->mensagens_count) >= 3) {
            $slbl = '💬 Engajado'; $scol = '#6d28d9'; $sbg = '#ede9fe';
        } else {
            $slbl = '👻 Abandono'; $scol = '#9ca3af'; $sbg = '#f3f4f6';
        }
        $search_str = strtolower(($s->product_name??'').' '.($s->whatsapp??'').' '.($s->categoria??'').' '.($s->tipo_evento??''));
    ?>
      <tr class="sofia-tbl-row" data-search="<?php echo esc_attr($search_str); ?>">
        <td style="white-space:nowrap;font-size:12px"><?php echo esc_html(get_date_from_gmt($s->started_at, 'd/m H:i')); ?></td>
        <td style="max-width:140px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;font-size:12px" title="<?php echo esc_attr($s->product_name ?? ''); ?>"><?php echo esc_html($s->product_name ?: '—'); ?></td>
        <td><?php if ($s->categoria): ?><span class="sofia-badge sofia-badge-<?php echo esc_attr($cat_slug_s); ?>"><?php echo esc_html(ucfirst($s->categoria)); ?></span><?php else: ?>—<?php endif; ?></td>
        <td style="font-size:12px"><?php echo esc_html($s->tipo_evento ?: '—'); ?></td>
        <td style="font-size:12px;white-space:nowrap"><?php echo esc_html($s->data_evento_str ?: '—'); ?></td>
        <td><?php if ($s->urgencia): ?><span class="sofia-badge sofia-badge-<?php echo esc_attr($urg_slug_s); ?>"><?php echo esc_html(ucfirst($s->urgencia)); ?></span><?php else: ?>—<?php endif; ?></td>
        <td style="font-size:12px"><?php if ($wa_ok_s): ?><a href="https://wa.me/<?php echo esc_attr($wa_clean_s); ?>" target="_blank" style="color:#059669;font-weight:600;text-decoration:none">📲 <?php echo esc_html($s->whatsapp); ?></a><?php else: ?>—<?php endif; ?></td>
        <td style="text-align:center;font-weight:700"><?php echo intval($s->mensagens_count); ?></td>
        <td><span style="background:<?php echo $sbg; ?>;color:<?php echo $scol; ?>;padding:3px 9px;border-radius:20px;font-size:11px;font-weight:700;white-space:nowrap"><?php echo $slbl; ?></span></td>
      </tr>
    <?php endforeach; endif; ?>
    </tbody>
  </table>
</div>
<script>
function vm2SofiaFilter(v) {
    var q = v.toLowerCase().trim();
    document.querySelectorAll('#sofia-sessions-tbl .sofia-tbl-row').forEach(function(tr) {
        tr.style.display = (!q || tr.dataset.search.indexOf(q) > -1) ? '' : 'none';
    });
}
</script>

<?php elseif ($active_tab === 'captura'): ?>
<!-- ═══ CAPTURA WA ═══════════════════════════════════════════════════════════ -->
<form method="post">
<?php wp_nonce_field('vm2_sofia_nonce'); ?>
<input type="hidden" name="vm2_sofia_save" value="1">

<div class="sofia-section">
  <h3>⚙️ Configurações de Captura</h3>
  <div class="sofia-trigger-row">
    <div class="sofia-trigger-label">
      🧠 Captura de WA Ativa
      <div class="sofia-trigger-desc">Liga/desliga todo o sistema de captura de WhatsApp no chat SofIA</div>
    </div>
    <label class="sofia-toggle">
      <input type="checkbox" name="sofia_enabled" value="1" <?php checked($sofia_enabled,'1'); ?>>
      <span class="sofia-toggle-slider"></span>
    </label>
  </div>
</div>

<div class="sofia-section">
  <h3>🎯 Gatilhos de Captura</h3>

  <div class="sofia-trigger-row">
    <div class="sofia-trigger-label">
      ⏱️ Após N mensagens
      <div class="sofia-trigger-desc">Soft ask natural após o usuário enviar N mensagens no chat</div>
    </div>
    <input type="number" name="trigger_msgs" value="<?php echo esc_attr($trigger_msgs); ?>" min="1" max="10"
      style="width:60px;padding:6px;border:1px solid #d1d5db;border-radius:6px;font-size:14px;font-weight:700;text-align:center">
    <span style="font-size:12px;color:#6b7280">msgs</span>
  </div>

  <div class="sofia-trigger-row">
    <div class="sofia-trigger-label">
      🎯 Detecção de intenção alta
      <div class="sofia-trigger-desc">Pergunta WA quando usuário usa palavras de compra (configure abaixo)</div>
    </div>
    <label class="sofia-toggle">
      <input type="checkbox" name="trigger_intencao" value="1" <?php checked($trigger_intencao,'1'); ?>>
      <span class="sofia-toggle-slider"></span>
    </label>
  </div>

  <div class="sofia-trigger-row">
    <div class="sofia-trigger-label">
      🛒 Clique em "Quero este"
      <div class="sofia-trigger-desc">Pede WA quando usuário clica no botão de reserva (~71% conversão)</div>
    </div>
    <label class="sofia-toggle">
      <input type="checkbox" name="trigger_quero" value="1" <?php checked($trigger_quero,'1'); ?>>
      <span class="sofia-toggle-slider"></span>
    </label>
  </div>
</div>

<div class="sofia-section">
  <h3>🔑 Palavras-chave de Intenção Alta</h3>
  <p style="font-size:12px;color:#6b7280;margin-bottom:10px">Separadas por vírgula. Quando o usuário usar qualquer uma dessas palavras, o gatilho de intenção dispara.</p>
  <textarea name="sofia_keywords" rows="3" style="width:100%;padding:10px;border:1px solid #d1d5db;border-radius:8px;font-size:13px;font-family:monospace"><?php echo esc_textarea($keywords_raw); ?></textarea>
</div>

<div class="sofia-section">
  <h3>💬 Mensagem de Captura do WhatsApp</h3>
  <p style="font-size:12px;color:#6b7280;margin-bottom:10px">Texto que a SofIA envia quando pede o WhatsApp do usuário. Use uma linguagem natural e amigável.</p>
  <textarea name="sofia_wa_msg" id="sofia_wa_msg_input" rows="3" style="width:100%;padding:10px;border:1px solid #d1d5db;border-radius:8px;font-size:13px;line-height:1.5" oninput="document.getElementById('sofia_preview_msg').textContent=this.value"><?php echo esc_textarea($sofia_wa_msg); ?></textarea>
</div>

<div class="sofia-section">
  <h3>✅ Resposta após receber o WhatsApp</h3>
  <p style="font-size:12px;color:#6b7280;margin-bottom:10px">Mensagem que a SofIA responde depois que o usuário envia o número. Confirma o recebimento e cria expectativa.</p>
  <textarea name="sofia_wa_confirm" id="sofia_wa_confirm_input" rows="3" style="width:100%;padding:10px;border:1px solid #d1d5db;border-radius:8px;font-size:13px;line-height:1.5" oninput="document.getElementById('sofia_preview_confirm').textContent=this.value"><?php echo esc_textarea($sofia_wa_confirm); ?></textarea>
</div>

<div style="background:#faf5ff;border:1px solid #ede9fe;border-radius:10px;padding:16px;margin-bottom:16px">
  <h3 style="font-size:14px;font-weight:700;color:#6d28d9;margin:0 0 10px">📱 Preview — Como aparece no chat</h3>
  <div style="max-width:320px;background:#fff;border:2px solid #e5e7eb;border-radius:16px;padding:16px">
    <div style="background:#7c3aed;border-radius:10px;padding:10px 14px;margin-bottom:12px;display:flex;align-items:center;gap:8px">
      <div style="width:32px;height:32px;background:linear-gradient(135deg,#7c3aed,#a855f7);border-radius:50%;display:flex;align-items:center;justify-content:center;font-size:16px">🧠</div>
      <div><div style="font-size:13px;font-weight:700;color:#fff">SofIA Assessora</div><div style="font-size:11px;color:#c4b5fd">● online</div></div>
    </div>
    <div style="background:#f3f4f6;border-radius:4px 16px 16px 16px;padding:10px 14px;font-size:12px;line-height:1.5;margin-bottom:8px;color:#1f2937">
      <span id="sofia_preview_msg"><?php echo esc_html($sofia_wa_msg); ?></span>
    </div>
    <div style="background:linear-gradient(135deg,#fffbeb,#fef3c7);border:1px solid #fbbf24;border-radius:12px;padding:12px;margin-top:8px">
      <div style="font-size:12px;font-weight:700;color:#92400e;margin-bottom:8px">📲 Seu WhatsApp:</div>
      <input type="text" placeholder="(11) 99999-0000" style="width:100%;padding:8px;border:1px solid #fbbf24;border-radius:8px;font-size:12px;margin-bottom:6px">
      <button style="width:100%;background:#FFD700;color:#1f2937;font-size:12px;font-weight:700;padding:8px;border:none;border-radius:8px;cursor:default">Enviar →</button>
    </div>
    <div style="background:#dcfce7;border-radius:16px 16px 16px 4px;padding:10px 14px;font-size:12px;line-height:1.5;margin-top:8px;color:#166534;border:1px solid #bbf7d0">
      <span id="sofia_preview_confirm"><?php echo esc_html($sofia_wa_confirm); ?></span>
    </div>
  </div>
</div>

<button type="submit" class="button button-primary button-large">💾 Salvar Configurações</button>
</form>

<?php elseif ($active_tab === 'automacoes'): ?>
<!-- ═══ AUTOMAÇÕES ═══════════════════════════════════════════════════════════ -->
<div class="sofia-section" style="margin-bottom:16px">
  <h3>🤖 Automações por Intenção</h3>
  <p style="font-size:13px;color:#6b7280;margin:0 0 16px">Quando a SofIA captura sinais de intenção, você pode automatizar o próximo passo. As regras rodam via Aquecer automático.</p>

  <div style="background:#fef3c7;border:1px solid #fbbf24;border-radius:8px;padding:12px;margin-bottom:16px;font-size:13px;color:#92400e">
    ⚙️ <strong>Em construção</strong> — as regras abaixo são exemplos do que será configurável. A engine de execução será integrada ao módulo Aquecer.
  </div>

  <!-- Regra 1 -->
  <div class="sofia-rule-row">
    <div style="display:flex;align-items:center;justify-content:space-between;margin-bottom:8px">
      <div class="sofia-rule-title">🎯 Intenção Alta + Sem compra</div>
      <label class="sofia-toggle"><input type="checkbox" checked disabled><span class="sofia-toggle-slider"></span></label>
    </div>
    <div class="sofia-rule-body">
      <span class="sofia-rule-badge">SE</span> Intenção alta detectada <span class="sofia-rule-badge">+</span> Sem compra em 24h<br>
      <span class="sofia-rule-badge" style="background:#d1fae5;color:#065f46">ENTÃO</span> WA personalizado com portfólio da categoria mencionada
    </div>
  </div>

  <!-- Regra 2 -->
  <div class="sofia-rule-row">
    <div style="display:flex;align-items:center;justify-content:space-between;margin-bottom:8px">
      <div class="sofia-rule-title">📅 Tem data + Urgência alta</div>
      <label class="sofia-toggle"><input type="checkbox" checked disabled><span class="sofia-toggle-slider"></span></label>
    </div>
    <div class="sofia-rule-body">
      <span class="sofia-rule-badge">SE</span> Data evento em ≤ 30 dias <span class="sofia-rule-badge">+</span> Urgência alta <span class="sofia-rule-badge">+</span> WA capturado<br>
      <span class="sofia-rule-badge" style="background:#d1fae5;color:#065f46">ENTÃO</span> WA de urgência com disponibilidade e desconto relâmpago
    </div>
  </div>

  <!-- Regra 3 -->
  <div class="sofia-rule-row">
    <div style="display:flex;align-items:center;justify-content:space-between;margin-bottom:8px">
      <div class="sofia-rule-title">🛒 Clicou "Quero este" + Não comprou</div>
      <label class="sofia-toggle"><input type="checkbox" checked disabled><span class="sofia-toggle-slider"></span></label>
    </div>
    <div class="sofia-rule-body">
      <span class="sofia-rule-badge">SE</span> Trigger = quero_este <span class="sofia-rule-badge">+</span> Convertido = Não <span class="sofia-rule-badge">+</span> 6h depois<br>
      <span class="sofia-rule-badge" style="background:#d1fae5;color:#065f46">ENTÃO</span> WA com link direto para o produto + oferta especial
    </div>
  </div>

  <button class="button" disabled style="margin-top:8px">+ Nova Regra (em breve)</button>
</div>

<div class="sofia-section">
  <h3>📊 Performance das Automações</h3>
  <div style="text-align:center;padding:30px;color:#9ca3af">
    <div style="font-size:32px;margin-bottom:8px">📈</div>
    Dados de performance aparecerão aqui quando as automações estiverem rodando
  </div>
</div>

<?php elseif ($active_tab === 'plano'): ?>
<!-- ═══ PLANO ═══════════════════════════════════════════════════════════════ -->
<div class="sofia-section">
  <h3>🏗️ Plano de Implementação — SofIA Intelligence</h3>
  <p style="font-size:13px;color:#6b7280;margin:0 0 16px">Roteiro para transformar conversas em vendas automáticas</p>

  <div class="sofia-plan-phase sofia-plan-done">
    <h4>✅ Fase 1 — Base (Concluída)</h4>
    <p>Tabela vm2_sofia_sessions • REST endpoint /sofia/session • Menu admin • 4 abas UI • Schema BD completo</p>
  </div>

  <div class="sofia-plan-phase sofia-plan-doing">
    <h4>🔄 Fase 2 — Captura Ativa (Em andamento)</h4>
    <p>Integração vm-bottom-nav: enviar dados para endpoint após cada mensagem • Soft ask após N mensagens • Detecção de palavras-chave no frontend • Captura no "Quero este"</p>
  </div>

  <div class="sofia-plan-phase">
    <h4>📋 Fase 3 — Sinais & Classificação</h4>
    <p>Parser de intenção no backend • Classificação automática de categoria (infantil/casamento/etc) • Extração de data mencionada no chat • Score de urgência</p>
  </div>

  <div class="sofia-plan-phase">
    <h4>📋 Fase 4 — Automações por Intenção</h4>
    <p>Engine de regras SE/ENTÃO integrada ao Aquecer • Disparos personalizados por categoria e urgência • Templates WABA por perfil de intenção</p>
  </div>

  <div class="sofia-plan-phase">
    <h4>📋 Fase 5 — Dashboard Avançado</h4>
    <p>Gráfico de funil interativo • Nuvem de palavras das sessões • Mapa de calor por horário • Comparativo semanal/mensal</p>
  </div>

  <div class="sofia-plan-phase">
    <h4>📋 Fase 6 — Visão Completa</h4>
    <p>Desligar Kommo como CRM principal • Loja 100% independente e inteligente • SofIA conhece histórico completo do visitante ao retornar</p>
  </div>
</div>

<div class="sofia-section">
  <h3>💡 Visão Estratégica</h3>
  <div style="background:linear-gradient(135deg,#1a0a2e,#2d1b69);border-radius:10px;padding:20px;color:#e2e8f0">
    <p style="margin:0 0 10px;font-size:14px;line-height:1.6">A SofIA não é só um chatbot — é o <strong style="color:#FFD700">sistema nervoso da loja</strong>. Cada conversa gera sinais que alimentam automações, personalizam follow-ups e identificam os leads mais quentes antes mesmo de eles saberem que vão comprar.</p>
    <p style="margin:0;font-size:13px;color:#a78bfa">Meta: 100 atrações/dia → TUDO AUTOMÁTICO, zero operacional</p>
  </div>
</div>
<?php elseif ($active_tab === 'conhecimento'): ?>
<!-- ═══ BASE DE CONHECIMENTO ══════════════════════════════════════════════════ -->
<?php
$kb_table  = $wpdb->prefix . 'vm2_sofia_knowledge';
if ( $wpdb->get_var("SHOW TABLES LIKE '$kb_table'") !== $kb_table ) {
    vm2_create_sofia_knowledge_table();
}
$kb_items  = $wpdb->get_results("SELECT * FROM $kb_table ORDER BY criado_em DESC");
$kb_ativos = array_filter($kb_items, function($i){ return (int)$i->ativo === 1; });
$kb_nonce  = wp_create_nonce('vm2_sofia_kb');
?>
<div class="sofia-section">
  <div style="display:flex;align-items:center;justify-content:space-between;flex-wrap:wrap;gap:10px;margin-bottom:16px">
    <div>
      <h3 style="margin:0 0 4px">📚 Base de Conhecimento da SofIA</h3>
      <p style="margin:0;font-size:13px;color:#6b7280">A SofIA usa automaticamente todos os itens <strong>ativos</strong> para responder com propriedade sobre seu negócio.</p>
    </div>
    <div style="background:#ecfdf5;border:1px solid #6ee7b7;border-radius:8px;padding:8px 14px;font-size:13px;color:#065f46;font-weight:600">
      ✅ <?php echo count($kb_ativos); ?> item(s) ativo(s)
    </div>
  </div>

  <!-- FORMULÁRIO ADD -->
  <div id="vm2kb-form-wrap" style="background:#f9fafb;border:1px solid #e5e7eb;border-radius:10px;padding:20px;margin-bottom:24px">
    <h4 style="margin:0 0 14px;font-size:15px;color:#1e293b">➕ Adicionar Conhecimento</h4>

    <div style="display:grid;grid-template-columns:1fr 1fr;gap:12px;margin-bottom:12px">
      <div>
        <label style="font-size:12px;font-weight:600;color:#374151;display:block;margin-bottom:4px">Tipo</label>
        <select id="vm2kb-tipo" style="width:100%;padding:8px;border:1px solid #d1d5db;border-radius:6px;font-size:13px">
          <option value="texto">📝 Texto livre</option>
          <option value="url">🌐 URL / Site</option>
          <option value="drive">📄 Google Doc</option>
        </select>
      </div>
      <div>
        <label style="font-size:12px;font-weight:600;color:#374151;display:block;margin-bottom:4px">Título (nome para identificar)</label>
        <input type="text" id="vm2kb-titulo" placeholder="Ex: Contrato VivaMais, Política de Preços..." style="width:100%;padding:8px;border:1px solid #d1d5db;border-radius:6px;font-size:13px;box-sizing:border-box">
      </div>
    </div>

    <!-- URL field -->
    <div id="vm2kb-url-wrap" style="display:none;margin-bottom:12px">
      <label style="font-size:12px;font-weight:600;color:#374151;display:block;margin-bottom:4px">URL</label>
      <div style="display:flex;gap:8px">
        <input type="url" id="vm2kb-url" placeholder="https://..." style="flex:1;padding:8px;border:1px solid #d1d5db;border-radius:6px;font-size:13px">
        <button type="button" id="vm2kb-btn-preview" style="padding:8px 14px;background:#6366f1;color:#fff;border:none;border-radius:6px;font-size:13px;cursor:pointer;white-space:nowrap">🔍 Importar</button>
      </div>
      <div id="vm2kb-preview-result" style="display:none;margin-top:8px;padding:10px;background:#eff6ff;border:1px solid #bfdbfe;border-radius:6px;font-size:12px;color:#1e40af"></div>
    </div>

    <!-- Conteúdo manual -->
    <div id="vm2kb-conteudo-wrap" style="margin-bottom:14px">
      <label style="font-size:12px;font-weight:600;color:#374151;display:block;margin-bottom:4px">Conteúdo</label>
      <textarea id="vm2kb-conteudo" rows="6" placeholder="Cole aqui o texto que a SofIA deve conhecer — contrato, FAQ, política de preços, informações sobre os serviços..." style="width:100%;padding:8px;border:1px solid #d1d5db;border-radius:6px;font-size:13px;box-sizing:border-box;resize:vertical"></textarea>
      <span id="vm2kb-chars" style="font-size:11px;color:#9ca3af">0 caracteres</span>
    </div>

    <div style="display:flex;align-items:center;gap:10px">
      <button type="button" id="vm2kb-btn-save" style="padding:10px 24px;background:#10b981;color:#fff;border:none;border-radius:8px;font-size:14px;font-weight:600;cursor:pointer">💾 Salvar Conhecimento</button>
      <span id="vm2kb-save-msg" style="font-size:13px"></span>
    </div>
  </div>

  <!-- LISTA DE ITEMS -->
  <h4 style="margin:0 0 12px;font-size:15px;color:#1e293b">📋 Itens Cadastrados (<?php echo count($kb_items); ?>)</h4>

  <?php if (empty($kb_items)): ?>
  <div style="text-align:center;padding:40px;color:#9ca3af;background:#f9fafb;border:1px dashed #d1d5db;border-radius:10px">
    <div style="font-size:36px;margin-bottom:8px">📭</div>
    <p>Nenhum conhecimento cadastrado ainda.<br>Adicione o contrato, FAQs, políticas de preço, informações sobre os serviços...</p>
  </div>
  <?php else: ?>
  <div id="vm2kb-list" style="display:flex;flex-direction:column;gap:10px">
    <?php foreach ($kb_items as $item):
      $is_active = (int)$item->ativo === 1;
      $tipo_icon = $item->tipo === 'url' ? '🌐' : ($item->tipo === 'drive' ? '📄' : '📝');
      $preview   = mb_substr(strip_tags($item->conteudo), 0, 180);
      $chars     = mb_strlen($item->conteudo);
    ?>
    <div id="vm2kb-item-<?php echo (int)$item->id; ?>" style="background:#fff;border:1px solid <?php echo $is_active ? '#6ee7b7' : '#e5e7eb'; ?>;border-left:4px solid <?php echo $is_active ? '#10b981' : '#9ca3af'; ?>;border-radius:8px;padding:14px">
      <div style="display:flex;align-items:flex-start;justify-content:space-between;gap:10px">
        <div style="flex:1;min-width:0">
          <div style="display:flex;align-items:center;gap:8px;flex-wrap:wrap;margin-bottom:4px">
            <span style="font-size:14px;font-weight:700;color:#1e293b"><?php echo $tipo_icon; ?> <?php echo esc_html($item->titulo); ?></span>
            <span style="font-size:11px;padding:2px 8px;border-radius:20px;background:<?php echo $is_active ? '#dcfce7' : '#f3f4f6'; ?>;color:<?php echo $is_active ? '#166534' : '#6b7280'; ?>;font-weight:600">
              <?php echo $is_active ? '🟢 Ativo' : '⚫ Inativo'; ?>
            </span>
            <span style="font-size:11px;color:#9ca3af"><?php echo esc_html(ucfirst($item->tipo)); ?> · <?php echo number_format($chars); ?> chars · <?php echo wp_date('d/m/Y', strtotime($item->criado_em)); ?></span>
          </div>
          <p style="margin:0;font-size:12px;color:#6b7280;line-height:1.5"><?php echo esc_html($preview); ?><?php echo $chars > 180 ? '...' : ''; ?></p>
          <?php if ($item->url): ?>
          <a href="<?php echo esc_url($item->url); ?>" target="_blank" style="font-size:11px;color:#6366f1;text-decoration:none">🔗 <?php echo esc_html(parse_url($item->url, PHP_URL_HOST)); ?></a>
          <?php endif; ?>
        </div>
        <div style="display:flex;gap:6px;flex-shrink:0">
          <button type="button"
            data-id="<?php echo (int)$item->id; ?>"
            data-ativo="<?php echo $is_active ? '1' : '0'; ?>"
            class="vm2kb-toggle-btn"
            style="padding:6px 12px;background:<?php echo $is_active ? '#fef3c7' : '#dcfce7'; ?>;color:<?php echo $is_active ? '#92400e' : '#166534'; ?>;border:1px solid <?php echo $is_active ? '#fcd34d' : '#6ee7b7'; ?>;border-radius:6px;font-size:12px;cursor:pointer;white-space:nowrap"
            title="<?php echo $is_active ? 'Desativar' : 'Ativar'; ?>"><?php echo $is_active ? '⏸ Pausar' : '▶ Ativar'; ?></button>
          <button type="button"
            data-id="<?php echo (int)$item->id; ?>"
            class="vm2kb-del-btn"
            style="padding:6px 12px;background:#fee2e2;color:#991b1b;border:1px solid #fca5a5;border-radius:6px;font-size:12px;cursor:pointer"
            title="Deletar">🗑</button>
        </div>
      </div>
    </div>
    <?php endforeach; ?>
  </div>
  <?php endif; ?>
</div>

<script>
(function(){
  var nonce  = <?php echo json_encode($kb_nonce); ?>;
  var ajaxUrl = <?php echo json_encode(admin_url('admin-ajax.php')); ?>;

  // Tipo selector
  var tipoSel    = document.getElementById('vm2kb-tipo');
  var urlWrap    = document.getElementById('vm2kb-url-wrap');
  var conteWrap  = document.getElementById('vm2kb-conteudo-wrap');
  var urlInput   = document.getElementById('vm2kb-url');
  var conteInput = document.getElementById('vm2kb-conteudo');
  var charsSpan  = document.getElementById('vm2kb-chars');
  var previewDiv = document.getElementById('vm2kb-preview-result');
  var saveMsg    = document.getElementById('vm2kb-save-msg');

  function updateForm() {
    var v = tipoSel.value;
    if (v === 'url' || v === 'drive') {
      urlWrap.style.display   = 'block';
      conteWrap.style.display = 'block';
      conteInput.placeholder  = v === 'drive'
        ? 'Clique em "Importar" para extrair o texto do Google Doc, ou cole manualmente.'
        : 'Clique em "Importar" para extrair o texto da página, ou cole manualmente.';
    } else {
      urlWrap.style.display   = 'none';
      conteWrap.style.display = 'block';
      conteInput.placeholder  = 'Cole aqui o texto que a SofIA deve conhecer — contrato, FAQ, política de preços...';
    }
  }
  tipoSel.addEventListener('change', updateForm);
  updateForm();

  // Char counter
  conteInput.addEventListener('input', function(){
    charsSpan.textContent = conteInput.value.length.toLocaleString('pt-BR') + ' caracteres';
  });

  // Preview / Importar
  document.getElementById('vm2kb-btn-preview').addEventListener('click', function(){
    var url = urlInput.value.trim();
    if (!url) { alert('Cole a URL antes de importar.'); return; }
    var btn = this;
    btn.disabled = true;
    btn.textContent = '⏳ Importando...';
    previewDiv.style.display = 'none';
    var fd = new FormData();
    fd.append('action', 'vm2_sofia_kb_preview');
    fd.append('nonce',  nonce);
    fd.append('url',    url);
    fetch(ajaxUrl, {method:'POST', body:fd})
      .then(function(r){ return r.json(); })
      .then(function(d){
        btn.disabled    = false;
        btn.textContent = '🔍 Importar';
        if (d.success) {
          var t = d.data;
          if (!document.getElementById('vm2kb-titulo').value) {
            document.getElementById('vm2kb-titulo').value = t.titulo;
          }
          if (!conteInput.value) {
            conteInput.value = t.conteudo;
            charsSpan.textContent = t.chars.toLocaleString('pt-BR') + ' caracteres importados';
          }
          previewDiv.style.display = 'block';
          previewDiv.innerHTML = '<strong>✅ Importado com sucesso!</strong> ' + t.chars.toLocaleString('pt-BR') + ' caracteres extraídos de <em>' + t.titulo + '</em>. Você pode editar o conteúdo antes de salvar.';
        } else {
          previewDiv.style.display = 'block';
          previewDiv.style.background = '#fef2f2';
          previewDiv.style.borderColor = '#fca5a5';
          previewDiv.style.color = '#991b1b';
          previewDiv.innerHTML = '<strong>❌ ' + d.data + '</strong>';
        }
      })
      .catch(function(e){
        btn.disabled    = false;
        btn.textContent = '🔍 Importar';
        alert('Erro de conexão: ' + e.message);
      });
  });

  // Salvar item
  document.getElementById('vm2kb-btn-save').addEventListener('click', function(){
    var titulo   = document.getElementById('vm2kb-titulo').value.trim();
    var tipo     = tipoSel.value;
    var url      = urlInput.value.trim();
    var conteudo = conteInput.value.trim();
    if (!titulo)   { alert('Por favor, preencha o Título.'); return; }
    if (!conteudo && tipo === 'texto') { alert('Conteúdo não pode estar vazio.'); return; }
    if (!url && (tipo === 'url' || tipo === 'drive') && !conteudo) {
      alert('Cole a URL ou o conteúdo.'); return;
    }
    var btn = this;
    btn.disabled    = true;
    btn.textContent = '⏳ Salvando...';
    saveMsg.textContent = '';
    var fd = new FormData();
    fd.append('action',   'vm2_sofia_kb_save');
    fd.append('nonce',    nonce);
    fd.append('tipo',     tipo);
    fd.append('titulo',   titulo);
    fd.append('url',      url);
    fd.append('conteudo', conteudo);
    fetch(ajaxUrl, {method:'POST', body:fd})
      .then(function(r){ return r.json(); })
      .then(function(d){
        btn.disabled    = false;
        btn.textContent = '💾 Salvar Conhecimento';
        if (d.success) {
          saveMsg.style.color = '#166534';
          saveMsg.textContent = '✅ Salvo! Recarregando...';
          setTimeout(function(){ window.location.reload(); }, 800);
        } else {
          saveMsg.style.color = '#991b1b';
          saveMsg.textContent = '❌ ' + d.data;
        }
      })
      .catch(function(e){
        btn.disabled    = false;
        btn.textContent = '💾 Salvar Conhecimento';
        saveMsg.style.color = '#991b1b';
        saveMsg.textContent = 'Erro: ' + e.message;
      });
  });

  // Toggle ativo/inativo
  document.querySelectorAll('.vm2kb-toggle-btn').forEach(function(btn){
    btn.addEventListener('click', function(){
      var id    = btn.getAttribute('data-id');
      var ativo = btn.getAttribute('data-ativo');
      btn.disabled    = true;
      btn.textContent = '⏳';
      var fd = new FormData();
      fd.append('action', 'vm2_sofia_kb_toggle');
      fd.append('nonce',  nonce);
      fd.append('id',     id);
      fetch(ajaxUrl, {method:'POST', body:fd})
        .then(function(r){ return r.json(); })
        .then(function(d){
          if (d.success) { window.location.reload(); }
          else { btn.disabled = false; alert('Erro: ' + d.data); }
        });
    });
  });

  // Deletar item
  document.querySelectorAll('.vm2kb-del-btn').forEach(function(btn){
    btn.addEventListener('click', function(){
      if (!confirm('Deletar este item da base de conhecimento?')) return;
      var id = btn.getAttribute('data-id');
      btn.disabled    = true;
      btn.textContent = '⏳';
      var fd = new FormData();
      fd.append('action', 'vm2_sofia_kb_delete');
      fd.append('nonce',  nonce);
      fd.append('id',     id);
      fetch(ajaxUrl, {method:'POST', body:fd})
        .then(function(r){ return r.json(); })
        .then(function(d){
          if (d.success) {
            var row = document.getElementById('vm2kb-item-' + id);
            if (row) row.remove();
          } else {
            btn.disabled = false;
            alert('Erro: ' + d.data);
          }
        });
    });
  });
})();
</script>

<?php elseif ($active_tab === 'prompt'): ?>
<?php
// ── Salvar prompt customizado ─────────────────────────────────────────
if ( isset($_POST['vm2_sofia_prompt_save']) && check_admin_referer('vm2_sofia_prompt_nonce') ) {
    $new_prompt = trim( wp_unslash( $_POST['vm2_sofia_prompt_text'] ?? '' ) );
    // [v1.5.93] toggle ask_email
    update_option('vm2_sofia_ask_email', isset($_POST['vm2_sofia_ask_email']) ? '1' : '0');
    if ( empty($new_prompt) ) {
        delete_option('vm2_sofia_system_prompt');
        echo '<div class="notice notice-success is-dismissible"><p>✅ Prompt resetado — SofIA voltará a usar o padrão interno.</p></div>';
    } else {
        update_option('vm2_sofia_system_prompt', $new_prompt, 'no');
        echo '<div class="notice notice-success is-dismissible"><p>✅ Prompt salvo com sucesso!</p></div>';
    }
}
$current_prompt = get_option('vm2_sofia_system_prompt', '');
$default_prompt = get_option('vm2_sofia_default_prompt', '');
$showing_default = empty($current_prompt);
$textarea_value  = $showing_default ? $default_prompt : $current_prompt;
?>
<div style="max-width:960px">
  <h2 style="margin-top:0;display:flex;align-items:center;gap:10px">⚙️ System Prompt da SofIA
    <?php if ($showing_default): ?>
      <span style="font-size:12px;font-weight:normal;background:#dcfce7;color:#166534;padding:3px 10px;border-radius:20px">usando padrão</span>
    <?php else: ?>
      <span style="font-size:12px;font-weight:normal;background:#fef9c3;color:#854d0e;padding:3px 10px;border-radius:20px">✏️ customizado</span>
    <?php endif; ?>
  </h2>
  <p style="color:#6b7280;margin-top:-8px;font-size:13px">
    Este é o "cérebro" da SofIA — define personalidade, regras e comportamento. Enviado ao Claude antes de <strong>cada conversa</strong>.
  </p>

  <div style="background:#eff6ff;border:1px solid #bfdbfe;border-radius:8px;padding:12px 16px;margin-bottom:16px;font-size:13px;line-height:1.6">
    💡 <strong>Variáveis disponíveis no prompt:</strong><br>
    <code style="background:#dbeafe;padding:2px 6px;border-radius:4px">{catalog_text}</code> — substituído automaticamente pelo catálogo de atrações em tempo real (mantenha esta variável no prompt).<br>
    Os itens da <strong>Base de Conhecimento</strong> são sempre injetados <em>após</em> este prompt, independentemente do que você escrever aqui.
  </div>

  <form method="post">
    <?php wp_nonce_field('vm2_sofia_prompt_nonce'); ?>
    <!-- [v1.5.93] Email toggle -->
    <?php $sofia_ask_email = get_option('vm2_sofia_ask_email','0'); ?>
    <div style="background:#fefce8;border:1px solid #fde68a;border-radius:8px;padding:12px 16px;margin-bottom:16px;display:flex;align-items:flex-start;gap:12px">
        <div>
            <label style="font-weight:700;font-size:13px;display:flex;align-items:center;gap:8px;cursor:pointer">
                <input type="checkbox" name="vm2_sofia_ask_email" value="1" <?php checked($sofia_ask_email,'1'); ?> style="width:16px;height:16px">
                📧 Pedir email após capturar WhatsApp
            </label>
            <p style="margin:6px 0 0;font-size:12px;color:#92400e">
                Quando ativo, adiciona ao prompt a instrução para pedir o e-mail após o WhatsApp ser fornecido, usando o copy:
                <em>"Seu e-mail? Assim a gente garante o contato mesmo se o WhatsApp travar 🔒"</em>
            </p>
        </div>
    </div>
    <textarea
      name="vm2_sofia_prompt_text"
      id="vm2-sofia-prompt-textarea"
      rows="32"
      style="width:100%;font-family:'SF Mono',Monaco,Consolas,monospace;font-size:12px;line-height:1.65;padding:14px;border:2px solid #e5e7eb;border-radius:8px;resize:vertical;box-sizing:border-box;background:#fafafa"
    ><?php echo esc_textarea($textarea_value); ?></textarea>

    <div style="display:flex;gap:10px;margin-top:14px;flex-wrap:wrap;align-items:center">
      <button type="submit" name="vm2_sofia_prompt_save" value="1"
        style="background:#7c3aed;color:#fff;border:none;border-radius:6px;padding:10px 20px;font-size:14px;font-weight:600;cursor:pointer">
        💾 Salvar Prompt
      </button>
      <button type="button" id="vm2-prompt-load-default"
        style="background:#fff;color:#6b7280;border:1px solid #d1d5db;border-radius:6px;padding:10px 20px;font-size:13px;cursor:pointer">
        📋 Carregar padrão
      </button>
      <button type="button" id="vm2-prompt-clear"
        style="background:#fff;color:#dc2626;border:1px solid #fca5a5;border-radius:6px;padding:10px 20px;font-size:13px;cursor:pointer">
        🔄 Limpar (volta ao padrão no save)
      </button>
      <span style="font-size:12px;color:#9ca3af;margin-left:auto" id="vm2-prompt-charcount"></span>
    </div>
  </form>
</div>

<script>
(function(){
  var ta = document.getElementById('vm2-sofia-prompt-textarea');
  var cc = document.getElementById('vm2-prompt-charcount');
  var defaultPrompt = <?php echo wp_json_encode( $default_prompt ?: '(padrão ainda não registrado — abra a loja uma vez para carregar)' ); ?>;

  function updateCount() {
    if (cc) cc.textContent = ta.value.length.toLocaleString('pt-BR') + ' caracteres';
  }
  ta.addEventListener('input', updateCount);
  updateCount();

  document.getElementById('vm2-prompt-load-default').addEventListener('click', function(){
    if (confirm('Substituir o conteúdo pelo prompt padrão?')) {
      ta.value = defaultPrompt;
      updateCount();
    }
  });

  document.getElementById('vm2-prompt-clear').addEventListener('click', function(){
    if (confirm('Limpar o campo? Ao salvar vazio, a SofIA voltará a usar o prompt padrão interno.')) {
      ta.value = '';
      updateCount();
    }
  });
})();
</script>


<?php elseif ($active_tab === 'setup'): ?>
<?php
// ── Salvar configurações auto-open ────────────────────────────────────
if ( isset($_POST['vm2_sofia_setup_save']) && check_admin_referer('vm2_sofia_setup_nonce') ) {
    update_option('vm2_sofia_auto_open',  isset($_POST['vm2_sofia_auto_open']) ? 1 : 0);
    update_option('vm2_sofia_auto_open_delay', intval($_POST['vm2_sofia_auto_open_delay'] ?? 8));
    update_option('vm2_sofia_auto_open_freq', sanitize_key($_POST['vm2_sofia_auto_open_freq'] ?? 'once_session'));
    update_option('vm2_sofia_auto_open_msg', sanitize_textarea_field(wp_unslash($_POST['vm2_sofia_auto_open_msg'] ?? '')));
    update_option('vm2_sofia_excluded_urls', sanitize_textarea_field(wp_unslash($_POST['vm2_sofia_excluded_urls'] ?? '')));
    echo '<div class="notice notice-success is-dismissible"><p>✅ Configurações salvas!</p></div>';
}
$ao_enabled   = (int)get_option('vm2_sofia_auto_open', 0);
$ao_delay     = (int)get_option('vm2_sofia_auto_open_delay', 8);
$ao_freq      = get_option('vm2_sofia_auto_open_freq', 'once_session');
$ao_msg       = get_option('vm2_sofia_auto_open_msg', '');
$ao_excl_urls = get_option('vm2_sofia_excluded_urls', '');
?>
<div style="max-width:720px">
  <h2 style="margin-top:0;display:flex;align-items:center;gap:10px">🔧 Setup da SofIA
    <span style="font-size:12px;font-weight:normal;background:<?php echo $ao_enabled?'#dcfce7':'#fee2e2'; ?>;color:<?php echo $ao_enabled?'#166534':'#991b1b'; ?>;padding:3px 10px;border-radius:20px">
      <?php echo $ao_enabled ? '🟢 Auto-open ativo' : '🔴 Auto-open desligado'; ?>
    </span>
  </h2>
  <p style="color:#6b7280;margin-top:-8px;font-size:13px">Configure quando e como a SofIA abre automaticamente para os visitantes do site.</p>

  <form method="post">
    <?php wp_nonce_field('vm2_sofia_setup_nonce'); ?>

    <!-- Card: Auto-open principal -->
    <div style="background:#fff;border:1px solid #e5e7eb;border-radius:12px;padding:20px 24px;margin-bottom:16px">
      <div style="display:flex;align-items:center;justify-content:space-between;margin-bottom:16px">
        <div>
          <strong style="font-size:15px">🚀 Abrir SofIA automaticamente</strong>
          <p style="margin:4px 0 0;color:#6b7280;font-size:13px">Quando ativado, a SofIA abre sozinha após o visitante entrar no site.</p>
        </div>
        <label style="display:flex;align-items:center;gap:8px;cursor:pointer">
          <input type="checkbox" name="vm2_sofia_auto_open" value="1" <?php checked($ao_enabled, 1); ?>
            style="width:18px;height:18px;accent-color:#7c3aed">
          <span style="font-weight:600;color:<?php echo $ao_enabled?'#7c3aed':'#6b7280'; ?>"><?php echo $ao_enabled?'Ativo':'Inativo'; ?></span>
        </label>
      </div>

      <!-- Delay -->
      <div style="margin-bottom:16px">
        <label style="display:block;font-size:13px;font-weight:600;color:#374151;margin-bottom:6px">⏱️ Abrir após (segundos)</label>
        <div style="display:flex;align-items:center;gap:12px">
          <input type="number" name="vm2_sofia_auto_open_delay" value="<?php echo esc_attr($ao_delay); ?>"
            min="0" max="120" style="width:90px;padding:8px 12px;border:1px solid #d1d5db;border-radius:8px;font-size:14px">
          <span style="font-size:12px;color:#9ca3af">0 = imediato · 8s recomendado (visitante já leu algo)</span>
        </div>
      </div>

      <!-- Frequência -->
      <div style="margin-bottom:16px">
        <label style="display:block;font-size:13px;font-weight:600;color:#374151;margin-bottom:8px">🔁 Frequência</label>
        <div style="display:flex;flex-direction:column;gap:8px">
          <?php
          $freqs = [
            'once_session' => ['label'=>'Uma vez por sessão',   'desc'=>'Abre só na primeira visita de cada aba/janela — fecha o navegador, abre de novo (⭐ recomendado)'],
            'once_day'     => ['label'=>'Uma vez por dia',      'desc'=>'Abre no máximo uma vez a cada 24h por visitante'],
            'new_only'     => ['label'=>'Apenas novos visitantes','desc'=>'Só abre para quem nunca conversou com a SofIA antes'],
            'always'       => ['label'=>'Sempre',               'desc'=>'Abre em toda página carregada (pode irritar visitantes frequentes)'],
          ];
          foreach ($freqs as $val => $f): ?>
          <label style="display:flex;align-items:flex-start;gap:10px;padding:10px 14px;border:2px solid <?php echo $ao_freq===$val?'#7c3aed':'#e5e7eb'; ?>;border-radius:8px;cursor:pointer;background:<?php echo $ao_freq===$val?'#faf5ff':'#fff'; ?>">
            <input type="radio" name="vm2_sofia_auto_open_freq" value="<?php echo esc_attr($val); ?>" <?php checked($ao_freq, $val); ?> style="margin-top:2px;accent-color:#7c3aed">
            <div>
              <strong style="font-size:13px;color:#111827"><?php echo esc_html($f['label']); ?></strong>
              <p style="margin:2px 0 0;font-size:12px;color:#6b7280"><?php echo esc_html($f['desc']); ?></p>
            </div>
          </label>
          <?php endforeach; ?>
        </div>
      </div>
    </div>

    <!-- Card: Mensagem inicial -->
    <div style="background:#fff;border:1px solid #e5e7eb;border-radius:12px;padding:20px 24px;margin-bottom:16px">
      <strong style="font-size:15px">💬 Mensagem inicial (opcional)</strong>
      <p style="margin:4px 0 12px;color:#6b7280;font-size:13px">Se preenchida, a SofIA exibe esta mensagem ao abrir automaticamente — em vez dos chips de sugestão padrão. Deixe vazio para manter o comportamento padrão.</p>
      <textarea name="vm2_sofia_auto_open_msg" rows="3"
        placeholder="Ex: Olá! 👋 Posso te ajudar a encontrar a atração perfeita para seu evento? Me conta um pouco sobre a festa!"
        style="width:100%;padding:10px 14px;border:1px solid #d1d5db;border-radius:8px;font-size:13px;font-family:inherit;resize:vertical"><?php echo esc_textarea($ao_msg); ?></textarea>
      <?php if ($ao_msg): ?>
        <p style="margin:6px 0 0;font-size:12px;color:#7c3aed">✏️ Mensagem customizada ativa</p>
      <?php else: ?>
        <p style="margin:6px 0 0;font-size:12px;color:#9ca3af">Usando chips de sugestão padrão</p>
      <?php endif; ?>
    </div>

    <!-- Preview -->
    <?php if ($ao_enabled): ?>
    <div style="background:#eff6ff;border:1px solid #bfdbfe;border-radius:8px;padding:12px 16px;margin-bottom:16px;font-size:13px">
      ℹ️ <strong>Configuração atual:</strong> SofIA abre após <strong><?php echo $ao_delay; ?>s</strong>,
      frequência <strong><?php echo esc_html($freqs[$ao_freq]['label']); ?></strong><?php if ($ao_msg): ?>, com mensagem customizada<?php endif; ?>.
    </div>
    <?php endif; ?>

    <!-- Card: URLs excluídas -->
    <div style="background:#fff;border:1px solid #e5e7eb;border-radius:12px;padding:20px 24px;margin-bottom:16px">
      <strong style="font-size:15px">🚫 Páginas onde a SofIA NÃO aparece</strong>
      <p style="margin:4px 0 12px;color:#6b7280;font-size:13px">Uma URL por linha. A barra de navegação inteira fica oculta nessas páginas (útil para páginas internas/admin).</p>
      <textarea name="vm2_sofia_excluded_urls" rows="5"
        placeholder="https://loja.vivamaiseventos.com/agenda-vivamais-admins-celular/&#10;https://loja.vivamaiseventos.com/outra-pagina-interna/"
        style="width:100%;padding:10px 14px;border:1px solid #d1d5db;border-radius:8px;font-size:13px;font-family:monospace;resize:vertical"><?php echo esc_textarea($ao_excl_urls); ?></textarea>
      <?php
        $excl_count = count(array_filter(array_map('trim', explode("\n", $ao_excl_urls))));
        if ($excl_count > 0):
      ?>
        <p style="margin:6px 0 0;font-size:12px;color:#dc2626">🚫 <?php echo $excl_count; ?> página<?php echo $excl_count > 1 ? 's' : ''; ?> excluída<?php echo $excl_count > 1 ? 's' : ''; ?></p>
      <?php else: ?>
        <p style="margin:6px 0 0;font-size:12px;color:#9ca3af">Nenhuma página excluída — SofIA aparece em todo o site</p>
      <?php endif; ?>
    </div>

    <button type="submit" name="vm2_sofia_setup_save"
      style="background:#7c3aed;color:#fff;border:none;padding:12px 32px;border-radius:8px;font-size:14px;font-weight:600;cursor:pointer">
      💾 Salvar configurações
    </button>
  </form>
</div>

<?php endif; ?>

</div><!-- .wrap -->
<?php
}

// ═══════════════════════════════════════════════════════════════════════════════
// SOFIA LANDING PAGE — /sofia
// Reutiliza o modal SofIA do vm-bottom-nav (mesma fonte de verdade)
// CSS fullscreen + auto-open + UTMs injetados no SOFIA_ENDPOINT
// v1.5.84
// ═══════════════════════════════════════════════════════════════════════════════

// Cria a WP page "sofia" automaticamente se não existir
add_action('init', 'vm2_sofia_ensure_page', 20);
function vm2_sofia_ensure_page() {
    if ( get_page_by_path('sofia') ) return;
    wp_insert_post([
        'post_title'  => 'SofIA — Encontre sua Atração',
        'post_name'   => 'sofia',
        'post_status' => 'publish',
        'post_type'   => 'page',
        'post_content'=> '',
    ]);
}

add_action('template_redirect', 'vm2_sofia_landing_redirect');
function vm2_sofia_landing_redirect() {
    if ( ! ( is_page('sofia') || get_query_var('pagename') === 'sofia' ) ) return;
    // Injetar CSS/JS sem interromper o render normal do WP (vm-bottom-nav carrega junto)
    add_action('wp_head',   'vm2_sofia_landing_head',   99);
    add_action('wp_footer', 'vm2_sofia_landing_footer', 99);
}

function vm2_sofia_landing_head() {
    $pixel_id = '3415944055226829';
    ?>
<!-- Meta Pixel -->
<script>!function(f,b,e,v,n,t,s){if(f.fbq)return;n=f.fbq=function(){n.callMethod?n.callMethod.apply(n,arguments):n.queue.push(arguments)};if(!f._fbq)f._fbq=n;n.push=n;n.loaded=!0;n.version='2.0';n.queue=[];t=b.createElement(e);t.async=!0;t.src=v;s=b.getElementsByTagName(e)[0];s.parentNode.insertBefore(t,s)}(window,document,'script','https://connect.facebook.net/en_US/fbevents.js');fbq('init','<?php echo esc_js($pixel_id); ?>');fbq('track','PageView');</script>
<noscript><img height="1" width="1" style="display:none" src="https://www.facebook.com/tr?id=<?php echo esc_attr($pixel_id); ?>&ev=PageView&noscript=1"/></noscript>
<style>
/* ── SOFIA LANDING: esconder tudo exceto o modal ── */
body.sofia-landing .site-header,
body.sofia-landing header:not(#vmbnav-ia-panel header),
body.sofia-landing #masthead,
body.sofia-landing .elementor-location-header,
body.sofia-landing footer,
body.sofia-landing .site-footer,
body.sofia-landing #colophon,
body.sofia-landing #wpadminbar,
body.sofia-landing #vmbnav-bar,
body.sofia-landing .entry-header,
body.sofia-landing .entry-content,
body.sofia-landing .page-content,
body.sofia-landing .site-main > *:not(#vmbnav-ia-modal) {
    display: none !important;
}
body.sofia-landing {
    background: #f5f3ff;
    overflow: hidden;
}
/* ── Modal fullscreen ── */
body.sofia-landing #vmbnav-ia-modal {
    background: #fff !important;
    align-items: stretch !important;
    justify-content: center !important;
    display: flex !important;
}
/* Panel: coluna flex que preenche 100dvh sem scroll próprio */
body.sofia-landing #vmbnav-ia-panel {
    height: 100dvh !important;
    max-height: 100dvh !important;
    border-radius: 0 !important;
    width: 100% !important;
    max-width: 480px !important;
    margin: 0 auto !important;
    transform: translateY(0) !important;
    box-shadow: none !important;
    overflow-y: hidden !important;
    display: flex !important;
    flex-direction: column !important;
    padding: 0 !important;
    box-sizing: border-box !important;
}
/* Header e chips: não encolhem */
body.sofia-landing .vmbnav-ia-header {
    flex-shrink: 0 !important;
    padding: 14px 20px 12px !important;
    margin-bottom: 0 !important;
}
body.sofia-landing #vm2-sofia-utm {
    flex-shrink: 0 !important;
}
body.sofia-landing #vmbnav-ia-chips {
    flex-shrink: 0 !important;
    padding: 6px 20px 8px !important;
}
/* Chat: cresce e rola */
body.sofia-landing #vmbnav-ia-chat {
    flex: 1 1 auto !important;
    max-height: none !important;
    overflow-y: auto !important;
    -webkit-overflow-scrolling: touch !important;
    padding: 4px 20px 8px !important;
}
/* Typing indicator */
body.sofia-landing #vmbnav-ia-typing {
    flex-shrink: 0 !important;
    padding: 2px 20px 4px !important;
}
/* Input: fixo no fundo, send button como flex item */
body.sofia-landing .vmbnav-ia-input-wrap {
    flex-shrink: 0 !important;
    position: relative !important;
    padding: 10px 20px calc(14px + env(safe-area-inset-bottom, 0px)) !important;
    margin-top: 0 !important;
    border-top: 1px solid #ede9fe !important;
}
body.sofia-landing .vmbnav-ia-sendbtn {
    position: static !important;
    flex-shrink: 0 !important;
}
/* ── UTM badge abaixo do header ── */
#vm2-sofia-utm {
    background: #f5f3ff;
    padding: 4px 16px;
    font-size: 11px;
    color: #7c3aed;
    text-align: center;
    letter-spacing: .3px;
}
</style>
    <?php
}

function vm2_sofia_landing_footer() {
    ?>
<script>
(function(){
    // 1. Marcar body para CSS
    document.body.classList.add('sofia-landing');

    // 2. Capturar UTMs da URL
    var params = new URLSearchParams(window.location.search);
    var utmKeys = ['utm_source','utm_medium','utm_campaign','utm_content','utm_term'];
    var utms = {};
    var parts = [];
    utmKeys.forEach(function(k){ var v=params.get(k); if(v){utms[k]=v; parts.push(v);} });
    window._vm2_sofia_utms = utms;

    // 3. Injetar UTMs + canal_origem no endpoint que o vmbnav já usa
    function patchEndpoint() {
        if (typeof SOFIA_ENDPOINT === 'undefined') { setTimeout(patchEndpoint, 100); return; }
        try {
            var ep = new URL(SOFIA_ENDPOINT);
            utmKeys.forEach(function(k){ if(utms[k]) ep.searchParams.set(k, utms[k]); });
            ep.searchParams.set('canal_origem', 'sofia_landing');
            SOFIA_ENDPOINT = ep.toString();
        } catch(e){}
    }
    patchEndpoint();

    // 4. Mostrar badge UTM dentro do painel
    if (parts.length) {
        var badge = document.createElement('div');
        badge.id = 'vm2-sofia-utm';
        badge.textContent = '📍 ' + parts.join(' · ');
        function insertBadge() {
            var panel = document.getElementById('vmbnav-ia-panel');
            if (!panel) { setTimeout(insertBadge, 150); return; }
            var first = panel.children[0];
            if (first) panel.insertBefore(badge, first.nextSibling);
            else panel.appendChild(badge);
        }
        insertBadge();
    }

    // 5. Auto-abrir o modal SofIA
    function tryOpen() {
        if (typeof vmbnavOpenIA === 'function') {
            vmbnavOpenIA();
        } else {
            setTimeout(tryOpen, 150);
        }
    }
    if (document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', tryOpen);
    } else {
        tryOpen();
    }
})();
</script>
    <?php
}

// ══════════════════════════════════════════════════════════════════
// EMAIL — Enriquecimento de base e estatísticas (v1.5.89)
// ══════════════════════════════════════════════════════════════════

add_action('rest_api_init', function() {
    // GET /vm-crm-v2/v1/email/stats
    register_rest_route('vm-crm-v2/v1', '/email/stats', [
        'methods'             => 'GET',
        'callback'            => 'vm2_email_stats_rest',
        'permission_callback' => 'vm2_email_rest_auth',
    ]);
    // POST /vm-crm-v2/v1/email/enrich
    register_rest_route('vm-crm-v2/v1', '/email/enrich', [
        'methods'             => 'POST',
        'callback'            => 'vm2_email_enrich_rest',
        'permission_callback' => 'vm2_email_rest_auth',
    ]);
});
function vm2_email_rest_auth( $request ) {
    // Aceita WP admin autenticado (Application Password) OU Bearer token
    if ( current_user_can('manage_options') ) return true;
    $auth     = $request->get_header('Authorization') ?? '';
    $expected = 'Bearer ' . get_option('vm2_fin_sync_token', 'vm2fsync_9kqw3p7x');
    return ( $auth === $expected );
}

/**
 * GET /vm-crm-v2/v1/email/stats
 * Retorna cobertura de e-mail na base vm2_contacts.
 */
function vm2_email_stats_rest( $request ) {
    global $wpdb;
    $table = $wpdb->prefix . 'vm2_contacts';

    $total    = (int) $wpdb->get_var("SELECT COUNT(*) FROM $table");
    $com_email = (int) $wpdb->get_var("SELECT COUNT(*) FROM $table WHERE email != '' AND email IS NOT NULL");
    $sem_email = $total - $com_email;
    $pct       = $total > 0 ? round(($com_email / $total) * 100, 1) : 0;

    return rest_ensure_response([
        'total'      => $total,
        'com_email'  => $com_email,
        'sem_email'  => $sem_email,
        'cobertura'  => $pct . '%',
    ]);
}

/**
 * POST /vm-crm-v2/v1/email/enrich
 * Enriquece vm2_contacts.email a partir de:
 *   1. Todos os pedidos WooCommerce (HPOS: wp_wc_orders)
 *   2. Usuários WP com phone meta
 *
 * Só atualiza contatos que têm email vazio.
 * Retorna { updated, skipped, not_found_in_contacts }.
 */
function vm2_email_enrich_rest( $request ) {
    global $wpdb;
    @ini_set('memory_limit', '512M');
    @set_time_limit(300);

    $table    = $wpdb->prefix . 'vm2_contacts';
    $updated  = 0;
    $skipped  = 0; // já tinham e-mail
    $no_match = 0; // e-mail encontrado mas telefone não está na base

    // ── Mapa de telefones sem e-mail na base ──
    $sem_email = $wpdb->get_results(
        "SELECT phone FROM $table WHERE email = '' OR email IS NULL",
        ARRAY_A
    );
    if ( empty($sem_email) ) {
        return rest_ensure_response([
            'updated' => 0, 'skipped' => 0, 'not_found_in_contacts' => 0,
            'message' => 'Todos os contatos já têm e-mail.',
        ]);
    }
    $phones_sem_email = array_flip( array_column($sem_email, 'phone') );
    $total_sem        = count($phones_sem_email);

    // ── Fonte 1: Pedidos WooCommerce (HPOS) ──
    $wc_tbl = $wpdb->prefix . 'wc_orders';
    if ( $wpdb->get_var("SHOW TABLES LIKE '$wc_tbl'") === $wc_tbl ) {
        // Buscar em lotes de 500 para não explodir a memória
        $offset = 0;
        $batch  = 500;
        do {
            $rows = $wpdb->get_results( $wpdb->prepare(
                "SELECT billing_phone, billing_email
                 FROM $wc_tbl
                 WHERE billing_phone != '' AND billing_email != '' AND type = 'shop_order'
                 LIMIT %d OFFSET %d",
                $batch, $offset
            ), ARRAY_A );

            foreach ( $rows as $r ) {
                $p = vm2_normalize_phone( $r['billing_phone'] );
                if ( ! $p ) continue;
                if ( ! isset($phones_sem_email[$p]) ) continue; // já tem e-mail ou não está na base
                $email = sanitize_email( $r['billing_email'] );
                if ( ! is_email($email) ) continue;
                $wpdb->update( $table, ['email' => $email, 'updated_at' => current_time('mysql')], ['phone' => $p] );
                unset($phones_sem_email[$p]); // remove do mapa para não reprocessar
                $updated++;
            }
            $offset += $batch;
        } while ( count($rows) === $batch );
    }

    // ── Fonte 2: Usuários WP (billing_phone meta) ──
    $remaining = array_keys($phones_sem_email);
    if ( ! empty($remaining) ) {
        // Buscar usuários com billing_phone preenchido
        $wp_users = $wpdb->get_results(
            "SELECT u.user_email, pm.meta_value AS phone
             FROM {$wpdb->users} u
             INNER JOIN {$wpdb->usermeta} pm ON pm.user_id = u.ID AND pm.meta_key = 'billing_phone'
             WHERE pm.meta_value != '' AND u.user_email != ''",
            ARRAY_A
        );
        foreach ( $wp_users as $r ) {
            $p = vm2_normalize_phone( $r['phone'] );
            if ( ! $p || ! isset($phones_sem_email[$p]) ) continue;
            $email = sanitize_email( $r['user_email'] );
            if ( ! is_email($email) ) continue;
            $wpdb->update( $table, ['email' => $email, 'updated_at' => current_time('mysql')], ['phone' => $p] );
            unset($phones_sem_email[$p]);
            $updated++;
        }
    }

    // Contatos que não encontramos e-mail em nenhuma fonte
    $no_match = count($phones_sem_email);

    return rest_ensure_response([
        'success'              => true,
        'total_sem_email'      => $total_sem,
        'updated'              => $updated,
        'no_match'             => $no_match,
        'message'              => "Enriquecimento concluído: {$updated} contatos atualizados de {$total_sem} que estavam sem e-mail.",
    ]);
}
