<?php
/*
 * Plugin Name: Canto
 * Version: 3.1.4
 * Plugin URI: https://www.canto.com/integrations/wordpress/
 * Description: Easily find and publish your brand and creative assets directly to wordpress without having to search through emails or folders, using digital asset management by Canto.
 * Author: Canto Inc
 * Author URI: https://www.canto.com/
 * Requires at least: 5.0
 * Tested up to: 7.0
 * License: GPLv2 or later
 * License URI: https://www.gnu.org/licenses/gpl-2.0.html
 *
 * Text Domain: canto
 * Domain Path: /lang/
 *
 * @package WordPress
 * @author Canto
 * @since 1.0.0
 */

if (!defined('ABSPATH')) {
    exit;
}

define('CANTO_FBC_PATH', plugin_dir_path(__FILE__));
define('CANTO_FBC_URL', plugin_dir_url(__FILE__));
define('CANTO_FBC_DIR', plugin_basename(__FILE__));
define('CANTO_WP_ABSPATH', ABSPATH);
define('CANTO_FBC_VERSION', '3.1.4');

// Load plugin class files
require_once 'includes/class-canto.php';
require_once 'includes/class-canto-settings.php';

// Load plugin libraries
require_once 'includes/lib/class-canto-admin-api.php';
require_once 'includes/lib/class-canto-media.php';
require_once 'includes/lib/class-canto-attachment.php';
require_once 'includes/lib/copy-media.php';
require_once 'includes/lib/detail.php';
require_once 'includes/lib/sizes.php';
require_once 'includes/lib/get.php';
require_once 'includes/lib/tree.php';

// Load advanced features safely with proper checks
if (function_exists('get_field') && file_exists(__DIR__ . '/includes/lib/class-canto-acf-integration.php')) {
    require_once 'includes/lib/class-canto-acf-integration.php';
}

if (file_exists(__DIR__ . '/includes/lib/class-canto-editor-integration.php')) {
    require_once 'includes/lib/class-canto-editor-integration.php';
    // Initialize editor integration safely
    add_action('init', function() {
        if (class_exists('Canto_Editor_Integration')) {
            Canto_Editor_Integration::instance();
        }
    }, 5);
}

//Gutenberg Block
require_once 'block/index.php';

// Load Elementor integration (WordPress.com compatible)
function canto_load_elementor_integration() {
    // Only run if Elementor is actually loaded
    if (did_action('elementor/loaded')) {
        do_action('canto_elementor_init');
    }
}
add_action('init', 'canto_load_elementor_integration');

/**
 * Determine whether an attachment originated from Canto's "Select from Canto" import flow.
 *
 * Checks for the `_canto_asset_id` post meta written when an asset is imported
 * via the Canto ACF integration (Canto_ACF_Integration::import_canto_asset()).
 * This reuses the exact meta key already read by Canto_Debug_Admin as the
 * canonical Canto-origin signal — no new storage is introduced.
 *
 * @param int $attachment_id WordPress attachment post ID.
 * @return bool True if the attachment carries Canto origin meta, false otherwise.
 */
function canto_attachment_is_from_canto($attachment_id) {
    if (!$attachment_id) {
        return false;
    }
    $canto_asset_id = get_post_meta($attachment_id, '_canto_asset_id', true);
    return !empty($canto_asset_id);
}

/**
 * Universal ACF field renderer (WordPress.com compatible)
 * This function can be called directly or used as a filter
 */
function canto_render_acf_fields($content = '', $post_id = null) {
    // Tracks post IDs already rendered via the `the_content` filter path
    // during this PHP request. Scoped to a single page render; resets between
    // requests. Only the `the_content` path (no explicit $post_id) is tracked
    // here, so the REST/direct-call path is never blocked by this guard.
    static $rendered_post_ids = array();

    // Skip if ACF is not available
    if (!function_exists('get_field_objects')) {
        return $content;
    }

    // Capture whether the caller supplied an explicit $post_id BEFORE the
    // get_the_ID() fallback below. The `the_content` filter never supplies one;
    // the REST callback / direct callers always do.
    $post_id_was_supplied = !empty($post_id);

    // If no post ID provided, try to get it
    if (!$post_id) {
        $post_id = get_the_ID();
    }
    
    // If still no post ID, return original content
    if (!$post_id) {
        return $content;
    }

    // Determine whether this invocation is the real, on-page render of the post
    // body. The de-duplication guard is scoped to exactly that case.
    //
    // Checking only for "no explicit $post_id" is too broad: plenty of plugins
    // apply `the_content` for non-display purposes (Yoast and friends building
    // meta descriptions, excerpt generation, search indexing). Those passes must
    // not consume the one allowed render, or the genuine render later in the
    // same request would be suppressed and the block would never appear.
    //
    // `in_the_loop() && is_main_query()` is true only during the main loop's
    // output of the post body, which is precisely the context that can fire
    // more than once per render (page builders re-applying the filter).
    $is_main_render = !$post_id_was_supplied
        && function_exists('in_the_loop') && in_the_loop()
        && function_exists('is_main_query') && is_main_query();

    // Early-out if the main render for this post already emitted the block.
    // The flag is only set once output is actually committed (further below),
    // so a pass that renders nothing never consumes this slot.
    if ($is_main_render && isset($rendered_post_ids[$post_id])) {
        return $content;
    }

    // Get all ACF fields for this post
    $fields = get_field_objects($post_id);
    if (!$fields) {
        return $content;
    }


    // PRE-SCAN: check whether this post has at least one ACF image/file/gallery
    // field with a value at all (cheap check, origin-agnostic). If none found,
    // return content completely untouched — no div, no style, nothing added.
    // The origin gate itself is enforced per-field in the render loop below;
    // the POST-RENDER GUARD after the loop handles the case where every field
    // present is filtered out for not being Canto-origin.
    $has_candidate_field = false;
    foreach ($fields as $field) {
        if (in_array($field['type'], array('image', 'file', 'gallery'), true) && !empty($field['value'])) {
            $has_candidate_field = true;
            break;
        }
    }

    if (!$has_candidate_field) {
        return $content;
    }


    // Build ACF fields container using string concatenation (no ob_start — avoids output buffer conflicts).
    // Original $content passes through untouched (no wp_kses_post stripping).
    $acf_output = '<div class="acf-fields-container" data-post-id="' . esc_attr($post_id) . '" data-canto-acf="true">';
    $rendered_count = 0;

    foreach ($fields as $field_name => $field) {
        if (!in_array($field['type'], array('image', 'file', 'gallery'), true) || empty($field['value'])) {
            continue;
        }

        // Resolve the attachment ID(s) backing this field's value, reusing
        // the same value-shape branches used to render the markup below
        // (array-with-url shape -> the 'ID' key; numeric shape -> the value
        // itself), rather than introducing a third parallel resolution path.
        $attachment_id = 0;
        $all_from_canto = false;

        if ($field['type'] === 'gallery') {
            // A gallery value is an array of items. Resolve an attachment ID
            // per item and require EVERY item to carry Canto origin meta
            // before the gallery renders as a whole; a mixed-origin gallery
            // is treated as non-Canto for this render.
            $gallery_items = is_array($field['value']) ? $field['value'] : array();
            $all_from_canto = !empty($gallery_items);
            foreach ($gallery_items as $gallery_item) {
                $item_attachment_id = 0;
                if (is_array($gallery_item) && isset($gallery_item['url'])) {
                    $item_attachment_id = isset($gallery_item['ID']) ? (int) $gallery_item['ID'] : 0;
                } elseif (is_numeric($gallery_item)) {
                    $item_attachment_id = (int) $gallery_item;
                }
                if (!canto_attachment_is_from_canto($item_attachment_id)) {
                    $all_from_canto = false;
                    break;
                }
            }
        } else {
            // image / file: a single attachment resolved from either value shape.
            $attachment_id = is_array($field['value']) ? (int) ($field['value']['ID'] ?? 0) : (int) $field['value'];
        }

        if (!$attachment_id && $field['type'] !== 'gallery') {
            continue;
        }

        // Decide whether this field originated from Canto before rendering.
        // Gallery fields use the per-item aggregate resolved above (every
        // item must carry Canto origin meta); image/file fields use the
        // single resolved attachment ID.
        if ($field['type'] === 'gallery') {
            $should_render = $all_from_canto;
        } else {
            $should_render = canto_attachment_is_from_canto($attachment_id);
        }

        /**
         * Filter whether a specific ACF field should be rendered by the Canto
         * duplicate-content block. Defaults to true only for Canto-origin
         * attachments (those carrying '_canto_asset_id' post meta).
         *
         * @param bool  $should_render Whether to render this field. Default: Canto-origin check result.
         * @param array $field         The ACF field array from get_field_objects().
         * @param int   $attachment_id Resolved attachment ID for the field's value (0 if unresolved or a gallery).
         * @param int   $post_id       The post ID being rendered.
         */
        $should_render = apply_filters('canto_should_render_acf_field', $should_render, $field, $attachment_id, $post_id);

        // Origin gate: skip fields that are not Canto-origin (and were not
        // force-enabled by the filter above). This is what stops unrelated
        // WordPress-media ACF fields (e.g. a page's teaser image) from being
        // duplicated into post content.
        if (!$should_render) {
            continue;
        }

        // data-field-type reflects the field's actual ACF type (image/file/gallery).
        $field_html = '<div class="acf-field-image" data-field-name="' . esc_attr($field_name) . '" data-field-type="' . esc_attr($field['type']) . '">';

        if (isset($field['label'])) {
            $field_html .= '<h3 class="acf-field-label">' . esc_html($field['label']) . '</h3>';
        }

        if ($field['type'] === 'gallery') {
            // Gallery value is an array of items (array-with-url shape, or
            // less commonly attachment IDs). Render one <img> per item,
            // reusing the same value-shape handling as the single-image
            // branch below.
            $gallery_items = is_array($field['value']) ? $field['value'] : array();
            foreach ($gallery_items as $gallery_item) {
                if (is_array($gallery_item) && isset($gallery_item['url'])) {
                    $field_html .= sprintf(
                        '<img src="%s" alt="%s" class="acf-image" data-id="%s" data-full-url="%s" />',
                        esc_url($gallery_item['url']),
                        esc_attr(isset($gallery_item['alt']) ? $gallery_item['alt'] : ''),
                        esc_attr(isset($gallery_item['ID']) ? $gallery_item['ID'] : ''),
                        esc_url($gallery_item['url'])
                    );
                } elseif (is_numeric($gallery_item)) {
                    $image_url = wp_get_attachment_url($gallery_item);
                    $image_alt = get_post_meta($gallery_item, '_wp_attachment_image_alt', true);
                    if ($image_url) {
                        $field_html .= sprintf(
                            '<img src="%s" alt="%s" class="acf-image" data-id="%s" data-full-url="%s" />',
                            esc_url($image_url),
                            esc_attr($image_alt),
                            esc_attr($gallery_item),
                            esc_url($image_url)
                        );
                    }
                }
            }
        } elseif ($field['type'] === 'file') {
            // File fields commonly hold non-image files (PDF, DOCX, etc.).
            // Render a link with the filename/title rather than an <img>,
            // consistent with ACF's own documented file-display pattern.
            if (is_array($field['value']) && isset($field['value']['url'])) {
                if (!empty($field['value']['title'])) {
                    $file_title = $field['value']['title'];
                } elseif (isset($field['value']['filename'])) {
                    $file_title = $field['value']['filename'];
                } else {
                    $file_title = basename($field['value']['url']);
                }
                $field_html .= sprintf(
                    '<a href="%s" class="acf-file" data-id="%s">%s</a>',
                    esc_url($field['value']['url']),
                    esc_attr(isset($field['value']['ID']) ? $field['value']['ID'] : ''),
                    esc_html($file_title)
                );
            } elseif (is_numeric($field['value'])) {
                $file_url = wp_get_attachment_url($field['value']);
                if ($file_url) {
                    $file_title = get_the_title($field['value']);
                    if (!$file_title) {
                        $file_title = basename($file_url);
                    }
                    $field_html .= sprintf(
                        '<a href="%s" class="acf-file" data-id="%s">%s</a>',
                        esc_url($file_url),
                        esc_attr($field['value']),
                        esc_html($file_title)
                    );
                }
            }
        } else {
            // image: a single attachment, resolved from either value shape.
            // Handle array format (value already transformed by format_image_value)
            if (is_array($field['value']) && isset($field['value']['url'])) {
                $field_html .= sprintf(
                    '<img src="%s" alt="%s" class="acf-image" data-id="%s" data-full-url="%s" />',
                    esc_url($field['value']['url']),
                    esc_attr($field['value']['alt'] ?? ''),
                    esc_attr($field['value']['ID'] ?? ''),
                    esc_url($field['value']['url'])
                );
            }
            // Handle numeric ID format
            elseif (is_numeric($field['value'])) {
                $image_url = wp_get_attachment_url($field['value']);
                $image_alt = get_post_meta($field['value'], '_wp_attachment_image_alt', true);
                if ($image_url) {
                    $field_html .= sprintf(
                        '<img src="%s" alt="%s" class="acf-image" data-id="%s" data-full-url="%s" />',
                        esc_url($image_url),
                        esc_attr($image_alt),
                        esc_attr($field['value']),
                        esc_url($image_url)
                    );
                }
            }
        }

        $field_html .= '</div>';

        $acf_output .= apply_filters('canto_acf_field_html', $field_html, $field, $post_id);
        $rendered_count++;
    }

    $acf_output .= '</div>';

    // POST-RENDER GUARD: if the loop produced nothing (every candidate field
    // was filtered out — most commonly because none of them were Canto-origin),
    // return content untouched — do not append the empty container div or style block.
    if ($rendered_count === 0) {
        return $content;
    }

    // Output is now committed for this render, so consume the main-render slot.
    // Deliberately set here rather than earlier: a pass that bails out above
    // (no fields, no candidate fields, nothing Canto-origin) leaves the flag
    // untouched, so a later genuine render in the same request still emits.
    if ($is_main_render) {
        $rendered_post_ids[$post_id] = true;
    }

    // Enqueue the ACF fields stylesheet via wp_head (once per page load, not per content block),
    // matching the approach already in use for layout-safety. No `clear: both`, so the theme
    // retains control of float clearing.
    if (!wp_style_is('canto-acf-fields', 'enqueued')) {
        wp_register_style('canto-acf-fields', false, array(), CANTO_FBC_VERSION);
        wp_enqueue_style('canto-acf-fields');
        wp_add_inline_style('canto-acf-fields', '
            .acf-fields-container { margin: 2em 0; }
            .acf-field-image { margin: 1.5em 0; position: relative; }
            .acf-field-label { margin-bottom: 1em; }
            .acf-image { max-width: 100%; height: auto; display: block; margin: 1em 0; }
        ');
    }

    // Original content passes through untouched; Canto ACF output appended after
    return apply_filters('canto_acf_fields_output', $content . $acf_output, $post_id);
}

// Hook the_content filter — only when ACF is available
if (function_exists('get_field_objects')) {
    add_filter('the_content', 'canto_render_acf_fields', 20);
}

// Footer script — only when ACF is available; guarded inside against pages with no Canto output
if (function_exists('get_field_objects')) {
    add_action('wp_footer', function() {
        ?>
        <script>
        (function() {
            var $ = window.jQuery;
            if (typeof $ === 'undefined') { return; }
            if (!document.querySelector('.acf-fields-container')) { return; }

            function initCantoAcfFields() {
                $('.acf-fields-container').each(function() {
                    var $container = $(this);
                    var postId = $container.data('post-id');
                    $(document).trigger('canto_acf_fields_loaded', [$container, postId]);
                });
            }

            $(document).ready(initCantoAcfFields);

            $(document).on('elementor/frontend/init', initCantoAcfFields);
            $(document).on('vc-full-width-row', initCantoAcfFields);
            $(document).on('fusion-element-render-fusion_builder_container', initCantoAcfFields);
            $(document).on('builder_content_updated', initCantoAcfFields);
        })();
        </script>
        <?php
    });
}

// Add support for REST API
add_action('rest_api_init', function() {
    register_rest_field('post', 'canto_acf_fields', array(
        'get_callback' => function($post) {
            return canto_render_acf_fields('', $post['id']);
        },
        'schema' => array(
            'description' => 'Canto ACF fields HTML output',
            'type' => 'string'
        )
    ));
});

/**
 * Returns the main instance of Canto to prevent the need to use globals.
 *
 * @return object Canto
 * @since  1.0.0
 */
function Canto()
{
    $instance = Canto::instance(__FILE__, '1.0.0');

    if (is_null($instance->settings)) {
        $instance->settings = Canto_Settings::instance($instance);
    }

    return $instance;
}

Canto();



/*
function canto_enqueue_block_editor_assets() {
// Scripts.
wp_enqueue_script(
'canto-block',
FBC_URL . 'block/block.js',
array( 'wp-blocks', 'wp-i18n', 'wp-element' )
);
// Styles.
wp_enqueue_style(
'canto-block-editor',
FBC_URL . 'assets/css/editor.css',
array( 'wp-edit-blocks' )
);
}
add_action( 'init', 'canto_enqueue_block_editor_assets' );
function canto_enqueue_block_assets() {
wp_enqueue_style(
'canto-frontend',
FBC_URL . 'assets/css/style.css',
array( 'wp-blocks' )
);
}
add_action( 'init', 'canto_enqueue_block_assets' );
*/