<?php

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

namespace Maestro\Component\Workflow\Repository;

use App\Domain\Entity\Workflow\Place;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\NonUniqueResultException;
use Psr\Container\ContainerInterface;

class PlacesRepository
{
    /** @var EntityManagerInterface */
    private $entityManager;

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

    public function __construct(
        EntityManagerInterface $entityManager,
        ContainerInterface $container
    ) {
        $this->entityManager = $entityManager;
        $this->container = $container;
    }

    /**
     * @return Place
     */
    public function create(Place $place)
    {
        $this->entityManager->persist($place);
        $this->entityManager->flush();

        return true;
    }

    /**
     * @param $name
     *
     * @throws NonUniqueResultException
     *
     * @return mixed
     */
    public function findByName(string $name, int $config)
    {
        return $this->entityManager
            ->createQueryBuilder()
            ->select('p')
            ->from(Place::class, 'p')
            ->innerJoin('p.configuration', 'c')
            ->where('p.name = :query')
            ->andWhere('c.id = :config')
            ->setParameters(['query'=> $name, 'config' => $config])
            ->getQuery()
            ->getOneOrNullResult()
            ;
    }

    /**
     * @return mixed
     */
    public function findAll()
    {
        return $this->entityManager
            ->createQueryBuilder()
            ->select('p')
            ->from(Place::class, 'p')
            ->getQuery()
            ->getResult()
            ;
    }

    public function findByKey(string $key)
    {
        return $this->entityManager
            ->createQueryBuilder()
            ->select('p')
            ->from(Place::class, 'p')
            ->where('p.key = :key')
            ->setParameter('key', $key)
            ->getQuery()
            ->getOneOrNullResult();
    }

    public function findByConfigId(int $configId)
    {
        return $this->entityManager
            ->createQueryBuilder()
            ->select('p')
            ->from(Place::class, 'p')
            ->where('p.configuration = :configId')
            ->setParameter('configId', $configId)
            ->getQuery()
            ->getResult();
    }

    public function remove(string $Place_id, int $config_id, string $module)
    {
        try {
            $query = $this->entityManager->createQuery();

            $query->setDQL(
                'DELETE FROM '.Place::class.' p
                WHERE p.id NOT IN (' . $Place_id . ')
                AND p.configuration = ' . $config_id
            );

            $query->execute();

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


    }

    public function findById(int $id)
    {
        return $this->entityManager->createQueryBuilder()
        ->select('p')
        ->from(Place::class, 'p')
        ->where('p.id = :id')
        ->setParameter('id', $id)
        ->getQuery()
        ->getOneOrNullResult();
    }

    public function findByIds(array $id)
    {
        $qb = $this->entityManager->createQueryBuilder();
        return $qb->select('p')
        ->from(Place::class, 'p')
        ->where($qb->expr()->in('p.id', $id))
        ->getQuery()
        ->getResult();
    }

    public function findFirstPlace(array $places)
    {
        $qb = $this->entityManager->createQueryBuilder();

        return $qb->select('p.color')
        ->from(Place::class, 'p')
        ->where($qb->expr()->in('p.key', $places))
        ->orderBy('p.id', 'ASC')
        ->setMaxResults(1)
        ->getQuery()
        ->getResult();
    }
}