<?php
/**
 * QBWS_Admin — admin menu + settings screen + manual trigger AJAX handlers.
 * Mirrors the "QB Mapping & Sync" screen from the OC admin (QB Product
 * Mapping / Product Sync / Customer Sync buttons),
 * plus new tabs this plugin needs: Settings (OAuth connect), Conflicts
 * (manual review queue), and the Historical Import progress bar.
 */

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

// phpcs:disable WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- This plugin reads/writes only its own custom tables (live sync state), which must never be served from an object cache.

class QBWS_Admin
{
    public static function init(): void
    {
        add_action('admin_menu', [__CLASS__, 'register_menu']);
        add_action('admin_post_qbws_save_settings', [__CLASS__, 'save_settings']);
        add_action('admin_post_qbws_download_pdf', [__CLASS__, 'download_pdf']);
        add_action('admin_post_qbws_export_customers', [__CLASS__, 'export_customers_csv']);
        add_action('wp_ajax_qbws_run_sync', [__CLASS__, 'ajax_run_sync']);
        add_action('wp_ajax_qbws_start_historical_import', [__CLASS__, 'ajax_start_historical_import']);
        add_action('wp_ajax_qbws_historical_import_status', [__CLASS__, 'ajax_historical_import_status']);
        add_action('wp_ajax_qbws_resolve_conflict', [__CLASS__, 'ajax_resolve_conflict']);
        add_action('wp_ajax_qbws_update_order_in_qb', [__CLASS__, 'ajax_update_order_in_qb']);
        add_action('wp_ajax_qbws_update_product_in_qb', [__CLASS__, 'ajax_update_product_in_qb']);
        add_action('wp_ajax_qbws_update_customer_in_qb', [__CLASS__, 'ajax_update_customer_in_qb']);

        // ── Order list "QBO Status" column — both legacy (post-based) and
        // HPOS (High-Performance Order Storage) admin order screens.
        add_filter('manage_edit-shop_order_columns', [__CLASS__, 'add_order_column']);
        add_action('manage_shop_order_posts_custom_column', [__CLASS__, 'render_order_column_legacy'], 10, 2);
        add_filter('manage_woocommerce_page_wc-orders_columns', [__CLASS__, 'add_order_column']);
        add_action('manage_woocommerce_page_wc-orders_custom_column', [__CLASS__, 'render_order_column_hpos'], 10, 2);

        // ── "QuickBooks Status" meta box on the single order edit screen.
        add_action('add_meta_boxes', [__CLASS__, 'add_order_meta_box']);

        // ── Product list "QBO Status" column + product edit meta box.
        // Products stay regular posts even when HPOS is on (HPOS only
        // moves orders), so — unlike the order column above — one set of
        // hooks covers this.
        add_filter('manage_product_posts_columns', [__CLASS__, 'add_product_column']);
        add_action('manage_product_posts_custom_column', [__CLASS__, 'render_product_column'], 10, 2);
        add_action('add_meta_boxes_product', [__CLASS__, 'add_product_meta_box']);

        // ── Customer "QBO Status" column on the Users list + a status
        // section on each customer's profile edit screen.
        add_filter('manage_users_columns', [__CLASS__, 'add_user_column']);
        add_filter('manage_users_custom_column', [__CLASS__, 'render_user_column'], 10, 3);
        add_action('show_user_profile', [__CLASS__, 'render_user_profile_section']);
        add_action('edit_user_profile', [__CLASS__, 'render_user_profile_section']);

        add_action('admin_enqueue_scripts', [__CLASS__, 'print_status_column_css']);
    }

    /**
     * WordPress/WooCommerce's list tables give every column a share of a
     * fixed-layout table with no width reserved for columns they don't
     * know about. Without an explicit width, a narrow custom column like
     * "QBO Status" gets squeezed down to almost nothing and the browser
     * wraps its header text one letter per line — exactly what happened
     * on the Products screen. This reserves enough room on every screen
     * this plugin adds the column to (orders, products, users).
     */
    public static function print_status_column_css(): void
    {
        self::add_inline_css('qbws-status-column', '.column-qbws_status { width: 110px !important; white-space: nowrap; }');
    }

    /** Attaches inline JS to a (source-less) footer script handle — the WP-approved way to emit small page scripts. */
    public static function add_inline_js(string $handle, string $js): void
    {
        wp_register_script($handle, false, [], QBWS_VERSION, true);
        wp_enqueue_script($handle);
        wp_add_inline_script($handle, $js);
    }

    /** Attaches inline CSS to a (source-less) style handle. */
    public static function add_inline_css(string $handle, string $css): void
    {
        wp_register_style($handle, false, [], QBWS_VERSION);
        wp_enqueue_style($handle);
        wp_add_inline_style($handle, $css);
    }

    public static function register_menu(): void
    {
        add_menu_page(__('Ledgerbridge Sync', 'ledgerbridge-sync'), __('QuickBooks Sync', 'ledgerbridge-sync'), 'manage_woocommerce', 'ledgerbridge-sync', [__CLASS__, 'render_dashboard'], 'dashicons-update');
        add_submenu_page('ledgerbridge-sync', __('Dashboard', 'ledgerbridge-sync'), __('Dashboard', 'ledgerbridge-sync'), 'manage_woocommerce', 'ledgerbridge-sync', [__CLASS__, 'render_dashboard']);
        add_submenu_page('ledgerbridge-sync', __('Settings', 'ledgerbridge-sync'), __('Settings', 'ledgerbridge-sync'), 'manage_woocommerce', 'ledgerbridge-sync-settings', [__CLASS__, 'render_settings']);
        add_submenu_page('ledgerbridge-sync', __('Conflicts', 'ledgerbridge-sync'), __('Conflicts', 'ledgerbridge-sync'), 'manage_woocommerce', 'ledgerbridge-sync-conflicts', [__CLASS__, 'render_conflicts']);
        add_submenu_page('ledgerbridge-sync', __('Logs', 'ledgerbridge-sync'), __('Logs', 'ledgerbridge-sync'), 'manage_woocommerce', 'ledgerbridge-sync-logs', [__CLASS__, 'render_logs']);
    }

    // ═══════════════════════ SCREENS ═══════════════════════════════════

    public static function render_dashboard(): void
    {
        $connected = (new QBWS_Token_Manager())->is_connected();
        include __DIR__ . '/views/dashboard.php';
    }

    public static function render_settings(): void
    {
        $settings = QBWS_Config::all();
        $authorizeUrl = QBWS_Config::get('client_id') ? QBWS_REST_API::build_authorize_url() : null;
        $connected = (new QBWS_Token_Manager())->is_connected();
        include __DIR__ . '/views/settings.php';
    }

    public static function render_conflicts(): void
    {
        global $wpdb;
        // phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching, WordPress.DB.PreparedSQL.InterpolatedNotPrepared -- plugin's own table; name is $wpdb->prefix + constant.
        $conflicts = $wpdb->get_results(
            $wpdb->prepare("SELECT * FROM {$wpdb->prefix}qbws_order_map WHERE sync_status = %s ORDER BY updated_at DESC LIMIT %d", 'conflict', 100),
            ARRAY_A
        );
        include __DIR__ . '/views/conflicts.php';
    }

    public static function render_logs(): void
    {
        global $wpdb;
        // phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching, WordPress.DB.PreparedSQL.InterpolatedNotPrepared -- plugin's own table; name is $wpdb->prefix + constant.
        $logs = $wpdb->get_results(
            $wpdb->prepare("SELECT * FROM {$wpdb->prefix}qbws_sync_log ORDER BY id DESC LIMIT %d", 200),
            ARRAY_A
        );
        include __DIR__ . '/views/logs.php';
    }

    // ═══════════════════════ ACTIONS ═══════════════════════════════════

    public static function save_settings(): void
    {
        if (!current_user_can('manage_woocommerce') || !check_admin_referer('qbws_save_settings')) {
            wp_die(esc_html__('Unauthorized', 'ledgerbridge-sync'));
        }

        $environment = isset($_POST['environment']) ? sanitize_key(wp_unslash($_POST['environment'])) : 'production';
        $environment = in_array($environment, ['production', 'sandbox'], true) ? $environment : 'production';

        $values = [
            'client_id'            => sanitize_text_field(wp_unslash($_POST['client_id'] ?? '')),
            'realm_id'             => sanitize_text_field(wp_unslash($_POST['realm_id'] ?? '')),
            'environment'          => $environment,
            'order_sync_direction' => self::sanitize_direction(sanitize_key(wp_unslash($_POST['order_sync_direction'] ?? 'two_way'))),
            'product_sync_direction'  => self::sanitize_direction(sanitize_key(wp_unslash($_POST['product_sync_direction'] ?? 'two_way'))),
            'customer_sync_direction' => self::sanitize_direction(sanitize_key(wp_unslash($_POST['customer_sync_direction'] ?? 'two_way'))),
            'order_doc_type'       => sanitize_text_field(wp_unslash($_POST['order_doc_type'] ?? 'Invoice')),
            'conflict_strategy'    => sanitize_text_field(wp_unslash($_POST['conflict_strategy'] ?? 'last_modified_wins')),
            'default_currency'     => sanitize_text_field(wp_unslash($_POST['default_currency'] ?? 'USD')),
            'cache_ttl_seconds'    => absint(wp_unslash($_POST['cache_ttl_seconds'] ?? 1800)),
            'delete_data_on_uninstall' => !empty($_POST['delete_data_on_uninstall']),
            'sync_matrix'          => self::sanitize_sync_matrix(),
        ];

        QBWS_Config::update($values);

        if (!empty($_POST['client_secret'])) {
            QBWS_Config::set_secret('client_secret', sanitize_text_field(wp_unslash($_POST['client_secret'])));
        }
        if (!empty($_POST['webhook_verifier'])) {
            QBWS_Config::set_secret('webhook_verifier', sanitize_text_field(wp_unslash($_POST['webhook_verifier'])));
        }

        wp_safe_redirect(add_query_arg('saved', '1', admin_url('admin.php?page=ledgerbridge-sync-settings')));
        exit;
    }

    /** Validates a *_sync_direction value against the three allowed options, defaulting to two_way. */
    private static function sanitize_direction($value): string
    {
        return in_array($value, ['qb_to_woo', 'woo_to_qb', 'two_way'], true) ? $value : 'two_way';
    }

    /** Builds a clean sync_matrix array from the submitted form, ignoring anything outside the known entity list. */
    private static function sanitize_sync_matrix(): array
    {
        check_admin_referer('qbws_save_settings');

        $matrix = [];
        foreach (QBWS_Config::SYNC_MATRIX_ENTITIES as $direction => $entities) {
            foreach ($entities as $entity) {
                $interval = isset($_POST['sync_matrix'][$direction][$entity]['interval'])
                    ? absint(wp_unslash($_POST['sync_matrix'][$direction][$entity]['interval']))
                    : 15;
                $matrix[$direction][$entity] = [
                    'enabled'  => !empty($_POST['sync_matrix'][$direction][$entity]['enabled']),
                    'interval' => max(15, $interval), // 15 min floor — see Settings screen's dropdown
                ];
            }
        }
        return $matrix;
    }

    public static function ajax_run_sync(): void
    {
        check_ajax_referer('qbws_admin_nonce');
        if (!current_user_can('manage_woocommerce')) wp_send_json_error('Unauthorized', 403);

        $type = sanitize_text_field(wp_unslash($_POST['sync_type'] ?? ''));

        try {
            switch ($type) {
                case 'products':  $result = (new QBWS_Sync_Products())->run(true); break;
                case 'customers': $result = (new QBWS_Sync_Customers())->pull_from_qb(true); break;
                case 'orders':    QBWS_Sync_Orders_Inbound::poll_qb_for_changes(); $result = ['queued' => true]; break;
                default: wp_send_json_error('Unknown sync type'); return;
            }
            wp_send_json_success($result);
        } catch (\Throwable $e) {
            QBWS_Logger::error('ADMIN', "Manual sync '{$type}' failed: " . $e->getMessage());
            wp_send_json_error($e->getMessage());
        }
    }

    public static function ajax_start_historical_import(): void
    {
        check_ajax_referer('qbws_admin_nonce');
        if (!current_user_can('manage_woocommerce')) wp_send_json_error('Unauthorized', 403);

        QBWS_Historical_Import::start();
        wp_send_json_success(QBWS_Historical_Import::get_state());
    }

    public static function ajax_historical_import_status(): void
    {
        check_ajax_referer('qbws_admin_nonce');
        if (!current_user_can('manage_woocommerce')) wp_send_json_error('Unauthorized', 403);
        wp_send_json_success(QBWS_Historical_Import::get_state());
    }

    public static function ajax_resolve_conflict(): void
    {
        check_ajax_referer('qbws_admin_nonce');
        if (!current_user_can('manage_woocommerce')) wp_send_json_error('Unauthorized', 403);

        $wcOrderId = absint(wp_unslash($_POST['order_id'] ?? 0));
        $keep      = sanitize_text_field(wp_unslash($_POST['keep'] ?? '')); // 'woo' or 'qb'

        $mapRow = QBWS_Mapper::order_map_row($wcOrderId);
        if (!$mapRow) wp_send_json_error('No mapping found for that order');

        if ($keep === 'woo') {
            (new QBWS_Sync_Orders_Outbound())->push_order($wcOrderId);
        } elseif ($keep === 'qb') {
            (new QBWS_Sync_Orders_Inbound())->sync_single_from_qb($mapRow['qb_txn_id'], $mapRow['qb_txn_type']);
        } else {
            wp_send_json_error('keep must be "woo" or "qb"');
            return;
        }

        global $wpdb;
        $wpdb->update($wpdb->prefix . 'qbws_order_map', ['sync_status' => 'synced'], ['wc_order_id' => $wcOrderId]);

        wp_send_json_success();
    }

    /** Called from the "Update in QuickBooks" button in the order meta box. */
    public static function ajax_update_order_in_qb(): void
    {
        check_ajax_referer('qbws_admin_nonce');
        if (!current_user_can('manage_woocommerce')) wp_send_json_error('Unauthorized', 403);

        $orderId = absint(wp_unslash($_POST['order_id'] ?? 0));
        if (!$orderId) wp_send_json_error('Missing order id');

        try {
            $result = (new QBWS_Sync_Orders_Outbound())->push_order($orderId);

            if ($result === 'conflict') {
                wp_send_json_error('This order has a conflicting change in QuickBooks — resolve it from the Conflicts tab first.');
            }

            wp_send_json_success(['result' => $result]);
        } catch (\Throwable $e) {
            QBWS_Logger::error('ADMIN', "Manual order push failed for #{$orderId}: " . $e->getMessage());
            wp_send_json_error($e->getMessage());
        }
    }

    /** Streams the QB-generated PDF for an order's Invoice/SalesReceipt. */
    public static function download_pdf(): void
    {
        $orderId = absint(wp_unslash($_GET['order_id'] ?? 0));

        if (!$orderId || !check_admin_referer('qbws_download_pdf_' . $orderId)) {
            wp_die(esc_html__('Invalid request.', 'ledgerbridge-sync'));
        }
        if (!current_user_can('manage_woocommerce')) {
            wp_die(esc_html__('Unauthorized.', 'ledgerbridge-sync'));
        }

        $map = QBWS_Mapper::order_map_row($orderId);
        if (!$map || empty($map['qb_txn_id'])) {
            wp_die(esc_html__('This order has not been synced to QuickBooks yet.', 'ledgerbridge-sync'));
        }

        $docType  = $map['qb_txn_type'] ?: 'Invoice';
        $endpoint = $docType === 'SalesReceipt' ? 'salesreceipt' : 'invoice';
        $realm    = QBWS_Config::get('realm_id');

        $pdf = (new QBWS_Api_Client())->get_raw(
            "v3/company/{$realm}/{$endpoint}/{$map['qb_txn_id']}/pdf",
            ['Accept' => 'application/pdf']
        );

        if (!$pdf || empty($pdf['body'])) {
            wp_die(esc_html__('Could not fetch the PDF from QuickBooks — check the Logs tab for details.', 'ledgerbridge-sync'));
        }

        nocache_headers();
        header('Content-Type: application/pdf');
        header('Content-Disposition: attachment; filename="order-' . $orderId . '.pdf"');
        header('Content-Length: ' . strlen($pdf['body']));
        echo $pdf['body']; // phpcs:ignore WordPress.Security.EscapeOutput.OutputNotEscaped -- raw binary PDF, not HTML output
        exit;
    }

    /**
     * Standalone CSV export of every WordPress user with their QuickBooks
     * sync status — built entirely from this plugin's own tables rather
     * than hooking into WooCommerce Analytics' Customers report. See the
     * README's "Customer QBO status" section for why: that report's
     * on-screen table has no supported way for a plugin to add a column
     * (open WooCommerce feature request), and the one semi-documented
     * way to add a CSV-export-only column requires guessing at that
     * report's internal SQL table aliases — getting it wrong risks
     * breaking the whole report for something we can build far more
     * reliably ourselves with a query we fully control.
     */
    public static function export_customers_csv(): void
    {
        if (!check_admin_referer('qbws_export_customers')) {
            wp_die(esc_html__('Invalid request.', 'ledgerbridge-sync'));
        }
        if (!current_user_can('manage_woocommerce')) {
            wp_die(esc_html__('Unauthorized.', 'ledgerbridge-sync'));
        }

        // Every WordPress user account, not just ones with the 'customer'
        // role — mirrors what actually shows in WooCommerce's own
        // Analytics Customers report (which includes admin-placed test
        // orders etc. too), so the numbers here match what you'd expect
        // to see there.
        $users = get_users(['orderby' => 'display_name', 'order' => 'ASC']);

        nocache_headers();
        header('Content-Type: text/csv; charset=utf-8');
        header('Content-Disposition: attachment; filename="customers-qbo-status-' . gmdate('Y-m-d') . '.csv"');

        // phpcs:disable WordPress.Security.EscapeOutput.OutputNotEscaped -- CSV download; every field is quoted/escaped by csv_line().
        echo self::csv_line(['User ID', 'Name', 'Username', 'Email', 'Registered', 'QBO Status', 'QB Customer ID']);

        foreach ($users as $user) {
            $qbId = QBWS_Mapper::qb_id_by_customer($user->ID);
            echo self::csv_line([
                $user->ID,
                $user->display_name,
                $user->user_login,
                $user->user_email,
                $user->user_registered,
                $qbId ? 'Synced' : 'Not Synced',
                $qbId ?: '',
            ]);
        }
        // phpcs:enable WordPress.Security.EscapeOutput.OutputNotEscaped
        exit;
    }

    /**
     * Builds one RFC 4180 CSV line. Fields that start with a spreadsheet
     * formula character are prefixed with an apostrophe so a malicious
     * display name can't execute as a formula when the file is opened.
     */
    private static function csv_line(array $fields): string
    {
        $cells = [];
        foreach ($fields as $field) {
            $value = (string) $field;
            if ($value !== '' && strpbrk($value[0], "=+-@\t\r") !== false) {
                $value = "'" . $value;
            }
            $cells[] = '"' . str_replace('"', '""', $value) . '"';
        }
        return implode(',', $cells) . "\r\n";
    }

    // ═══════════════════════ ORDER LIST COLUMN ═════════════════════════

    public static function add_order_column(array $columns): array
    {
        if (isset($columns['qbws_status'])) return $columns; // already added (both filters can fire in some WC versions)

        $new = [];
        foreach ($columns as $key => $label) {
            $new[$key] = $label;
            if ($key === 'order_total') {
                $new['qbws_status'] = __('QBO Status', 'ledgerbridge-sync');
            }
        }
        if (!isset($new['qbws_status'])) {
            $new['qbws_status'] = __('QBO Status', 'ledgerbridge-sync'); // fallback: append if 'order_total' wasn't present
        }
        return $new;
    }

    /** Legacy (post-based) orders screen — $item is the WP post ID. */
    public static function render_order_column_legacy(string $column, $item): void
    {
        if ($column !== 'qbws_status') return;
        self::render_status_badge((int) $item);
    }

    /** HPOS orders screen — $item is a WC_Order object. */
    public static function render_order_column_hpos(string $column, $item): void
    {
        if ($column !== 'qbws_status') return;
        $orderId = is_object($item) && method_exists($item, 'get_id') ? $item->get_id() : (int) $item;
        self::render_status_badge($orderId);
    }

    private static function render_status_badge(int $orderId): void
    {
        $map = QBWS_Mapper::order_map_row($orderId);

        $status = 'not_synced';
        if ($map) {
            if (($map['sync_status'] ?? '') === 'conflict') $status = 'conflict';
            elseif (!empty($map['qb_txn_id'])) $status = 'synced';
        }

        $styles = [
            'synced'     => ['#d5f5e3', '#1e7e34', __('Synced', 'ledgerbridge-sync')],
            'conflict'   => ['#fdf3d0', '#8a6d3b', __('Conflict', 'ledgerbridge-sync')],
            'not_synced' => ['#fbdada', '#a94442', __('Not Synced', 'ledgerbridge-sync')],
        ][$status];

        printf(
            '<span style="display:inline-block;padding:3px 10px;border-radius:12px;font-size:11px;font-weight:600;line-height:1.4;background:%s;color:%s;">%s</span>',
            esc_attr($styles[0]), esc_attr($styles[1]), esc_html($styles[2])
        );
    }

    // ═══════════════════════ ORDER META BOX ════════════════════════════

    public static function add_order_meta_box(): void
    {
        $screen = class_exists('\Automattic\WooCommerce\Utilities\OrderUtil')
            ? wc_get_page_screen_id('shop-order')
            : 'shop_order';

        add_meta_box(
            'qbws_order_status',
            __('QuickBooks Status', 'ledgerbridge-sync'),
            [__CLASS__, 'render_order_meta_box'],
            $screen,
            'side',
            'default'
        );
    }

    public static function render_order_meta_box($post_or_order): void
    {
        $order = ($post_or_order instanceof WC_Order)
            ? $post_or_order
            : wc_get_order(is_object($post_or_order) ? $post_or_order->ID : $post_or_order);

        if (!$order) {
            echo '<p>' . esc_html__('Order not found.', 'ledgerbridge-sync') . '</p>';
            return;
        }

        $orderId = $order->get_id();
        $map = QBWS_Mapper::order_map_row($orderId);

        $status = 'not_synced';
        if ($map) {
            if (($map['sync_status'] ?? '') === 'conflict') $status = 'conflict';
            elseif (!empty($map['qb_txn_id'])) $status = 'synced';
        }

        $nonce = wp_create_nonce('qbws_admin_nonce');
        $ajaxUrl = admin_url('admin-ajax.php');

        include __DIR__ . '/views/order-meta-box.php';
    }

    private static function qb_view_url(array $map): string
    {
        $docType = $map['qb_txn_type'] ?? 'Invoice';
        $path = $docType === 'SalesReceipt' ? 'salesreceipt' : 'invoice';
        $base = QBWS_Config::get('environment') === 'sandbox'
            ? 'https://sandbox.qbo.intuit.com'
            : 'https://qbo.intuit.com';
        return "{$base}/app/{$path}?txnId=" . rawurlencode($map['qb_txn_id']);
    }

    /** Renders a <select> of common intervals (in minutes) for the Automatic Sync Settings screen. */
    private static function interval_kses(): array
    {
        return ['select' => ['name' => true], 'option' => ['value' => true, 'selected' => true]];
    }

    private static function interval_select(string $name, int $currentMinutes): string
    {
        // 15 minutes is the floor everywhere in this matrix — see
        // QBWS_Config::sync_interval_minutes() and the save-time
        // sanitizer, both of which enforce it too.
        $options = [
            15   => '15 minutes',
            30   => '30 minutes',
            60   => '1 hour',
            360  => '6 hours',
            720  => '12 hours',
            1440 => '24 hours',
        ];

        // An older install may still have a sub-15-minute value stored
        // from before this floor existed — round it up for display
        // rather than silently offering an option that's no longer valid.
        if ($currentMinutes < 15) $currentMinutes = 15;

        if (!isset($options[$currentMinutes])) {
            $options[$currentMinutes] = $currentMinutes . ' minutes'; // preserve a custom stored value
            ksort($options);
        }

        $html = '<select name="' . esc_attr($name) . '">';
        foreach ($options as $minutes => $label) {
            $html .= '<option value="' . esc_attr($minutes) . '"' . selected($currentMinutes, $minutes, false) . '>' . esc_html($label) . '</option>';
        }
        $html .= '</select>';

        return $html;
    }

    // ═══════════════════════ PRODUCT LIST COLUMN + META BOX ═══════════════

    public static function add_product_column(array $columns): array
    {
        if (isset($columns['qbws_status'])) return $columns;

        $new = [];
        foreach ($columns as $key => $label) {
            $new[$key] = $label;
            if ($key === 'price') {
                $new['qbws_status'] = __('QBO Status', 'ledgerbridge-sync');
            }
        }
        if (!isset($new['qbws_status'])) {
            $new['qbws_status'] = __('QBO Status', 'ledgerbridge-sync'); // fallback: append if 'price' column wasn't present
        }
        return $new;
    }

    public static function render_product_column(string $column, int $postId): void
    {
        if ($column !== 'qbws_status') return;

        $qbId = QBWS_Mapper::qb_id_by_product($postId, 0);
        self::render_simple_status_badge((bool) $qbId);
    }

    public static function add_product_meta_box(): void
    {
        add_meta_box(
            'qbws_product_status',
            __('QuickBooks Status', 'ledgerbridge-sync'),
            [__CLASS__, 'render_product_meta_box'],
            'product',
            'side',
            'default'
        );
    }

    public static function render_product_meta_box($post): void
    {
        $productId = $post->ID;
        $product = wc_get_product($productId);
        $qbId = QBWS_Mapper::qb_id_by_product($productId, 0);

        $variationSummary = null;
        if ($product && $product->is_type('variable')) {
            $variationSummary = self::variation_sync_summary($productId, $product->get_children());
        }

        $nonce = wp_create_nonce('qbws_admin_nonce');
        $ajaxUrl = admin_url('admin-ajax.php');

        include __DIR__ . '/views/product-meta-box.php';
    }

    /** Counts how many of a variable product's variations already have a QB mapping — one query for all of them, not one per variation. */
    private static function variation_sync_summary(int $productId, array $variationIds): array
    {
        $mapped = QBWS_Mapper::qb_ids_for_variations($productId, $variationIds);
        return ['synced' => count($mapped), 'total' => count($variationIds)];
    }

    public static function ajax_update_product_in_qb(): void
    {
        check_ajax_referer('qbws_admin_nonce');
        if (!current_user_can('manage_woocommerce')) wp_send_json_error('Unauthorized', 403);

        $productId = absint(wp_unslash($_POST['product_id'] ?? 0));
        if (!$productId) wp_send_json_error('Missing product id');

        try {
            (new QBWS_Sync_Products())->push_to_qb($productId);
            wp_send_json_success();
        } catch (\Throwable $e) {
            QBWS_Logger::error('ADMIN', "Manual product push failed for #{$productId}: " . $e->getMessage());
            wp_send_json_error($e->getMessage());
        }
    }

    /**
     * QBO doesn't offer a stable single-item deep-link the way it does for
     * invoices (no equivalent of ?txnId=... for Items) — this links to the
     * Products and Services list instead, which is the closest honest
     * equivalent rather than a guessed URL that might not resolve.
     */
    private static function qb_products_list_url(): string
    {
        return QBWS_Config::get('environment') === 'sandbox'
            ? 'https://sandbox.qbo.intuit.com/app/products'
            : 'https://qbo.intuit.com/app/products';
    }

    // ═══════════════════════ CUSTOMER (USERS LIST) COLUMN + PROFILE ═══════

    public static function add_user_column(array $columns): array
    {
        if (isset($columns['qbws_status'])) return $columns;
        $columns['qbws_status'] = __('QBO Status', 'ledgerbridge-sync');
        return $columns;
    }

    public static function render_user_column($value, string $columnName, int $userId)
    {
        if ($columnName !== 'qbws_status') return $value;

        $qbId = QBWS_Mapper::qb_id_by_customer($userId);
        ob_start();
        self::render_simple_status_badge((bool) $qbId);
        return ob_get_clean();
    }

    public static function render_user_profile_section($user): void
    {
        if (!current_user_can('manage_woocommerce')) return; // this is sync/admin info, not something the customer themself needs on their own profile

        $userId = $user->ID;
        $qbId = QBWS_Mapper::qb_id_by_customer($userId);
        $nonce = wp_create_nonce('qbws_admin_nonce');
        $ajaxUrl = admin_url('admin-ajax.php');

        include __DIR__ . '/views/customer-status-section.php';
    }

    public static function ajax_update_customer_in_qb(): void
    {
        check_ajax_referer('qbws_admin_nonce');
        if (!current_user_can('manage_woocommerce')) wp_send_json_error('Unauthorized', 403);

        $userId = absint(wp_unslash($_POST['user_id'] ?? 0));
        if (!$userId) wp_send_json_error('Missing user id');

        try {
            (new QBWS_Sync_Customers())->push_to_qb($userId);
            wp_send_json_success();
        } catch (\Throwable $e) {
            QBWS_Logger::error('ADMIN', "Manual customer push failed for #{$userId}: " . $e->getMessage());
            wp_send_json_error($e->getMessage());
        }
    }

    private static function qb_customer_view_url(string $qbCustomerId): string
    {
        $base = QBWS_Config::get('environment') === 'sandbox'
            ? 'https://sandbox.qbo.intuit.com'
            : 'https://qbo.intuit.com';
        return "{$base}/app/customerdetail?nameId=" . rawurlencode($qbCustomerId);
    }

    // ═══════════════════════ SHARED BADGE RENDERER ═════════════════════

    /** Same visual style as the order status badge, but for the simpler product/customer Synced|Not Synced case (no 'conflict' state tracked for these two entity types). */
    private static function render_simple_status_badge(bool $isSynced): void
    {
        if ($isSynced) {
            printf(
                '<span style="display:inline-block;padding:3px 10px;border-radius:12px;font-size:11px;font-weight:600;line-height:1.4;background:%s;color:%s;">%s</span>',
                '#d5f5e3', '#1e7e34', esc_html__('Synced', 'ledgerbridge-sync')
            );
        } else {
            printf(
                '<span style="display:inline-block;padding:3px 10px;border-radius:12px;font-size:11px;font-weight:600;line-height:1.4;background:%s;color:%s;">%s</span>',
                '#fbdada', '#a94442', esc_html__('Not Synced', 'ledgerbridge-sync')
            );
        }
    }
}