<?php

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

namespace App\Infrastructure\Repository;

use App\Domain\Adapter\ValueRepositoryInterface;
use App\Domain\Entity\Page;
use App\Domain\Entity\Value;
use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\NonUniqueResultException;
use Doctrine\Persistence\ManagerRegistry;
use Exception;
use Psr\Container\ContainerInterface;

/**
 * @method Value|null find($id, $lockMode = null, $lockVersion = null)
 * @method Value|null findOneBy(array $criteria, array $orderBy = null)
 * @method Value[]    findAll()
 * @method Value[]    findBy(array $criteria, array $orderBy = null, $limit = null, $offset = null)
 */
class ValueRepository extends ServiceEntityRepository implements ValueRepositoryInterface
{
    /** @var EntityManagerInterface */
    private $entityManager;

    /** @var ContainerInterface */
    private $container;

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

    /**
     * 
     * @return array [description]
     */
    public function list()
    {
        return $this->entityManager
            ->createQueryBuilder()
            ->select('v')
            ->from(Value::class, 'v')
            ->getQuery()
            ->getResult();
    }

    /**
     * @param Value $value [description]
     * 
     * @return Value|bool [description]
     */
    public function create(Value $value)
    {
        try {
            $this->entityManager->persist($value);
            $this->entityManager->flush();

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

    /**
     * @param int $valueId [description]
     * @param int $idField [description]
     * 
     * @throws NonUniqueResultException
     * 
     * @return Value|null [description]
     */
    public function alreadySave(int $valueId, int $idField): ?Value
    {
        return $this->entityManager
            ->createQueryBuilder()
            ->select('v')
            ->from(Value::class, 'v')
            ->where('v.valueId = :valueId')
            ->andWhere('v.field = :idField')
            ->setParameters(['valueId' => $valueId, 'idField' => $idField])
            ->getQuery()
            ->getOneOrNullResult();
    }

    /**
     * @param Value $value [description]
     * 
     * @return bool [description]
     */
    public function remove(Value $value): bool
    {
        try {
            $this->entityManager->remove($value);
            $this->entityManager->flush();

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

    /**
     * @param Value $value [description]
     * 
     * @return bool [description]
     */
    public function update(Value $value): bool
    {
        try {
            $this->entityManager->persist($value);
            $this->entityManager->flush();

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

    /**
     * @param int $pimElementId [description]
     * @param int $idExport [description]
     * @param int $pageId [description]
     * 
     * @return array [description]
     */
    public function getValues(int $pimElementId, int $idExport, int $pageId): array
    {
        return $this->entityManager
            ->createQueryBuilder()
            ->select('v', 'e')
            ->from(Value::class, 'v')
            ->innerJoin('v.export', 'e')
            ->where('e.id = :idExport')
            ->andWhere('v.pimElementId = :pimElementId')
            ->andWhere('v.flatplanPageId = :pageId')
            ->andWhere('v.version is null')
            ->andWhere('v.deletedAt is null')
            ->setParameters(['pimElementId' => $pimElementId, 'idExport' => $idExport, 'pageId' => $pageId])
            ->getQuery()
            ->getResult();
    }

    /**
     * @param int $pimElementId [description]
     * @param int $idExport [description]
     * @param int $pageId [description]
     * @param array $templateFieldId [description]
     * 
     * @return array [description]
     */
    public function getValuesMaster(?int $pimElementId, int $idExport, int $pageId, array $templateFieldId): array
    {
        $qb = $this->entityManager
            ->createQueryBuilder();

        $qb->select('v', 'e')
            ->from(Value::class, 'v')
            ->innerJoin('v.export', 'e')
            ->where('e.id = :idExport');

        if (!empty($pimElementId)) {
            $qb->andWhere($qb->expr()->in('v.pimElementId', $pimElementId));
        } else {
            $qb->andWhere('v.pimElementId is null');
        }
        return $qb->andWhere('v.flatplanPageId = :pageId')
            ->andWhere($qb->expr()->notIn('v.templateFieldId', $templateFieldId))
            ->andWhere('v.version is null')
            ->andWhere('v.deletedAt is null')
            ->setParameters(['idExport' => $idExport, 'pageId' => $pageId])
            ->getQuery()
            ->getResult();
    }

    /**
     * @param int $pimElementId [description]
     * @param int $idExport [description]
     * @param int $pageId [description]
     * @param int $version [description]
     * 
     * @return array [description]
     */
    public function getValuesByVersionDuplicate(int $pimElementId, int $idExport, int $pageId, int $duplicate): array
    {
        return $this->entityManager
            ->createQueryBuilder()
            ->select('v', 'e')
            ->from(Value::class, 'v')
            ->innerJoin('v.export', 'e')
            ->innerJoin('v.pageDuplicate', 'p')
            ->where('e.id = :idExport')
            ->andWhere('v.pimElementId = :pimElementId')
            ->andWhere('v.flatplanPageId = :pageId')
            ->andWhere('p.id = :pageDuplicate')
            ->andWhere('v.deletedAt is null')
            ->setParameters(['pimElementId' => $pimElementId, 'idExport' => $idExport, 'pageId' => $pageId, 'pageDuplicate' => $duplicate])
            ->getQuery()
            ->getResult();
    }

    /**
     * @param int $idProject [description]
     * @param int $idPim [description]
     * @param int $idField [description]
     * 
     * @return array [description]
     */
    public function findByProjectIdPimIdFieldId(int $idProject, int $idPim, int $idField): array
    {
        // TODO : Use Query Builder
        $connection = $this->container->get('doctrine.dbal.projects_connection');

        $sql = '
        SELECT DISTINCT v.id, v.field_id, v.valueId, v.value
        FROM value AS v
        INNER JOIN element_field AS ef ON v.field_id = ef.id
        INNER JOIN element AS e ON ef.element_id = e.id
        INNER JOIN element_type AS et ON e.elementType_id = et.id
        WHERE v.valueId = ' . $idPim . '
        AND v.field_id = ' . $idField . '
        AND et.project_id = ' . $idProject;

        $sql = $connection->prepare($sql);
        $sql->execute();

        return $sql->fetch();
    }

    /**
     * @param int $id [description]
     * 
     * @throws NonUniqueResultException
     * 
     * @return Value|null [description]
     */
    public function findById(int $id): ?Value
    {
        return $this->entityManager
            ->createQueryBuilder()
            ->select('v')
            ->from(Value::class, 'v')
            ->where('v.id = :id')
            ->setParameter('id', $id)
            ->getQuery()
            ->getOneOrNullResult();
    }

    /**
     * @param int $id [description]
     * @param int $version [description]
     * 
     * @throws NonUniqueResultException
     * 
     * @return Value|null [description]
     */
    public function findByIdAndPageDuplicate(int $id, int $pageDuplicateId): ?Value
    {
        return $this->entityManager
            ->createQueryBuilder()
            ->select('v')
            ->from(Value::class, 'v')
            ->innerJoin('v.pageDuplicate', 'p')
            ->where('v.id = :id')
            ->andWhere('p.id = :pageDuplicateId')
            ->setParameters(['id' => $id, "pageDuplicateId" => $pageDuplicateId])
            ->getQuery()
            ->getOneOrNullResult();
    }

    /**
     * @param Value $value [description]
     * 
     * @return array [description]
     */
    public function diff(Value $value): array
    {
        $uow = $this->entityManager->getUnitOfWork();
        $uow->computeChangeSets();

        return $uow->getEntityChangeSet($value);
    }

    /**
     * @param int $idElemFieldPim [description]
     * @param int $idElemTypeField [description]
     * 
     * @return array [description]
     */
    public function findFieldId(int $idElemFieldPim, int $idElemTypeField): array
    {
        // TODO : Use Query Builder
        $connection = $this->container->get('doctrine.dbal.projects_connection');

        $sql = '
        SELECT ef.id
        FROM element_field AS ef
        WHERE ef.elementFieldId = ' . $idElemFieldPim . '
        AND ef.elementTypeFieldId = ' . $idElemTypeField;

        $sql = $connection->prepare($sql);
        $sql->execute();

        return $sql->fetch();
    }

    /**
     * @param array $pages_id [description]
     * 
     * @return array [description]
     */
    public function findByPages(array $pages_id): array
    {
        $qb = $this->entityManager->createQueryBuilder();

        return $qb->select('v')
            ->from(Value::class, 'v')
            ->where($qb->expr()->in('v.flatplanPageId', $pages_id))
            ->getQuery()
            ->getResult();
    }

    /**
     * @param array $page_id [description]
     * 
     * @return array [description]
     */
    public function getValueByPageId(int $page_id): array
    {
        $qb = $this->entityManager->createQueryBuilder();

        return $qb->select('v')
            ->from(Value::class, 'v')
            ->where('v.flatplanPageId = :page_id')
            ->setParameter('page_id',  $page_id)
            ->getQuery()
            ->getResult();
    }

    /**
     * @param array $values [description]
     * 
     * @return bool|Exception [description]
     */
    public function removeMultiple(array $values)
    {
        try {
            foreach ($values as $value) {
                $this->entityManager->remove($value);
            }

            $this->entityManager->flush();

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

        return $result;
    }

    /**
     * @param array $exportIds [description]
     * @param int $templateFieldId [description]
     * @param int $elementTypeFieldId [description]
     * 
     * @return array [description]
     */
    public function findByExportIdsAndAssociations(array $exportIds, int $variableProjectId, ?int $elementTypeFieldId): array
    {
        $qb = $this->entityManager->createQueryBuilder();
        $qb->select('v')
            ->from(Value::class, 'v')
            ->innerJoin('v.variableProject','vp')
            ->where($qb->expr()->in('v.export', $exportIds))
            ->andWhere('vp.id = :variableProjectId')
            ->andWhere('v.pimElementTypeFieldId = :pimElementTypeFieldId')
            ->andWhere('v.deletedAt is null')
            ->setParameters([
                'variableProjectId' => $variableProjectId,
                'pimElementTypeFieldId' => $elementTypeFieldId
            ]);

        $result = $qb->getQuery()->getResult();


        return $result;
    }

    /**
     * @param array templateFieldIds
     * 
     * @return array
     */
    public function findByTemplateFieldIds(array $templateFieldIds): array
    {
        $qb = $this->entityManager->createQueryBuilder();

        return $qb->select('v')
            ->from(Value::class, 'v')
            ->where($qb->expr()->in('v.templateFieldId', $templateFieldIds))
            ->andWhere('v.deletedAt is null')
            ->getQuery()
            ->getResult();
    }

    /**
     * {@inheritDoc}
     */
    public function findByProjectLayoutAssociation(int $projectId, int $templateFieldId, ?int $pimElementTypeFieldId): array
    {
        $qb = $this->entityManager->createQueryBuilder();

        $qb->select('v')
            ->from(Value::class, 'v')
            ->innerJoin('v.export', 'e')
            ->where('v.templateFieldId = :templateFieldId')
            ->andWhere('e.project = :projectId')
            ->andWhere('v.deletedAt is null')
            ->andWhere('e.archived = false');

        if (isset($pimElementTypeFieldId)) {
            $qb->andWhere('v.pimElementTypeFieldId = :pimElementTypeFieldId')
                ->setParameters(["projectId" => $projectId, "templateFieldId" => $templateFieldId, "pimElementTypeFieldId" => $pimElementTypeFieldId]);
        } else {
            $qb->andWhere('v.pimElementTypeFieldId is null')
                ->setParameters(["projectId" => $projectId, "templateFieldId" => $templateFieldId]);
        }

        return $qb->getQuery()
            ->getResult();
    }


    /**
     * {@inheritDoc}
     */
    public function saveMultiple(array $values): void
    {
        foreach ($values as $value) {
            $this->entityManager->persist($value);
        }

        $this->entityManager->flush();
    }
}