<?php

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

namespace App\Infrastructure\Repository\Media;

use App\Domain\Adapter\Media\ElementMediaRepositoryInterface;
use App\Domain\Entity\ElementMedia;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\NonUniqueResultException;
use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
use Doctrine\Persistence\ManagerRegistry;
use Exception;

class ElementMediaRepository extends ServiceEntityRepository implements ElementMediaRepositoryInterface
{
    /** @var EntityManagerInterface */
    private $entityManager;

    public function __construct(
        ManagerRegistry $registry,
        EntityManagerInterface $entityManager
    ) {
        parent::__construct($registry, ElementMedia::class);
        $this->entityManager = $entityManager;
    }

    /**
     * @param ElementMedia $elementMedia
     *
     * @return ElementMedia|Exception
     */
    public function save(ElementMedia $elementMedia)
    {
        try {
            $this->entityManager->persist($elementMedia);
            $this->entityManager->flush();

            $result = $elementMedia;
        } catch (Exception $e) {
            $result = $e;
        }

        return $result;
    }

    /**
     * @throws NonUniqueResultException
     *
     * @return mixed
     */
    public function findById(int $id)
    {
        return $this->entityManager
            ->createQueryBuilder()
            ->select('e')
            ->from(ElementMedia::class, 'e')
            ->where('e.id = :id')
            ->andWhere('e.deletedAt is null')
            ->setParameter('id', $id)
            ->getQuery()
            ->getOneOrNullResult();
    }

    /**
     * @throws NonUniqueResultException
     *
     * @return mixed
     */
    public function findByIdAndVersion(int $id, int $version)
    {
        return $this->entityManager
            ->createQueryBuilder()
            ->select('e')
            ->from(ElementMedia::class, 'e')
            ->innerJoin('e.version','v')
            ->where('e.id = :id')
            ->andWhere('v.id = :version')
            ->andWhere('e.deletedAt is null')
            ->setParameters(['id' => $id, 'version' => $version])
            ->getQuery()
            ->getOneOrNullResult();
    }

    /**
     * @return mixed
     */
    public function findAllByElement(int $id)
    {
        return $this->entityManager
            ->createQueryBuilder()
            ->select('e')
            ->from(ElementMedia::class, 'e')
            ->innerJoin('e.element', 'el')
            ->where('el.id = :id')
            ->setParameter('id', $id)
            ->getQuery()
            ->getResult();
    }

    /**
     * @throws NonUniqueResultException
     * @throws Exception
     */
    public function delete(int $id): bool
    {
        $elementMedia = $this->findById($id);

        try {
            $this->entityManager->remove($elementMedia);
            $this->entityManager->flush();

            return true;
        } catch (Exception $exception) {
            return false;
        }
    }

    /**
     * @param int $pageId [page's id]
     *
     * @return array [Export_Medias for this page]
     */
    public function findByPage(int $pageId): array
    {
        return $this->entityManager
            ->createQueryBuilder()
            ->select('e')
            ->from(ElementMedia::class, 'e')
            ->where('e.flatplanPageId = :pageId')
            ->andWhere('e.deletedAt is null')
            ->setParameter('pageId', $pageId)
            ->getQuery()
            ->getResult();
    }

    /**
     * @param int $esportId
     *
     * @return array [Export_Medias for this export]
     */
    public function findByExport(int $exportId): array
    {
        return $this->entityManager
            ->createQueryBuilder()
            ->select('e')
            ->from(ElementMedia::class, 'e')
            ->innerJoin('e.export', 'exp')
            ->where('exp.id = :exportId')
            ->andWhere('e.deletedAt is null')
            ->setParameter('exportId', $exportId)
            ->getQuery()
            ->getResult();
    }

    /**
     * @param array $mediaIds
     *
     * @return array [Export_Medias for these template media ids]
     */
    public function findByTemplateMediaIds(array $mediaIds): array
    {
        $qb = $this->entityManager->createQueryBuilder();

        return $qb->select('em')
            ->from(ElementMedia::class, 'em')
            ->where($qb->expr()->in('em.templateMediaId', ':mediaIds'))
            ->andWhere('em.deletedAt is null')
            ->setParameter('mediaIds', $mediaIds)
            ->getQuery()
            ->getResult();
    }

    /**
     * @param array $medias
     * 
     * @return bool | Exception
     */
    public function removeMultiple(array $medias)
    {
        try {
            foreach ($medias as $media) {
                $this->entityManager->remove($media);
            }

            $this->entityManager->flush();
            $result = true;
        } catch (Exception $e) {
            $result = $e;
        }

        return $result;
    }

    
}