<?php

namespace TFGraphics\SmartImport\Intelligence;

use TFGraphics\SmartImport\Domain\Contracts\ProductIntelligenceInterface;
use TFGraphics\SmartImport\Domain\DTO\EnhancedProductDTO;
use TFGraphics\SmartImport\Domain\DTO\ProductDTO;
use TFGraphics\SmartImport\Intelligence\Exceptions\ProductIntelligenceException;

final class ProductIntelligenceEngine implements ProductIntelligenceInterface
{
    private DuplicateDetector $duplicateDetector;
    private CategoryResolver $categoryResolver;
    private AttributeResolver $attributeResolver;
    private BrandResolver $brandResolver;
    private ConditionResolver $conditionResolver;
    private SeoBuilder $seoBuilder;
    private SlugBuilder $slugBuilder;
    private PriceAdvisor $priceAdvisor;
    private ProductEnhancer $productEnhancer;

    public function __construct(
        DuplicateDetector $duplicateDetector,
        CategoryResolver $categoryResolver,
        AttributeResolver $attributeResolver,
        BrandResolver $brandResolver,
        ConditionResolver $conditionResolver,
        SeoBuilder $seoBuilder,
        SlugBuilder $slugBuilder,
        PriceAdvisor $priceAdvisor,
        ProductEnhancer $productEnhancer
    ) {
        $this->duplicateDetector = $duplicateDetector;
        $this->categoryResolver = $categoryResolver;
        $this->attributeResolver = $attributeResolver;
        $this->brandResolver = $brandResolver;
        $this->conditionResolver = $conditionResolver;
        $this->seoBuilder = $seoBuilder;
        $this->slugBuilder = $slugBuilder;
        $this->priceAdvisor = $priceAdvisor;
        $this->productEnhancer = $productEnhancer;
    }

    public function enhance(ProductDTO $productDTO): EnhancedProductDTO
    {
        if ($productDTO->getName() === '') {
            throw new ProductIntelligenceException('Product name is required for intelligence enrichment.');
        }

        $duplicateMatches = $this->duplicateDetector->detect($productDTO);
        if (\TFGraphics\SmartImport\Providers\Foundation\RuntimeProviderCatalog::hasCapability((string) $productDTO->getProviderInfo()?->getName(), 'conservative_identity_only')) {
            return new EnhancedProductDTO($productDTO, $productDTO, $duplicateMatches, resolvedAttributes: $productDTO->getAttributes());
        }
        $categorySuggestion = $this->categoryResolver->resolve($productDTO);
        $resolvedAttributes = $this->attributeResolver->resolve($productDTO);
        $brandSuggestion = $this->brandResolver->resolve($productDTO, $resolvedAttributes);
        $conditionSuggestion = $this->conditionResolver->resolve($productDTO, $resolvedAttributes);
        $suggestedSlug = $this->slugBuilder->build($productDTO, $duplicateMatches === [] ? null : 'dup');
        $seo = $this->seoBuilder->build($productDTO, $categorySuggestion, $resolvedAttributes, $suggestedSlug);
        $priceSuggestion = $this->priceAdvisor->advise($productDTO);

        $enhancedProduct = $this->productEnhancer->enhance(
            $productDTO,
            $categorySuggestion,
            $resolvedAttributes,
            $brandSuggestion,
            $conditionSuggestion,
            $seo,
            $suggestedSlug
        );

        return new EnhancedProductDTO(
            $productDTO,
            $enhancedProduct,
            $duplicateMatches,
            $categorySuggestion,
            $resolvedAttributes,
            $brandSuggestion,
            $conditionSuggestion,
            $suggestedSlug,
            $priceSuggestion,
            [
                'duplicate_count' => count($duplicateMatches),
                'mapping_based_category' => $categorySuggestion?->getName(),
                'slug_source' => $duplicateMatches === [] ? 'title' : 'title-with-duplicate-suffix',
            ]
        );
    }
}