<?php

declare(strict_types=1);

namespace Evomedien\Vitec\UserFunc;

use TYPO3\CMS\Core\Database\ConnectionPool;
use TYPO3\CMS\Core\Service\FlexFormService;
use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Core\Resource\ResourceFactory;
use TYPO3\CMS\Core\Imaging\ImageManipulation\CropVariantCollection;
use TYPO3\CMS\Core\Resource\FileReference;
use TYPO3\CMS\Core\Imaging\ImageService;
use Doctrine\DBAL\ParameterType;

/**
 * UserFunc to render single product data as JSON for headless output
 */
class ProductShowJsonRenderer
{
    public function render(string $content, array $conf): string
    {
        $pageId = (int)$GLOBALS['TSFE']->id;
        
        // DEBUG: Log that the UserFunc is being called
        $debugInfo = [
            'userFuncCalled' => true,
            'pageId' => $pageId,
            'requestUri' => $_SERVER['REQUEST_URI'] ?? 'unknown',
        ];
        
        // Query tt_content for vitec_productshow on this page
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
            ->getQueryBuilderForTable('tt_content');
        
        $contentElements = $queryBuilder
            ->select('*')
            ->from('tt_content')
            ->where(
                $queryBuilder->expr()->eq('pid', $queryBuilder->createNamedParameter($pageId, ParameterType::INTEGER)),
                $queryBuilder->expr()->eq('list_type', $queryBuilder->createNamedParameter('vitec_productshow', ParameterType::STRING)),
                $queryBuilder->expr()->eq('deleted', 0),
                $queryBuilder->expr()->eq('hidden', 0)
            )
            ->executeQuery()
            ->fetchAllAssociative();
        
        $debugInfo['contentElementsFound'] = count($contentElements);
        
        if (empty($contentElements)) {
            $debugInfo['error'] = 'No vitec_productshow on page';
            return json_encode(['debug' => $debugInfo]);
        }
        
        // Take the first one
        $contentElement = $contentElements[0];
        
        // Parse FlexForm
        $flexFormService = GeneralUtility::makeInstance(FlexFormService::class);
        $flexFormData = $flexFormService->convertFlexFormContentToArray($contentElement['pi_flexform'] ?? '');
        $settings = $flexFormData['settings'] ?? [];
        
        // Get product UID from FlexForm or route parameter
        $productUid = (int)($settings['product'] ?? 0);
        $layout = (int)($settings['layout'] ?? 0);
        $debugMode = (bool)($settings['debug'] ?? false);
        
        // If no product selected in FlexForm, try to get from route parameter
        if (!$productUid) {
            // Get the product parameter from GET request
            $routeParams = $GLOBALS['TYPO3_REQUEST']->getQueryParams();
            $productParam = $routeParams['tx_vitec_productshow']['product'] ?? null;
            
            if ($productParam) {
                // If it's a slug, resolve it to UID
                if (!is_numeric($productParam)) {
                    $slugQueryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
                        ->getQueryBuilderForTable('tx_vitec_domain_model_product');
                    
                    $productBySlug = $slugQueryBuilder
                        ->select('uid')
                        ->from('tx_vitec_domain_model_product')
                        ->where(
                            $slugQueryBuilder->expr()->eq('slug', $slugQueryBuilder->createNamedParameter($productParam)),
                            $slugQueryBuilder->expr()->eq('deleted', 0),
                            $slugQueryBuilder->expr()->eq('hidden', 0)
                        )
                        ->executeQuery()
                        ->fetchAssociative();
                    
                    $productUid = (int)($productBySlug['uid'] ?? 0);
                } else {
                    $productUid = (int)$productParam;
                }
            }
        }
        
        if (!$productUid) {
            return json_encode([
                'error' => 'No product selected or found',
                'debug' => [
                    'settings' => $settings, 
                    'routeParams' => $routeParams ?? [],
                    'allQueryParams' => $GLOBALS['TYPO3_REQUEST']->getQueryParams() ?? [],
                    'requestUri' => $GLOBALS['TYPO3_REQUEST']->getUri()->getPath() ?? ''
                ]
            ]);
        }
        
        // Query product
        $productQueryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
            ->getQueryBuilderForTable('tx_vitec_domain_model_product');
        
        $product = $productQueryBuilder
            ->select('*')
            ->from('tx_vitec_domain_model_product')
            ->where(
                $productQueryBuilder->expr()->eq('uid', $productQueryBuilder->createNamedParameter($productUid, ParameterType::INTEGER)),
                $productQueryBuilder->expr()->eq('deleted', 0),
                $productQueryBuilder->expr()->eq('hidden', 0)
            )
            ->executeQuery()
            ->fetchAssociative();
        
        if (!$product) {
            return json_encode([
                'error' => 'Product not found',
                'debug' => $debugMode ? ['productUid' => $productUid] : null
            ]);
        }
        
        // Get product images
        $images = $this->getProductImages((int)$product['uid']);
        
        // Get categories
        $categories = $this->getProductCategories((int)$product['uid']);
        
        // Get downloads
        $downloads = $this->getProductDownloads((int)$product['uid']);
        
        // Build response
        $response = [
            'product' => [
                'uid' => (int)$product['uid'],
                'title' => $product['title'],
                'subtitle' => $product['subtitle'],
                'slug' => $product['slug'],
                'teaser' => $product['teaser'],
                'description' => $product['description'],
                'seotitle' => $product['seotitle'],
                'categories' => $categories,
                'images' => $images,
                'downloads' => $downloads,
            ],
            'layout' => $layout,
            'settings' => [
                'layout' => $layout,
            ],
        ];
        
        if ($debugMode) {
            $response['debug'] = [
                'pageId' => $pageId,
                'productUid' => $productUid,
                'layout' => $layout,
                'settings' => $settings,
            ];
        }
        
        return json_encode($response);
    }
    
    /**
     * Get all images for a product with FAL and ImageService processing
     */
    protected function getProductImages(int $productUid): array
    {
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
            ->getQueryBuilderForTable('sys_file_reference');
        
        $fileReferences = $queryBuilder
            ->select('*')
            ->from('sys_file_reference')
            ->where(
                $queryBuilder->expr()->eq('uid_foreign', $queryBuilder->createNamedParameter($productUid, ParameterType::INTEGER)),
                $queryBuilder->expr()->eq('tablenames', $queryBuilder->createNamedParameter('tx_vitec_domain_model_product', ParameterType::STRING)),
                $queryBuilder->expr()->eq('fieldname', $queryBuilder->createNamedParameter('productimage', ParameterType::STRING)),
                $queryBuilder->expr()->eq('deleted', 0),
                $queryBuilder->expr()->eq('hidden', 0)
            )
            ->orderBy('sorting_foreign', 'ASC')
            ->executeQuery()
            ->fetchAllAssociative();
        
        if (empty($fileReferences)) {
            return [];
        }
        
        $resourceFactory = GeneralUtility::makeInstance(ResourceFactory::class);
        $imageService = GeneralUtility::makeInstance(ImageService::class);
        $images = [];
        
        foreach ($fileReferences as $fileRef) {
            try {
                $fileReference = $resourceFactory->getFileReferenceObject($fileRef['uid']);
                $originalFile = $fileReference->getOriginalFile();
                
                // Process main image
                $processedImage = $imageService->applyProcessingInstructions(
                    $fileReference,
                    ['width' => '1874c', 'height' => '625c']
                );
                
                // Generate srcset
                $srcset = [];
                foreach ([400, 800, 1200, 1600] as $width) {
                    $processedVariant = $imageService->applyProcessingInstructions(
                        $fileReference,
                        ['width' => $width . 'c', 'height' => (int)($width / 3) . 'c']
                    );
                    $srcset[] = [
                        'url' => $imageService->getImageUri($processedVariant),
                        'width' => $width,
                        'descriptor' => $width . 'w',
                    ];
                }
                
                $images[] = [
                    'uid' => $fileRef['uid'],
                    'url' => $imageService->getImageUri($processedImage),
                    'title' => $fileReference->getTitle() ?: '',
                    'alternative' => $fileReference->getAlternative() ?: '',
                    'description' => $fileReference->getDescription() ?: '',
                    'srcset' => $srcset,
                    'properties' => [
                        'width' => $originalFile->getProperty('width'),
                        'height' => $originalFile->getProperty('height'),
                        'mimeType' => $originalFile->getMimeType(),
                    ],
                ];
            } catch (\Exception $e) {
                // Skip invalid file references
                continue;
            }
        }
        
        return $images;
    }
    
    /**
     * Get categories for a product
     */
    protected function getProductCategories(int $productUid): array
    {
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
            ->getQueryBuilderForTable('sys_category');
        
        $categories = $queryBuilder
            ->select('c.uid', 'c.title', 'c.description')
            ->from('sys_category', 'c')
            ->join(
                'c',
                'sys_category_record_mm',
                'mm',
                'mm.uid_local = c.uid AND mm.tablenames = ' . 
                $queryBuilder->createNamedParameter('tx_vitec_domain_model_product', ParameterType::STRING) . 
                ' AND mm.fieldname = ' . 
                $queryBuilder->createNamedParameter('categories', ParameterType::STRING)
            )
            ->where(
                $queryBuilder->expr()->eq('mm.uid_foreign', $queryBuilder->createNamedParameter($productUid, ParameterType::INTEGER)),
                $queryBuilder->expr()->eq('c.deleted', 0),
                $queryBuilder->expr()->eq('c.hidden', 0)
            )
            ->orderBy('mm.sorting', 'ASC')
            ->executeQuery()
            ->fetchAllAssociative();
        
        return array_map(function ($cat) {
            return [
                'uid' => (int)$cat['uid'],
                'title' => $cat['title'],
                'description' => $cat['description'] ?? '',
            ];
        }, $categories);
    }
    
    /**
     * Get all downloads for a product
     */
    protected function getProductDownloads(int $productUid): array
    {
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
            ->getQueryBuilderForTable('tx_vitec_domain_model_download');
        
        $downloads = $queryBuilder
            ->select('d.*')
            ->from('tx_vitec_domain_model_download', 'd')
            ->join(
                'd',
                'tx_vitec_product_download_mm',
                'mm',
                'mm.uid_foreign = d.uid'
            )
            ->where(
                $queryBuilder->expr()->eq('mm.uid_local', $queryBuilder->createNamedParameter($productUid, ParameterType::INTEGER)),
                $queryBuilder->expr()->eq('d.deleted', 0),
                $queryBuilder->expr()->eq('d.hidden', 0),
                $queryBuilder->expr()->eq('d.hideonwebsite', 0)
            )
            ->orderBy('mm.sorting', 'ASC')
            ->executeQuery()
            ->fetchAllAssociative();
        
        $result = [];
        foreach ($downloads as $download) {
            $fileInfo = null;
            
            // Get file information from FAL if file reference exists
            if (!empty($download['file'])) {
                $fileQueryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
                    ->getQueryBuilderForTable('sys_file_reference');
                
                $fileRef = $fileQueryBuilder
                    ->select('fr.uid', 'f.uid as file_uid', 'f.identifier', 'f.name', 'f.size', 'f.extension', 'f.mime_type')
                    ->from('sys_file_reference', 'fr')
                    ->join('fr', 'sys_file', 'f', 'fr.uid_local = f.uid')
                    ->where(
                        $fileQueryBuilder->expr()->eq('fr.uid_foreign', $fileQueryBuilder->createNamedParameter((int)$download['uid'], ParameterType::INTEGER)),
                        $fileQueryBuilder->expr()->eq('fr.tablenames', $fileQueryBuilder->createNamedParameter('tx_vitec_domain_model_download', ParameterType::STRING)),
                        $fileQueryBuilder->expr()->eq('fr.fieldname', $fileQueryBuilder->createNamedParameter('file', ParameterType::STRING)),
                        $fileQueryBuilder->expr()->eq('fr.deleted', 0),
                        $fileQueryBuilder->expr()->eq('f.missing', 0)
                    )
                    ->orderBy('fr.sorting_foreign', 'ASC')
                    ->setMaxResults(1)
                    ->executeQuery()
                    ->fetchAssociative();
                
                if ($fileRef) {
                    $fileInfo = [
                        'uid' => (int)$fileRef['file_uid'],
                        'name' => $fileRef['name'],
                        'url' => '/fileadmin' . $fileRef['identifier'],
                        'size' => (int)$fileRef['size'],
                        'extension' => $fileRef['extension'],
                        'mimeType' => $fileRef['mime_type'] ?? '',
                    ];
                }
            }
            
            $result[] = [
                'uid' => (int)$download['uid'],
                'title' => $download['title'] ?? '',
                'slug' => $download['slug'] ?? '',
                'teaser' => $download['teaser'] ?? '',
                'description' => $download['description'] ?? '',
                'keywords' => $download['keywords'] ?? '',
                'icon' => $download['icon'] ?? '',
                'file' => $fileInfo,
            ];
        }
        
        return $result;
    }
}