<?php

namespace FluentCartBreakdance\Breakdance\DynamicData;

use Breakdance\DynamicData\StringData;
use Breakdance\DynamicData\StringField;
use FluentCartBreakdance\Breakdance\TemplateRegistry;
use FluentCartBreakdance\Compatibility\FluentCartAdapter;
use FluentCartBreakdance\Context\ProductContext;

defined('ABSPATH') || exit;

/**
 * WP5 (Golf 1, fork C, ELITE-PLAN.md par. 220): generic, single-value string Dynamic Data
 * field, parametrized by `$valueKey`. Every value key below is SERVER-STATIC/DEFAULT-
 * VARIATION: it resolves `ProductContext::resolve()` and, where a variation matters,
 * `ProductContext::defaultVariation()` -- the product's configured default variation,
 * NEVER a variant the visitor has just picked in their browser (that is reactive-element
 * state, golf 2; see `DynamicDataRegistry`'s class docblock for the full policy and the
 * two concepts deliberately excluded everywhere in this fork).
 *
 * Value keys added in this fork (golf 0 already shipped: price, compare_price, sku,
 * stock, id, variation_id, fulfillment, payment_type, sale_state, url):
 * - `buy_now_url`: the default variation's real `getPurchaseUrl()` model method
 *   (`FluentCart\App\Models\ProductVariation::getPurchaseUrl()`, live-verified at
 *   `app/Models/ProductVariation.php:298-300`, `site_url('?fluent-cart=instant_checkout&item_id='
 *   . $id . '&quantity=1')`); a local fallback mirrors that exact literal format only if
 *   the real method is ever unavailable.
 * - `add_to_cart_url`: FluentCart has NO evidenced GET-based add-to-cart route (grep-
 *   confirmed against `app/Http/Routes/WebRoutes.php::registerRoutes()`: only the
 *   `instant_checkout` page action is dispatched; add-to-cart is AJAX/JS-driven via the
 *   `[fluent_cart_add_to_cart_button]` shortcode's own button, never a navigable link).
 *   Rather than fabricate an unproven URL scheme, this resolves to the product's own
 *   permalink, where that real add-to-cart button already lives. Documented deliberately,
 *   not a guess.
 * - `price_raw`: the default variation's raw `item_price`, an unformatted minor-unit
 *   integer (matching `Helper::toCent()`'s own unit), as a string.
 * - `currency`: `FluentCart\Api\CurrencySettings::get('currency')`.
 * - `package_info`: `FluentCart\App\Services\Renderer\ProductCardRender::buildPackageInfoFromOtherInfo()`
 *   (live-verified, `app/Services/Renderer/ProductCardRender.php:78-124`), fed the default
 *   variation's own `other_info`.
 * - `categories`/`brands`: a comma-separated term list for `product-categories`/
 *   `product-brands` (the same taxonomy constants TemplateRegistry.php declares, read
 *   here, never redefined), mirroring Breakdance's own shipped `WoocommerceProductTerms`
 *   dynamic-data field pattern.
 * - `stock_quantity`: the default variation's public `available` stock count, only when
 *   `ProductDetail::manage_stock` is on (unmanaged stock has no meaningful number to show);
 *   deliberately never exposes `on_hold`/`committed`, which are internal-only figures.
 */
final class ProductStringField extends StringField
{
    private string $fieldSlug;
    private string $fieldLabel;
    private string $valueKey;
    private array $types;

    public function __construct(string $slug, string $label, string $valueKey, array $types = ['string'])
    {
        $this->fieldSlug = $slug;
        $this->fieldLabel = $label;
        $this->valueKey = $valueKey;
        $this->types = $types;
    }

    public function label()
    {
        return $this->fieldLabel;
    }

    public function category()
    {
        return 'FluentCart';
    }

    public function slug()
    {
        return $this->fieldSlug;
    }

    public function returnTypes()
    {
        return $this->types;
    }

    public function handler($attributes): StringData
    {
        $product = ProductContext::resolve();
        $value = '';

        if ($product) {
            switch ($this->valueKey) {
                case 'price':
                    $value = FluentCartAdapter::formattedPrice($product);
                    break;
                case 'sku':
                    $value = FluentCartAdapter::sku($product);
                    break;
                case 'compare_price':
                    $value = FluentCartAdapter::formattedComparePrice($product);
                    break;
                case 'stock':
                    $value = FluentCartAdapter::stockLabel($product);
                    break;
                case 'variation_id':
                    $value = (string) FluentCartAdapter::variationId($product);
                    break;
                case 'fulfillment':
                    $value = FluentCartAdapter::fulfillmentType($product);
                    break;
                case 'payment_type':
                    $value = FluentCartAdapter::paymentType($product);
                    break;
                case 'sale_state':
                    $value = FluentCartAdapter::isAnyVariationOnSale($product) ? 'on-sale' : 'regular';
                    break;
                case 'id':
                    $value = (string) FluentCartAdapter::id($product);
                    break;
                case 'url':
                    $value = (string) get_permalink(FluentCartAdapter::id($product));
                    break;
                case 'buy_now_url':
                    $value = self::buyNowUrl($product);
                    break;
                case 'add_to_cart_url':
                    // See class docblock: no GET-based add-to-cart route exists, so this
                    // resolves to the product permalink, not a fabricated URL scheme.
                    $productId = FluentCartAdapter::id($product);
                    $value = $productId ? (string) get_permalink($productId) : '';
                    break;
                case 'price_raw':
                    $variation = ProductContext::defaultVariation($product);
                    $value = $variation ? (string) (int) ($variation->item_price ?? 0) : '';
                    break;
                case 'currency':
                    $value = class_exists('FluentCart\\Api\\CurrencySettings')
                        ? (string) \FluentCart\Api\CurrencySettings::get('currency')
                        : '';
                    break;
                case 'package_info':
                    $value = self::packageInfo($product);
                    break;
                case 'categories':
                    $value = self::termList($product, TemplateRegistry::CATEGORY_TAXONOMY);
                    break;
                case 'brands':
                    $value = self::termList($product, TemplateRegistry::BRAND_TAXONOMY);
                    break;
                case 'stock_quantity':
                    $value = self::stockQuantity($product);
                    break;
            }
        }

        return StringData::fromString($value);
    }

    /** @param object $product */
    private static function buyNowUrl($product): string
    {
        $variation = ProductContext::defaultVariation($product);
        if (!$variation) {
            return '';
        }

        if (method_exists($variation, 'getPurchaseUrl')) {
            return (string) $variation->getPurchaseUrl();
        }

        $variationId = (int) ($variation->id ?? 0);
        if (!$variationId || !function_exists('site_url')) {
            return '';
        }

        // Mirrors FluentCart\App\Models\ProductVariation::getPurchaseUrl()'s own literal
        // format exactly (app/Models/ProductVariation.php:298-300); used only if that real
        // method is ever unavailable.
        return site_url('?fluent-cart=instant_checkout&item_id=' . $variationId . '&quantity=1');
    }

    /** @param object $product */
    private static function packageInfo($product): string
    {
        $variation = ProductContext::defaultVariation($product);
        $otherInfo = $variation ? ($variation->other_info ?? null) : null;

        if (is_string($otherInfo)) {
            $decoded = json_decode($otherInfo, true);
            $otherInfo = is_array($decoded) ? $decoded : null;
        }

        if (!is_array($otherInfo) ||
            !class_exists('FluentCart\\App\\Services\\Renderer\\ProductCardRender') ||
            !method_exists('FluentCart\\App\\Services\\Renderer\\ProductCardRender', 'buildPackageInfoFromOtherInfo')) {
            return '';
        }

        return (string) \FluentCart\App\Services\Renderer\ProductCardRender::buildPackageInfoFromOtherInfo($otherInfo);
    }

    /** @param object $product */
    private static function termList($product, string $taxonomy): string
    {
        $productId = FluentCartAdapter::id($product);
        if (!$productId || !function_exists('get_the_term_list')) {
            return '';
        }

        $list = get_the_term_list($productId, $taxonomy, '', ', ');
        if (!is_string($list) && !(function_exists('is_wp_error') && is_wp_error($list))) {
            return '';
        }
        if (function_exists('is_wp_error') && is_wp_error($list)) {
            return '';
        }

        return function_exists('wp_strip_all_tags') ? wp_strip_all_tags((string) $list) : strip_tags((string) $list); // phpcs:ignore WordPress.WP.AlternativeFunctions.strip_tags_strip_tags -- Fallback only when WordPress is not loaded; the preferred branch uses wp_strip_all_tags().
    }

    /** @param object $product */
    private static function stockQuantity($product): string
    {
        $detail = $product->detail ?? null;
        if (!$detail || empty($detail->manage_stock)) {
            return '';
        }

        $variation = ProductContext::defaultVariation($product);
        if (!$variation || !isset($variation->available)) {
            return '';
        }

        return (string) (int) $variation->available;
    }
}