<?php
/**
 * Tells AdvocateLoop this store is connected, so the AdvocateLoop dashboard
 * shows WooCommerce as connected.
 *
 * Three signals, each a small signed request (the base plugin's signing):
 *   activated    when this add-on is activated
 *   heartbeat    once a day while it's active (WordPress cron)
 *   deactivated  when this add-on is deactivated, or the site is disconnected
 *                or moved to another AdvocateLoop account
 * plus a check-in as soon as the site is connected.
 *
 * Connected means the add-on is activated; its settings switch doesn't
 * change that.
 *
 * Sent: the connector name, the signal, the site's host name and this
 * add-on's version. No customer or order data.
 *
 * Never blocks a page: heartbeats run from cron, and every request has a short
 * timeout. Failures are ignored; the next heartbeat tries again.
 *
 * @package AdvocateLoop\WooCommerce
 */

namespace AdvocateLoop\WooCommerce;

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

class Presence {

    /** Daily heartbeat cron hook. */
    const HOOK = 'advocate_loop_woo_presence';

    /** API path the signals go to. */
    const PATH = '/api/v1/integrations/presence';

    /**
     * Register hooks. Called once from the main plugin file on every load.
     */
    public static function register() {
        add_action(self::HOOK, [__CLASS__, 'heartbeat']);
        add_action('init', [__CLASS__, 'ensure_scheduled']);

        // The site was connected (or reconnected) to AdvocateLoop. The signing
        // secret is saved last, so check in right then (an admin action, like
        // activation); key and brand changes also queue a check-in as backup.
        add_action('add_option_advocate_loop_ss', [__CLASS__, 'connected_now']);
        add_action('update_option_advocate_loop_ss', [__CLASS__, 'connected_now']);
        foreach (['advocate_loop_api_key', 'advocate_loop_brand_id'] as $option) {
            add_action('add_option_' . $option, [__CLASS__, 'check_in_soon']);
            add_action('update_option_' . $option, [__CLASS__, 'check_in_soon']);
        }

        // The site is being disconnected, or moved to another brand: say so
        // while the current credentials still exist (these run before the change).
        add_action('delete_option', [__CLASS__, 'before_delete'], 10, 1);
        add_filter('pre_update_option_advocate_loop_brand_id', [__CLASS__, 'before_brand_change'], 10, 2);
    }

    /**
     * Keep the daily heartbeat scheduled. Covers updates from versions that
     * didn't have it (activation hooks don't run on update): the first
     * heartbeat goes out a few minutes after the update.
     */
    public static function ensure_scheduled() {
        if (!wp_next_scheduled(self::HOOK)) {
            wp_schedule_event(time() + 5 * MINUTE_IN_SECONDS, 'daily', self::HOOK);
        }
    }

    /** Run the next check-in in about a minute (from cron, off the page load). */
    public static function check_in_soon() {
        if (!wp_next_scheduled(self::HOOK, ['once'])) {
            wp_schedule_single_event(time() + MINUTE_IN_SECONDS, self::HOOK, ['once']);
        }
    }


    /** The signing secret was just saved: the site is connected, check in now. */
    public static function connected_now() {
        self::send_once('activated');
    }

    /**
     * Before the base plugin removes its connection.
     *
     * @param string $option Option about to be deleted.
     */
    public static function before_delete($option) {
        if (in_array($option, ['advocate_loop_api_key', 'advocate_loop_brand_id', 'advocate_loop_ss'], true)) {
            self::send_once('deactivated');
        }
    }

    /**
     * Before the site is pointed at a different brand: tell the old one.
     *
     * @param mixed $new New brand ID.
     * @param mixed $old Current brand ID.
     * @return mixed The new value, unchanged.
     */
    public static function before_brand_change($new, $old) {
        if (!empty($old) && (string) $new !== (string) $old) {
            self::send_once('deactivated');
        }
        return $new;
    }

    /** Send a signal at most once per request (a disconnect removes several options). */
    private static function send_once($event) {
        static $sent = [];
        if (!empty($sent[$event])) {
            return;
        }
        $sent[$event] = true;
        self::send($event);
    }

    /** Daily (and one-off) check-in. */
    public static function heartbeat() {
        self::send('heartbeat');
    }

    /** On activation: schedule the heartbeat and check in now. */
    public static function on_activation() {
        self::ensure_scheduled();
        self::send('activated');
    }

    /** On deactivation: stop the heartbeat and say so. */
    public static function on_deactivation() {
        wp_clear_scheduled_hook(self::HOOK);
        self::send('deactivated');
    }

    /**
     * Send one signal. Quietly does nothing when the base plugin isn't
     * connected yet, or can't sign (no signing secret).
     *
     * @param string $event activated | heartbeat | deactivated
     */
    public static function send($event) {
        if (!class_exists('\AdvocateLoop\Core\Signing')) {
            return;
        }
        if (!function_exists('advocate_loop_is_connected') || !advocate_loop_is_connected()) {
            return;
        }
        if (!get_option('advocate_loop_ss')) {
            return; // unsigned check-ins are refused; the next one will be signed
        }

        $host = wp_parse_url(home_url(), PHP_URL_HOST);

        \AdvocateLoop\Core\Signing::post(self::PATH, [
            'connector' => 'woocommerce',
            'event'     => $event,
            'enabled'   => true,
            'site'      => is_string($host) ? $host : '',
            'version'   => defined('ADVOCATE_LOOP_WOO_VERSION') ? ADVOCATE_LOOP_WOO_VERSION : '',
        ], [
            'timeout' => 5,
        ]);
    }
}