<?php

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

namespace App\Application\Query\ElementMedia;

use App\Application\Adapter\Query\ElementMedia\UpdateQueryInterface;
use App\Application\View\ElementMedia\UpdateView;
use App\Application\Adapter\GenerationInterface;
use App\Domain\Adapter\ExportsRepositoryInterface;
use App\Application\Adapter\Query\StoryQueryInterface;
use App\Application\Exception\SubException\NotFoundMaestroException;
use App\Application\Exception\SubException\UnprocessableEntityMaestroException;
use App\Domain\Adapter\Media\ElementMediaRepositoryInterface;
use App\Domain\Entity\ElementMedia;
use App\Domain\Entity\PageDuplicate;
use App\Domain\Entity\VariableProject;
use App\Domain\Entity\VersionExport;
use App\Infrastructure\Adapter\Provider\Media\MediaCollectInterface;
use Doctrine\ORM\EntityManagerInterface;
use Exception;

class UpdateQuery implements UpdateQueryInterface
{
    /** @var ElementMediaRepositoryInterface */
    private $elementMediaRepository;

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

    /** @var GenerationInterface */
    private $generation;

    /** @var MediaCollectInterface */
    private $mediaCollect;

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

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

    public function __construct(
        StoryQueryInterface $story,
        ElementMediaRepositoryInterface $elementMediaRepository,
        ExportsRepositoryInterface $exportsRepository,
        GenerationInterface $generation,
        MediaCollectInterface $mediaCollect,
        EntityManagerInterface $entityManager
    ) {
        $this->story = $story;
        $this->elementMediaRepository = $elementMediaRepository;
        $this->exportsRepository = $exportsRepository;
        $this->generation = $generation;
        $this->mediaCollect = $mediaCollect;
        $this->entityManager = $entityManager;
    }

    /**
     * @param array $views
     *
     * @return UpdateView|array
     */
    public function update(array $views)
    {
        $result = [];

        foreach ($views as $view) {
            $scenario = "";
            $diff = [];

            if (isset($view->id)) {
                if (isset($view->version) && $view->version > 0) {
                    $elementMedia = $this->elementMediaRepository->findByIdAndVersion($view->id, $view->version);
                } else {
                    $elementMedia = $this->elementMediaRepository->findById($view->id);
                }
            } else {
                $elementMedia = new ElementMedia();
            }

            if (null !== $elementMedia) {
                $elementMedia->setMediaId($view->mediaId);

                if (null === $view->linkData || -1 !== $view->mediaId) {
                    $elementMedia->setLinkData($view->linkData);
                } else {
                    $elementMedia->setLinkData(json_encode($view->linkData));
                }

                $export = $this->exportsRepository->findById($view->exportId);

                if (null !== $export) {
                    if (!empty($view->dateValid)) {
                        $dateTimeFormatdmY = \DateTime::createFromFormat('d/m/Y', $view->dateValid);
                        if ($dateTimeFormatdmY) {
                            $dateNewFormat = $dateTimeFormatdmY->format("Y-m-d H:i");
                            $date = new \DateTime($dateNewFormat);
                        } else {
                            $date = null;
                        }
                    } else {
                        $date = null;
                    }

                    $diff = [
                        "old" => [
                            "mediaId" => $elementMedia->getMediaId(),
                            "copyright" => $elementMedia->getCopyright(),
                            "legend" => $elementMedia->getLegend(),
                            "dateValid" => $elementMedia->getDateValid()
                        ],
                        "new" => [
                            "mediaId" => $view->mediaId,
                            "copyright" => $view->copyright,
                            "legend" => $view->legend,
                            "dateValid" => $date
                        ]
                    ];

                    $elementMedia->setExport($export);

                    $elementMedia->setHeightMedia($view->heightMedia);
                    $elementMedia->setWidthMedia($view->widthMedia);
                    $elementMedia->setRotateMedia($view->rotateMedia);
                    $elementMedia->setX($view->x);
                    $elementMedia->setY($view->y);
                    if (isset($view->element)) {
                        $elementMedia->setElementPIM($view->element);
                    }
                    if (isset($view->templatePositionMedia)) {
                        $elementMedia->setTemplatePositionMedia($view->templatePositionMedia);
                    }
                    if (isset($view->variableProjectId)) {
                        $variableProjectRepo = $this->entityManager->getRepository(VariableProject::class);
                        $variableProject = $variableProjectRepo->findOneBy([
                            "id" => $view->variableProjectId
                        ]);
                        if (!empty($variableProject)) {
                            $elementMedia->setVariableProject($variableProject);
                        }
                    }
                    $elementMedia->setFlatplanPageId($view->flatplanPageId);
                    $elementMedia->setFlipVertical($view->flipVertical);
                    $elementMedia->setFlipHorizontal($view->flipHorizontal);
                    $elementMedia->setCopyright($view->copyright);
                    $elementMedia->setLegend($view->legend);

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


                    $elementMedia = $this->elementMediaRepository->save($elementMedia);

                    if (!$elementMedia instanceof Exception) {
                        $this->story->execute('updatePosPhoto', $diff, $elementMedia->getId(), get_class($elementMedia), 0);
                        $meds = $this->mediaCollect->collectMediaByIds(["medias" => [$elementMedia->getMediaId()], "def" => "bd"]);

                        if (!$meds instanceof Exception) {
                            $thumb = '';
                            $thumbPath = '';
                            if (!empty($meds)) {
                                $thumb = !empty($meds) ? $this->getThumb($meds, $elementMedia) : "";
                                $thumbPath = $thumb ? '' : reset($meds)['thumbPath'];
                            }

                            $result = new UpdateView(
                                $elementMedia->getId(),
                                $elementMedia->getMediaId(),
                                $elementMedia->getExport()->getId(),
                                $elementMedia->getWidthMedia(),
                                $elementMedia->getHeightMedia(),
                                $elementMedia->getRotateMedia(),
                                $elementMedia->getX(),
                                $elementMedia->getY(),
                                $elementMedia->getElementPIM(),
                                $elementMedia->getTemplatePositionMedia(),
                                $elementMedia->getFlatplanPageId(),
                                $elementMedia->getFlipVertical(),
                                $elementMedia->getFlipHorizontal(),
                                $thumb,
                                $thumbPath,
                                !empty($elementMedia->getVariableProject()) ? $elementMedia->getVariableProject()->getId() : null,
                                !empty($elementMedia->getVersion()) ? $elementMedia->getVersion()->getId() : null,
                                $elementMedia->getCopyright(),
                                $elementMedia->getLegend(),
                                !empty($elementMedia->getDateValid()) ? $elementMedia->getDateValid()->format("d/m/Y") : null,
                                !empty($elementMedia->getPageDuplicate()) ? $elementMedia->getPageDuplicate()->getId() : null,
                                null !== $elementMedia->getLinkData() ? json_decode($elementMedia->getLinkData(), true) : null
                            );
                        } else {
                            if (count($views) === 1) {
                                $result = $meds;
                            } else {
                                $result[] = $meds;
                            }
                        }
                    } else {
                        if (count($views) === 1) {
                            $result = $elementMedia;
                        } else {
                            $result[] = $elementMedia;
                        }
                    }
                } else {
                    throw new NotFoundMaestroException("No export found for id : '$view->exportId'");
                }
            } else {
                throw new UnprocessableEntityMaestroException("No element media to process, id given is : '$view->id'");
            }
        }

        return $result;
    }

    /**
     * @param array $meds
     * @param ElementMedia $elementMedia
     * 
     * @return string
     */
    private function getThumb(array $meds, ElementMedia $elementMedia): string
    {
        $crop = [
            "height" => $elementMedia->getHeightMedia(),
            "width" => $elementMedia->getWidthMedia(),
            "x" => $elementMedia->getX(),
            "y" => $elementMedia->getY(),
            "rotate" => $elementMedia->getRotateMedia(),
            "flipVertical" => $elementMedia->getFlipVertical(),
            "flipHorizontal" => $elementMedia->getFlipHorizontal()
        ];

        $meds = reset($meds);
        if ($meds['fileBd']) {
            $fileBdToGet = $meds['fileBd'];
            $fileToGet = $meds['thumb'];
            $isBase64 = true;
        } else {
            $fileBdToGet = $meds['fileBdPath'];
            $fileToGet = $meds['thumbPath'];
            $isBase64 = false;
        }
        return $this->generation->cropMediaImage($fileToGet, $crop, $fileBdToGet, $isBase64);
    }

    public function updateField(int $id, array $fields)
    {
        $elementMediaRepository = $this->entityManager->getRepository(ElementMedia::class);
        $elementMedia = $elementMediaRepository->findOneBy(["id" => $id]);

        $result = false;
        if (!empty($elementMedia)) {
            $elementMedia->setCopyright($fields['copyright']);
            $elementMedia->setLegend($fields['legend']);
            if (!empty($fields['dateValid'])) {
                $date = new \DateTime($fields['dateValid']);
            } else {
                $date = null;
            }

            $elementMedia->setDateValid($date);

            $this->entityManager->persist($elementMedia);
            $this->entityManager->flush();

            $result = true;
        }

        return $result;
    }
}