<?php

/*
 * This file is part of the Maestro Project.
 * Copyright (C) Compos Juliot
 */

namespace App\Application\Query;

use App\Application\Adapter\Query\StoryQueryInterface;
use App\Application\View\Value\ValueView;
use App\Domain\Adapter\DataDiffInterface;
use App\Domain\Adapter\ExportsRepositoryInterface;
use App\Domain\Adapter\LayoutRepositoryInterface;
use App\Domain\Adapter\ProjectRepositoryInterface;
use App\Domain\Adapter\ValueRepositoryInterface;
use App\Domain\Entity\ElementField;
use App\Domain\Entity\Input;
use App\Domain\Entity\PageDuplicate;
use App\Domain\Entity\Value;
use App\Domain\Entity\VariableProject;
use App\Domain\Entity\VersionExport;
use App\Infrastructure\Adapter\Provider\Element\ElementCollectInterface;
use App\Infrastructure\Adapter\Provider\ElementValue\ElementValueCollectInterface;
use Doctrine\ORM\EntityManagerInterface;

class ValueQuery
{
    /** @var ProjectRepositoryInterface */
    private $projectRepository;

    /** @var ValueRepositoryInterface */
    private $valueRepository;

    /** @var ExportsRepositoryInterface */
    private $exportsRepository;

    /** @var StoryQueryInterface */
    private $story;

    /** @var DataDiffInterface */
    private $dataDiff;

    /** @var EntityManagerInterface */
    private $entityManager;

    /** @var ElementCollectInterface */
    private $elementProvider;

    /** @var ElementValueCollectInterface */
    private $elementValueProvider;

    /** @var LayoutRepositoryInterface */
    private $layoutrepository;

    private const TOKEN_BYTES = 9;

    public function __construct(
        ProjectRepositoryInterface $projectRepository,
        EntityManagerInterface $entityManager,
        ValueRepositoryInterface $valueRepository,
        ExportsRepositoryInterface $exportsRepository,
        StoryQueryInterface $story,
        DataDiffInterface $dataDiff,
        ElementCollectInterface $elementProvider,
        ElementValueCollectInterface $elementValueProvider,
        LayoutRepositoryInterface $layoutrepository
    ) {
        $this->projectRepository = $projectRepository;
        $this->entityManager = $entityManager;
        $this->valueRepository = $valueRepository;
        $this->exportsRepository = $exportsRepository;
        $this->story = $story;
        $this->dataDiff = $dataDiff;
        $this->elementProvider = $elementProvider;
        $this->elementValueProvider = $elementValueProvider;
        $this->layoutrepository = $layoutrepository;
    }

    /**
     * @param mixed $field
     * @param mixed $elementField
     *
     * @return bool
     */
    public function create($field, $elementField): bool  //TODO if it will use or delete
    {
        $values = $this->valueRepository->read($field['id']); // todo there is no function read i
        foreach ($values as $value) {
            $val = new Value();
            $val->setValue($value['value']);
            $val->setValueId($value['id']);
            $val->setField($elementField);
            $this->valueRepository->create($val);

            if (!$val->getId()) {
                return false;
            }
        }

        return true;
    }

    /**
     * @param ValueView $view
     *
     * @return array|null
     */
    public function save(ValueView $view): ?array
    {

        $value = null;
        if (isset($view->id) && $view->id > 0) {
            $value = $this->updateValue($view);
        } else {
            $value = $this->saveValue($view);
        }
        $resultValue = json_decode($value->getValue(), true);
        if ($resultValue && isset($resultValue['collections'])) {
            $result =  $value->getId() ? ["id" => $value->getId(), "value" => $resultValue['collections'], "type" => "collection"] : null;
        } else {
            $result =  $value->getId() ? ["id" => $value->getId(), "value" => $value->getValue(), "type" => "value"] : null;
        }


        return $result;
    }
    /**
     * Save a new Value 
     */
    private function saveValue(ValueView $view)
    {
        $variableProjectRepository = $this->entityManager->getRepository(VariableProject::class);
        $variableProject = $variableProjectRepository->findOneBy(['id' => $view->variableProjectId]);
        $value = new Value();
        isset($view->variableProjectId) && $view->variableProjectId ? $value->setVariableProject($variableProject) : 0;
        isset($view->pimElementId) && $view->pimElementId ? $value->setPimElementId($view->pimElementId) : 0;
        isset($view->pimElementTypeFieldId) && $view->pimElementTypeFieldId ? $value->setPimElementTypeFieldId($view->pimElementTypeFieldId) : 0;
        isset($view->flatplanPageId) && $view->flatplanPageId ? $value->setFlatplanPageId($view->flatplanPageId) : 0;

        if (isset($view->version) && $view->version) {
            $versionRepository = $this->entityManager->getRepository(VersionExport::class);
            $version = $versionRepository->findOneBy(["id" => $view->version]);
            $value->setVersion($version);
        }
        if (isset($view->pageDuplicateId) && $view->pageDuplicateId) {
            $pageDuplicateRepository = $this->entityManager->getRepository(PageDuplicate::class);
            $pageDuplicate = $pageDuplicateRepository->findOneBy(["id" => $view->pageDuplicateId]);
            $value->setPageDuplicate($pageDuplicate);
        }

        $newValue = $view->value;
        if (isset($view->valuePimId)) {
            $value->setValuePimId($view->valuePimId);

            $input = $variableProjectRepository->findOneBy(["id" => $view->templateInputId]);
            if (!empty($input)) {
                $value->setInputProject($input);
            }
            $value->setCollection($view->collection);
            $value->setPimInputId($view->pimInputId);
        }

        $value->setValue($newValue);

        $export = $this->exportsRepository->findById($view->idExport);
        $value->setExport($export);
        $value = $this->valueRepository->create($value);
        $result = null;
        if ($value->getId()) {

            $diff[] = ['oldValue' => ['value' => ''], 'newValue' => ['value' => $view->value]];

            $this->saveStory($diff, $value);

            $result = $value;
        }
        return $result;
    }

    /**
     * Update a Value
     */
    private function  updateValue(ValueView $view)
    {
        if ($view->version) {
            $value = $this->valueRepository->findByIdAndPageDuplicate($view->id, $view->pageDuplicateId);
        } else {
            $value = $this->valueRepository->findById($view->id);
        }

        if (empty($value)) {
            $result = $this->saveValue($view);
        } else {

            $oldValue =  $value->getValue();
            if (isset($view->valuePimId)) {
                $value->setValuePimId($view->valuePimId);
                $variableProjectRepository = $this->entityManager->getRepository(VariableProject::class);

                $input = $variableProjectRepository->findOneBy(["id" => $view->templateInputId]);

                if (!empty($input)) {
                    $value->setInputProject($input);
                }
                $value->setCollection($view->collection);
                $value->setPimInputId($view->pimInputId);
            }
            $diff[] = ['oldValue' => ['value' => $oldValue], 'newValue' => ['value' => $view->value]];

            $value->setValue($view->value);
            $entity = $this->valueRepository->update($value);

            $result = null;
            if ($entity) {
                $this->saveStory($diff, $value);

                $result = $value;
            }
        }
        return $result;
    }


    /**
     * save the story 
     */
    private function saveStory($diff, $value)
    {
        if (!empty($diff)) {
            $this->story->execute('update', $diff, $value->getId(), get_class($value), 0);
        }
    }

    public function deleteValue($idValue, $elementId, $elementTypeFieldId, $pageDuplicateId, $layout)
    {
        $result = null;
        $value = null;
        if(!empty($idValue)){
            if(!empty($pageDuplicateId)){
                $value = $this->valueRepository->findByIdAndPageDuplicate($idValue, $pageDuplicateId);   
            }else{
                $value = $this->valueRepository->findById($idValue);
            }
        }
        
        if(!empty($value)){
            $this->valueRepository->remove($value);
        }
        if(!empty($elementId) && !empty($elementTypeFieldId)){
            $result = null;
            $data = $this->elementValueProvider->readMultiple([$elementId], [$elementTypeFieldId], false);

            if($data['type'] == "success" ){
                $defaultField = $data['data'][$elementId]["fields"][$elementTypeFieldId];
                if(in_array($defaultField["fieldType"], ["fieldset", "productLink"])){
                    $result = [];
                    $layout = $this->layoutrepository->findById($layout);
                    if(!empty($layout)){
                        $fieldset = $layout->getInputs();
                        $collections = $defaultField["fieldType"] == "fieldset" ? $defaultField['collections'] : $defaultField['elements'];
                        foreach ($collections as $key => $collection) {
                            $col = [];
                            foreach ($fieldset as $input) {
                                $inputs = $defaultField["fieldType"] == "fieldset" ? $collection : $collection['inputs'];
                                $index = array_search($input["inputId"], array_column($inputs,'inputId'));
                                $col[] = [
                                    "collection" => $key,
                                    "editable" => $input['editable'],
                                    "fieldType" => array_values($inputs)[$index]['fieldType'],
                                    "name" => $input['inputName'],
                                    "pimInputId" => $input['inputId'],
                                    "twigVar" => $input['name'],
                                    "value" => array_values($inputs)[$index]['value'],
                                    "valuePimId" => array_values($inputs)[$index]['id'],
                                    "valueProjectId" => null,
                                    "variableProjectId" => $input['variableProjectId'],
                                    "listValue" => isset(array_values($inputs)[$index]['listValue']) ? array_values($inputs)[$index]['listValue'] : []
                                ];
                            }
                            if($defaultField["fieldType"] == "fieldset" ){
                                $result[] = $col;
                            } else {
                                $result[] = [
                                    "id" => $key,
                                    "name" => $collection['name'],
                                    "value" => $col,
                                ];
                            }
                        }
                    }
                } else {
                    $result = $defaultField['value'];
                }
            }
        }
        return $result;
    }
}