<?php
/**
 * Network status + one-click onboarding for the Adnet network.
 *
 * Wraps the two off-site touchpoints a publisher needs — the discovery index
 * (Epistery Scan) and the ad matcher (Adnet Exchange) — so the whole flow
 * runs from the plugin: check standing, submit for indexing, register with
 * the matcher. Status reads are cached; network calls happen only when the
 * admin clicks Check & Connect, never on page load.
 *
 * @package Geistm_AI_Discovery
 */

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

/**
 * Talks to the discovery index and the ad matcher on the admin's behalf.
 */
class Geistm_Network {

    /** Discovery index (Epistery Scan). Filterable via `geistm_scan_url`. */
    const SCAN_URL = 'https://epistery.com/scan';

    /** Transient key for the cached status snapshot. */
    const CACHE_KEY = 'geistm_network_status';

    /**
     * This site's domain as the network sees it.
     *
     * @return string Host name.
     */
    public static function domain() {
        return (string) wp_parse_url( home_url(), PHP_URL_HOST );
    }

    /**
     * Discovery index base URL.
     *
     * @return string URL without trailing slash.
     */
    public static function scan_url() {
        return untrailingslashit( apply_filters( 'geistm_scan_url', self::SCAN_URL ) );
    }

    /**
     * Matcher base URL — the Exchange mounts under the configured Adnet host.
     *
     * @return string URL without trailing slash.
     */
    public static function exchange_url() {
        $host = get_option( 'geistm_adnet_host', 'https://adnet.geistm.com' );
        return untrailingslashit( $host ) . '/exchange';
    }

    /**
     * The cached status snapshot, if one exists. Never triggers network calls.
     *
     * @return array|null Status array, or null when never checked / expired.
     */
    public static function cached() {
        $status = get_transient( self::CACHE_KEY );
        return is_array( $status ) ? $status : null;
    }

    /**
     * Fetch fresh status from the index and the matcher, and cache it.
     *
     * @return array Status snapshot.
     */
    public static function refresh() {
        $domain = self::domain();
        $status = array(
            'domain'    => $domain,
            'scan'      => self::fetch_scan( $domain ),
            'exchange'  => self::fetch_exchange( $domain ),
            'dns'       => self::check_dns( $domain ),
            'checkedAt' => gmdate( 'c' ),
        );
        set_transient( self::CACHE_KEY, $status, 10 * MINUTE_IN_SECONDS );
        return $status;
    }

    /**
     * One-click onboarding: submit to the discovery index, request a fresh
     * review of the current manifest, and register with the matcher. All
     * calls are idempotent — safe to click repeatedly.
     *
     * @return array Fresh status snapshot after connecting.
     */
    public static function connect() {
        $domain = self::domain();
        $json   = array(
            'timeout' => 10,
            'headers' => array( 'Content-Type' => 'application/json' ),
            'body'    => wp_json_encode( array( 'domain' => $domain ) ),
        );

        // Matcher registration first — a match read registers the domain (the
        // Exchange auto-submits unknown domains into its pipeline), and the
        // discovery calls below can be slow (a re-check crawls the site), so
        // the most important write must not depend on them finishing.
        wp_remote_get( self::exchange_url() . '/api/match/' . rawurlencode( $domain ), array( 'timeout' => 15 ) );

        // Submit covers a never-seen domain; check re-verifies a known one.
        wp_remote_post( self::scan_url() . '/api/discovery', $json );
        wp_remote_post( self::scan_url() . '/api/discovery/check', $json );

        return self::refresh();
    }

    /**
     * The DNS TXT record that verifies domain ownership to the network.
     *
     * @param string $domain The site domain.
     * @return array { name, value } of the record to create.
     */
    public static function dns_record( $domain ) {
        return array(
            'name'  => '_ai.' . $domain,
            'value' => 'v=aid1 host=' . $domain,
        );
    }

    /**
     * Whether a set of TXT records contains the verification record.
     *
     * @param array $records Records as returned by dns_get_record().
     * @return bool
     */
    public static function txt_present( $records ) {
        foreach ( (array) $records as $record ) {
            $txt = is_array( $record ) ? ( $record['txt'] ?? '' ) : (string) $record;
            if ( false !== stripos( $txt, 'v=aid1' ) ) {
                return true;
            }
        }
        return false;
    }

    /**
     * Reduce a Scan entity response to the facts the status panel shows.
     *
     * @param array $body Decoded /api/discovery/{domain} response.
     * @return array Status fragment.
     */
    public static function parse_scan_entity( $body ) {
        $signals = isset( $body['entity']['metadata']['signals'] ) && is_array( $body['entity']['metadata']['signals'] )
            ? $body['entity']['metadata']['signals']
            : array();

        return array(
            'reachable'   => true,
            'indexed'     => ! empty( $body['entity'] ),
            'signed'      => ! empty( $signals['selfSigned']['present'] ),
            'hashValid'   => ! empty( $signals['hashValid']['present'] ),
            'dnsVerified' => ! empty( $signals['dnsVerified']['present'] ),
        );
    }

    /**
     * Reduce a matcher response to the facts the status panel shows.
     *
     * @param array $body Decoded /api/match/{domain} response.
     * @return array Status fragment.
     */
    public static function parse_exchange_response( $body ) {
        $matches = isset( $body['matches'] ) && is_array( $body['matches'] ) ? count( $body['matches'] ) : 0;
        return array(
            'reachable'  => true,
            'registered' => true,
            'matches'    => isset( $body['count'] ) ? intval( $body['count'] ) : $matches,
            'coldStart'  => ! empty( $body['coldStart'] ),
        );
    }

    /**
     * Query the discovery index for this domain's standing.
     *
     * @param string $domain The site domain.
     * @return array Status fragment.
     */
    private static function fetch_scan( $domain ) {
        $response = wp_remote_get( self::scan_url() . '/api/discovery/' . rawurlencode( $domain ), array( 'timeout' => 10 ) );
        if ( is_wp_error( $response ) ) {
            return array( 'reachable' => false );
        }
        $code = wp_remote_retrieve_response_code( $response );
        if ( 404 === $code ) {
            return array(
                'reachable' => true,
                'indexed'   => false,
            );
        }
        if ( 200 !== $code ) {
            return array( 'reachable' => false );
        }
        $body = json_decode( wp_remote_retrieve_body( $response ), true );
        return self::parse_scan_entity( is_array( $body ) ? $body : array() );
    }

    /**
     * Query the matcher for this domain's match rows (registers as a side effect).
     *
     * @param string $domain The site domain.
     * @return array Status fragment.
     */
    private static function fetch_exchange( $domain ) {
        $response = wp_remote_get( self::exchange_url() . '/api/match/' . rawurlencode( $domain ), array( 'timeout' => 10 ) );
        if ( is_wp_error( $response ) || 200 !== wp_remote_retrieve_response_code( $response ) ) {
            return array( 'reachable' => false );
        }
        $body = json_decode( wp_remote_retrieve_body( $response ), true );
        return self::parse_exchange_response( is_array( $body ) ? $body : array() );
    }

    /**
     * Live DNS check for the verification record.
     *
     * @param string $domain The site domain.
     * @return array Status fragment.
     */
    private static function check_dns( $domain ) {
        if ( ! function_exists( 'dns_get_record' ) ) {
            return array( 'checked' => false );
        }
        $record  = self::dns_record( $domain );
        $records = @dns_get_record( $record['name'], DNS_TXT ); // phpcs:ignore WordPress.PHP.NoSilencedErrors.Discouraged -- dns_get_record warns on lookup failure.
        return array(
            'checked' => true,
            'present' => self::txt_present( $records ),
        );
    }
}