<?php

declare(strict_types=1);

namespace CrocoAI\DataBridge\Domain;

use CrocoAI\DataBridge\Contracts\Validator;

final class ProductValidator implements Validator
{
    public function validate(array $canonical): array
    {
        $errors = ProductMetadata::errors($canonical);
        $warnings = [];
        if (($canonical['external_id'] ?? '') === '') {
            $errors[] = 'external_id is required';
        }
        if (($canonical['name'] ?? '') === '' && ($canonical['type'] ?? '') !== 'variation') {
            $errors[] = 'name is required';
        }
        if (($canonical['type'] ?? '') !== 'variable' && ($canonical['sku'] ?? '') === '') {
            $warnings[] = 'sku is empty; only source identity will be used';
        }
        foreach (['regular_price', 'sale_price'] as $field) {
            if (($canonical[$field] ?? '') !== '' && !is_numeric($canonical[$field])) {
                $errors[] = "{$field} must be numeric";
            }
        }
        if (
            array_key_exists('backorders', $canonical)
            && !in_array($canonical['backorders'], ['no', 'notify', 'yes'], true)
        ) {
            $errors[] = 'backorders must be no, notify, or yes';
        }
        if (($canonical['type'] ?? '') === 'variation' && empty($canonical['parent_external_id'])) {
            $errors[] = 'variation requires parent_external_id';
        }
        if (array_key_exists('brands', $canonical)) {
            if (!is_array($canonical['brands']) || !array_is_list($canonical['brands'])) {
                $errors[] = 'brands must be a list of exact term names';
            } else {
                foreach ($canonical['brands'] as $brand) {
                    if (!is_string($brand) || $brand === '' || trim($brand) !== $brand) {
                        $errors[] = 'each brand must be a non-empty exact term name without surrounding whitespace';
                        break;
                    }
                }
            }
        }
        if (array_key_exists('_structural_migration', $canonical)) {
            $migration = $canonical['_structural_migration'];
            if (!is_array($migration)) {
                $errors[] = '_structural_migration must be an object';
            } else {
                $direction = (string) ($migration['direction'] ?? '');
                if (!in_array($direction, ['simple_to_variable', 'variable_to_simple', 'variation_to_simple'], true)) {
                    $errors[] = 'The structural migration direction is unknown.';
                }
                if ($direction === 'variation_to_simple' && ($migration['confirmed'] ?? null) !== true) {
                    $errors[] = 'variation_to_simple requires _structural_migration.confirmed to be exactly true.';
                }
            }
        }
        if (array_key_exists('translations', $canonical)) {
            if (!is_array($canonical['translations'])) {
                $errors[] = 'translations must be a list';
            } else {
                foreach ($canonical['translations'] as $translation) {
                    if (!is_array($translation) || sanitize_key((string) ($translation['language'] ?? '')) === '') {
                        $errors[] = 'each translation needs a language';
                        break;
                    }
                    $mode = (string) ($translation['mode'] ?? 'duplicate');
                    foreach (ProductMetadata::errors($translation) as $error) {
                        $errors[] = 'translation ' . $translation['language'] . ': ' . $error;
                    }
                    if (!in_array($mode, ['duplicate', 'translate'], true)) {
                        $errors[] = 'translation mode must be duplicate or translate';
                        break;
                    }
                    if ($mode === 'translate') {
                        $sourceAttributes = array_column(AttributeIdentity::rows((array) ($canonical['attributes'] ?? [])), null, 'key');
                        foreach (AttributeIdentity::rows((array) ($translation['attributes'] ?? [])) as $attribute) {
                            $sourceAttribute = $sourceAttributes[$attribute['key']] ?? null;
                            if (!$sourceAttribute || count($sourceAttribute['values']) !== count($attribute['values'])) {
                                $errors[] = 'translated attribute options must match the source options for ' . $attribute['key'];
                            }
                        }
                        if (trim((string) ($translation['content_hash'] ?? '')) === '') {
                            $errors[] = 'translated content_hash is required';
                            break;
                        }
                        if (($canonical['type'] ?? '') === 'variation') {
                            if (
                                !is_array($translation['attributes'] ?? null)
                                || !is_array($translation['variation_attributes'] ?? null)
                            ) {
                                $errors[] = 'translated variation requires attributes and variation_attributes';
                                break;
                            }
                        } elseif (
                            trim((string) ($translation['name'] ?? '')) === ''
                            || !is_array($translation['categories'] ?? null)
                            || !is_array($translation['attributes'] ?? null)
                        ) {
                            $errors[] = 'translated product requires name, categories, and attributes';
                            break;
                        }
                    }
                }
            }
        }
        if (array_key_exists('_attribute_ownership', $canonical)) {
            if (!is_array($canonical['_attribute_ownership'])) {
                $errors[] = '_attribute_ownership must be an object';
            } else {
                $seenAttributeKeys = [];
                foreach ($canonical['_attribute_ownership'] as $key => $owner) {
                    if (is_int($key)) {
                        $errors[] = '_attribute_ownership must be keyed by stable attribute key';
                        break;
                    }
                    $attributeKey = AttributeIdentity::slug((string) $key);
                    if ($attributeKey === '') {
                        $errors[] = 'each attribute ownership entry needs a stable key';
                        break;
                    }
                    if (isset($seenAttributeKeys[$attributeKey])) {
                        $errors[] = 'attribute ownership contains the duplicate stable key ' . $attributeKey;
                        break;
                    }
                    $seenAttributeKeys[$attributeKey] = true;
                    if (!in_array($owner, ['source', 'merchant'], true)) {
                        $errors[] = 'attribute ownership for ' . $attributeKey . ' must be source or merchant';
                        break;
                    }
                }
            }
        }
        if (!empty($canonical['_normalization_pending'])) {
            $errors[] = 'category or attribute normalization requires approval';
        }
        $urls = array_filter($canonical['images'] ?? [], static fn ($url): bool => !wp_http_validate_url((string) $url));
        if ($urls) {
            $errors[] = 'one or more image URLs are invalid';
        }
        return apply_filters('crocoai_dbridge_validation_result', ['errors' => $errors, 'warnings' => $warnings], $canonical);
    }
}