<?php

namespace FluentCartBreakdance\Compatibility;

defined('ABSPATH') || exit;

use FluentCartBreakdance\Support\Kses;

/**
 * WP9 (Golf 3, ELITE-PLAN.md par. 281-292): the single compatibility layer every
 * FC_Checkout* element renders through. Architectuurprincipe 1 ("alle FluentCart-kennis in
 * de adapter, elementen kennen alleen de renderer") applies here exactly like
 * FluentCartAdapter does for the product family: no bd-elements/FC_Checkout* file ever
 * references a `FluentCart\...` class or `CheckoutFieldsSchema`/`FormFieldRenderer` method
 * directly. Every call is guarded (class_exists/method_exists) so a future FluentCart
 * release that renames or removes one of these degrades to a documented notice, never a
 * fatal error, per architectuurprincipe 2.
 *
 * Feature flag (task instruction 4, binding): `fcbd_atomized_checkout` defaults to OFF.
 * This is the SAME option name `src/Admin/HealthPage.php` (WP12A, golf 4) already reports
 * on as "reserved, no writer yet" -- this fork is that writer. While the flag is off,
 * `isAtomizedEnabled()` returns false and FC_Checkout renders nothing but the native
 * `[fluent_cart_checkout]` shortcode (`renderNativeCheckout()`), so a fresh install of this
 * plugin never changes checkout behavior until an admin deliberately opts in.
 *
 * Dual render path (architectuurprincipe 4): every method below is safe to call from BOTH
 * the live path (a real `Cart` model, real customer/session state) and the builder path
 * (`$isBuilder === true`, no real cart mutation ever). The anonymized*() helpers exist
 * specifically so builder-path schema reconstruction never needs a real cart or customer:
 * they are plain, static, non-PII example values (never a real name, email, or address),
 * matching task instruction 3's "GEANONIMISEERDE placeholderdata" requirement.
 */
final class CheckoutAdapter
{
    /**
     * Feature flag option (default OFF). Reserved and already referenced by
     * `src/Admin/HealthPage.php` (WP12A); this file is its first real consumer/writer-check.
     */
    public const ATOMIZED_OPTION = 'fcbd_atomized_checkout';

    private const CART_HELPER_CLASS = 'FluentCart\\App\\Helpers\\CartHelper';
    private const CHECKOUT_RENDERER_CLASS = 'FluentCart\\App\\Services\\Renderer\\CheckoutRenderer';
    private const CHECKOUT_FIELDS_SCHEMA_CLASS = 'FluentCart\\App\\Services\\Renderer\\CheckoutFieldsSchema';
    private const FORM_FIELD_RENDERER_CLASS = 'FluentCart\\App\\Services\\Renderer\\FormFieldRenderer';
    private const CART_RENDERER_CLASS = 'FluentCart\\App\\Services\\Renderer\\CartRenderer';
    private const CART_SUMMARY_RENDER_CLASS = 'FluentCart\\App\\Services\\Renderer\\CartSummaryRender';
    private const MODAL_CHECKOUT_RENDERER_CLASS = 'FluentCart\\App\\Services\\Renderer\\ModalCheckoutRenderer';
    private const CHECKOUT_PAGE_HANDLER_CLASS = 'FluentCart\\App\\Hooks\\Handlers\\ShortCodes\\Checkout\\CheckoutPageHandler';

    /**
     * Whether the atomized checkout feature flag is on. Default OFF (binding, task
     * instruction 4): a site that merely updates this plugin sees no behavior change.
     */
    public static function isAtomizedEnabled(): bool
    {
        return function_exists('get_option') && (bool) get_option(self::ATOMIZED_OPTION, false);
    }

    /**
     * Whether the current request is a Breakdance builder/SSR-preview request. Delegates
     * to the golf-1 `ProductContext` API (read-only dependency, already the plugin-wide
     * single source of truth for this check; never reimplemented here).
     */
    public static function isBuilderRequest(): bool
    {
        if (class_exists('FluentCartBreakdance\\Context\\ProductContext')) {
            return \FluentCartBreakdance\Context\ProductContext::isBuilderRequest();
        }

        return false;
    }

    /**
     * Whether FluentCart's checkout classes are present at all. Distinct from the broader
     * `Requirements::hasFluentCart()` check because the checkout classes live in their own
     * namespace and could theoretically be missing on a stripped custom build even when
     * the base product classes are present.
     */
    public static function isAvailable(): bool
    {
        return class_exists(self::CART_HELPER_CLASS) && class_exists(self::CHECKOUT_RENDERER_CLASS);
    }

    /**
     * @return object|null The live FluentCart\App\Models\Cart, or null if unavailable/empty.
     */
    public static function getCart()
    {
        if (!class_exists(self::CART_HELPER_CLASS) || !method_exists(self::CART_HELPER_CLASS, 'getCart')) {
            return null;
        }

        try {
            return call_user_func([self::CART_HELPER_CLASS, 'getCart']);
        } catch (\Throwable $error) {
            self::logError('getCart', $error);
            return null;
        }
    }

    /**
     * @param object|null $cart
     */
    public static function cartHasItems($cart): bool
    {
        if (!is_object($cart) || !isset($cart->cart_data)) {
            return false;
        }

        return !empty($cart->cart_data);
    }

    /**
     * @param object $cart
     * @return object|null A live FluentCart\App\Services\Renderer\CheckoutRenderer instance.
     */
    public static function newCheckoutRenderer($cart)
    {
        if (!class_exists(self::CHECKOUT_RENDERER_CLASS)) {
            return null;
        }

        try {
            $class = self::CHECKOUT_RENDERER_CLASS;
            return new $class($cart);
        } catch (\Throwable $error) {
            self::logError('newCheckoutRenderer', $error);
            return null;
        }
    }

    /**
     * @return object|null A live FluentCart\App\Services\Renderer\FormFieldRenderer instance.
     */
    public static function newFormFieldRenderer()
    {
        if (!class_exists(self::FORM_FIELD_RENDERER_CLASS)) {
            return null;
        }

        try {
            $class = self::FORM_FIELD_RENDERER_CLASS;
            return new $class();
        } catch (\Throwable $error) {
            self::logError('newFormFieldRenderer', $error);
            return null;
        }
    }

    /**
     * @param object $cart
     * @return object|null A live FluentCart\App\Services\Renderer\CartSummaryRender instance.
     */
    public static function newCartSummaryRenderer($cart)
    {
        if (!class_exists(self::CART_SUMMARY_RENDER_CLASS)) {
            return null;
        }

        try {
            $class = self::CART_SUMMARY_RENDER_CLASS;
            return new $class($cart);
        } catch (\Throwable $error) {
            self::logError('newCartSummaryRenderer', $error);
            return null;
        }
    }

    /**
     * @param object $cart
     * @return object|null A live FluentCart\App\Services\Renderer\ModalCheckoutRenderer instance.
     */
    public static function newModalCheckoutRenderer($cart)
    {
        if (!class_exists(self::MODAL_CHECKOUT_RENDERER_CLASS)) {
            return null;
        }

        try {
            $class = self::MODAL_CHECKOUT_RENDERER_CLASS;
            return new $class($cart);
        } catch (\Throwable $error) {
            self::logError('newModalCheckoutRenderer', $error);
            return null;
        }
    }

    /**
     * @return array<string, mixed>
     */
    public static function getAddressBaseFields(array $config, string $scope = 'render'): array
    {
        if (!class_exists(self::CHECKOUT_FIELDS_SCHEMA_CLASS) || !method_exists(self::CHECKOUT_FIELDS_SCHEMA_CLASS, 'getAddressBaseFields')) {
            return [];
        }

        try {
            $fields = call_user_func([self::CHECKOUT_FIELDS_SCHEMA_CLASS, 'getAddressBaseFields'], $config, $scope);
            return is_array($fields) ? $fields : [];
        } catch (\Throwable $error) {
            self::logError('getAddressBaseFields', $error);
            return [];
        }
    }

    /**
     * @param object|null $cart
     * @return array<string, mixed>
     */
    public static function getNameEmailFieldsSchema($cart = null, string $scope = 'render'): array
    {
        if (!class_exists(self::CHECKOUT_FIELDS_SCHEMA_CLASS) || !method_exists(self::CHECKOUT_FIELDS_SCHEMA_CLASS, 'getNameEmailFieldsSchema')) {
            return [];
        }

        try {
            $schema = call_user_func([self::CHECKOUT_FIELDS_SCHEMA_CLASS, 'getNameEmailFieldsSchema'], $cart, $scope);
            return is_array($schema) ? $schema : [];
        } catch (\Throwable $error) {
            self::logError('getNameEmailFieldsSchema', $error);
            return [];
        }
    }

    public static function isTermsVisible(): bool
    {
        if (!class_exists(self::CHECKOUT_FIELDS_SCHEMA_CLASS) || !method_exists(self::CHECKOUT_FIELDS_SCHEMA_CLASS, 'isTermsVisible')) {
            // Fail open exactly like the live renderer would if the schema class were
            // present (isTermsVisible() defaults true in 1.3.27); absence of the class
            // itself is caught earlier by isAvailable() guards in the calling element.
            return true;
        }

        try {
            return (bool) call_user_func([self::CHECKOUT_FIELDS_SCHEMA_CLASS, 'isTermsVisible']);
        } catch (\Throwable $error) {
            self::logError('isTermsVisible', $error);
            return true;
        }
    }

    public static function getTermsText(): string
    {
        if (!class_exists(self::CHECKOUT_FIELDS_SCHEMA_CLASS) || !method_exists(self::CHECKOUT_FIELDS_SCHEMA_CLASS, 'getTermsText')) {
            return __('I agree to the terms and conditions.', 'sparkcore-commerce');
        }

        try {
            return (string) call_user_func([self::CHECKOUT_FIELDS_SCHEMA_CLASS, 'getTermsText']);
        } catch (\Throwable $error) {
            self::logError('getTermsText', $error);
            return __('I agree to the terms and conditions.', 'sparkcore-commerce');
        }
    }

    /**
     * The two verified filters (task instruction 3): submit-button copy goes through
     * `fluent_cart/checkout_page_order_button_text` exactly like the live
     * `CheckoutRenderer::renderCheckoutButton()` does, so a site-wide filter hooked to that
     * tag affects the atomized submit button identically to the native one.
     */
    public static function submitButtonText(string $default): string
    {
        if (!function_exists('apply_filters')) {
            return $default;
        }

        return (string) apply_filters('fluent_cart/checkout_page_order_button_text', $default);
    }

    /**
     * Renders the native `[fluent_cart_checkout]` shortcode. This is BOTH the
     * feature-flag-off default path and the CheckoutStructureValidator fallback path (task
     * instructions 4 and 4): an invalid or disabled atomized tree always degrades to
     * exactly what a site running the plain shortcode would see, never a broken partial
     * render.
     */
    public static function renderNativeCheckout(): void
    {
        if (function_exists('shortcode_exists') && shortcode_exists('fluent_cart_checkout')) {
            echo wp_kses(Kses::prepare(function_exists('do_shortcode') ? do_shortcode('[fluent_cart_checkout]') : ''), Kses::allowed());
            return;
        }

        // Guarded fallback mirroring the shortcode's own call path bit for bit, same
        // discipline as bd-elements/FC_Login/ssr.php's documented OR-pattern: FluentCart
        // 1.3.27 DOES register `fluent_cart_checkout` (verified,
        // Contracts.php shortcodeContracts()), so this branch is a defensive
        // future-proofing path, not a currently-exercised one.
        if (class_exists(self::CHECKOUT_PAGE_HANDLER_CLASS)) {
            try {
                $class = self::CHECKOUT_PAGE_HANDLER_CLASS;
                (new $class())->render();
                return;
            } catch (\Throwable $error) {
                self::logError('renderNativeCheckout', $error);
            }
        }

        echo wp_kses(\FluentCartBreakdance\Compatibility\FluentCartAdapter::notice(
            __('The checkout is unavailable right now.', 'sparkcore-commerce'),
            'broken'
        ), Kses::allowed());
    }

    /**
     * Renders FluentCart's own empty-cart state (`CartRenderer::renderEmpty()`), used by
     * FC_Checkout when the resolved cart genuinely has no items -- the same empty-state
     * branch `CheckoutPageHandler::render()` itself takes.
     */
    public static function renderEmptyCart(): void
    {
        if (!class_exists(self::CART_RENDERER_CLASS) || !method_exists(self::CART_RENDERER_CLASS, 'renderEmpty')) {
            echo wp_kses(\FluentCartBreakdance\Compatibility\FluentCartAdapter::notice(
                __('Your cart is empty.', 'sparkcore-commerce'),
                'empty'
            ), Kses::allowed());
            return;
        }

        try {
            $class = self::CART_RENDERER_CLASS;
            (new $class())->renderEmpty();
        } catch (\Throwable $error) {
            self::logError('renderEmptyCart', $error);
            echo wp_kses(\FluentCartBreakdance\Compatibility\FluentCartAdapter::notice(
                __('Your cart is empty.', 'sparkcore-commerce'),
                'empty'
            ), Kses::allowed());
        }
    }

    // ------------------------------------------------------------------
    // Builder-path anonymized placeholder data (task instruction 3, binding:
    // "GEANONIMISEERDE placeholderdata"). Every value below is a static, non-PII example;
    // none of it is ever derived from a real customer, cart, or order.
    // ------------------------------------------------------------------

    /**
     * @return array<string, mixed> A builder-preview billing address config for
     *      CheckoutFieldsSchema::getAddressBaseFields(), scope 'builder' (all fields
     *      shown, none filtered by store requirements -- "verborgen secties zichtbaar in
     *      builder").
     */
    public static function anonymizedBillingAddressConfig(): array
    {
        return [
            'type' => 'billing',
            'product_type' => 'physical',
            'with_shipping' => false,
            'full_name' => __('Jordan Rivera', 'sparkcore-commerce'),
            'country' => '',
            'address_1' => __('123 Example Street', 'sparkcore-commerce'),
            'address_2' => '',
            'city' => __('Sampletown', 'sparkcore-commerce'),
            'state' => '',
            'postcode' => '12345',
            'company_name' => '',
            'phone' => '',
        ];
    }

    /**
     * @return array<string, mixed> A builder-preview shipping address config, same
     *      anonymization discipline as anonymizedBillingAddressConfig().
     */
    public static function anonymizedShippingAddressConfig(): array
    {
        return [
            'type' => 'shipping',
            'product_type' => 'physical',
            'full_name' => __('Jordan Rivera', 'sparkcore-commerce'),
            'country' => '',
            'address_1' => __('123 Example Street', 'sparkcore-commerce'),
            'address_2' => '',
            'city' => __('Sampletown', 'sparkcore-commerce'),
            'state' => '',
            'postcode' => '12345',
            'company_name' => '',
            'phone' => '',
        ];
    }

    /**
     * @return array<int, array{label: string, price: string}> A static builder-preview
     *      shipping-methods list (FC_Checkout_Shipping_Methods has no real Cart to derive
     *      AddressHelper::getShippingMethods() from in the builder).
     */
    public static function anonymizedShippingMethods(): array
    {
        return [
            ['label' => __('Standard Shipping', 'sparkcore-commerce'), 'price' => __('$5.00', 'sparkcore-commerce')],
            ['label' => __('Express Shipping', 'sparkcore-commerce'), 'price' => __('$15.00', 'sparkcore-commerce')],
        ];
    }

    /**
     * @return array<int, array{route: string, title: string}> A static builder-preview
     *      payment-methods list (FC_Checkout_Payment_Methods has no real Cart/store
     *      payment-gateway configuration to derive PaymentMethods::getActiveMethodInstance()
     *      from in the builder).
     */
    public static function anonymizedPaymentMethods(): array
    {
        return [
            ['route' => 'card', 'title' => __('Credit / Debit Card', 'sparkcore-commerce')],
            ['route' => 'paypal', 'title' => __('PayPal', 'sparkcore-commerce')],
        ];
    }

    /**
     * @return array<int, array{title: string, price: string}> A static builder-preview
     *      order summary line-item list for FC_Checkout_Order_Summary.
     */
    public static function anonymizedOrderSummaryItems(): array
    {
        return [
            ['title' => __('Example Product', 'sparkcore-commerce'), 'price' => __('$49.00', 'sparkcore-commerce')],
        ];
    }

    private static function logError(string $context, \Throwable $error): void
    {
        if (defined('WP_DEBUG') && WP_DEBUG) {
            // phpcs:ignore WordPress.PHP.DevelopmentFunctions.error_log_error_log -- Diagnostic logging, only reached when WP_DEBUG is enabled.
            error_log('SparkCore Commerce checkout adapter error (' . $context . '): ' . $error->getMessage());
        }
    }
}