<?php

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

namespace App\Infrastructure\Repository;

use App\Domain\Adapter\ElementTypeRepositoryInterface;
use App\Domain\Entity\ElementType;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\NonUniqueResultException;
use Exception;
use Psr\Container\ContainerInterface;

class ElementTypeRepository implements ElementTypeRepositoryInterface
{
    /** @var EntityManagerInterface */
    private $entityManager;

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

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

    public function save(ElementType $elementType)
    {
        try {
            $this->entityManager->persist($elementType);
            $this->entityManager->flush();

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

    public function saveMultiple(array $elementTypes): bool
    {
        try {
            foreach ($elementTypes as $elementType) {
                $this->entityManager->persist($elementType);
            }
            $this->entityManager->flush();

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

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

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

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

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

    /**
     * @throws NonUniqueResultException
     *
     * @return int|mixed|string|null
     */
    public function findByIdPIM(int $id)
    {
        return $this->entityManager
            ->createQueryBuilder()
            ->select('e')
            ->from(ElementType::class, 'e')
            ->where('e.elementTypePIM = :id')
            ->setParameter('id', $id)
            ->getQuery()
            ->getResult();
    }

    /**
     * @return mixed
     */
    public function getElementTypeProject()
    {
        $qb = $this->entityManager
            ->createQueryBuilder()
            ->select('et')
            ->from(ElementType::class, 'et');

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

    public function findTypeField(int $elementTypeId): array
    {
        $connection = $this->container->get('doctrine.dbal.pim_connection');
        $sql = '

                SELECT 
                element_type_field.id,
                element_type_field.name,
                tab_type.name as TabName,
                element_type.name as ElementTypeName,
                element_type.id as idElementType
                FROM element_type_field, tab_type, element_type
                WHERE element_type_field.tab_type_id = tab_type.id
                AND element_type.id = tab_type.element_type_id
                AND tab_type.element_type_id = ' . $elementTypeId . '
                ORDER BY tab_type.id
            ';

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

        return  $stmt->fetchAll();
    }

    public function findByElementTypeField(int $elementTypeFieldId)
    {
        $connection = $this->container->get('doctrine.dbal.pim_connection');
        $sql = '
                SELECT 
                element_type_field.id,
                element_type_field.name,
                element_type.id as elementTypeId
                FROM element_type_field, tab_type,element_type
                WHERE element_type_field.tab_type_id = tab_type.id
                AND tab_type.element_type_id = element_type.id  
                AND element_type_field.id = ' . $elementTypeFieldId;

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

        return  $stmt->fetch();
    }

    /**
     * @throws NonUniqueResultException
     *
     * @return int|mixed|string|null
     */
    public function findElementTypeByIdProject(int $elementTypePIM, int $projectId)
    {
        return $this->entityManager
            ->createQueryBuilder()
            ->select('et', 'l')
            ->from(ElementType::class, 'et')
            ->leftJoin('et.layouts', 'l')
            ->where('et.elementTypePIM = :elementTypePIM')
            ->andWhere('et.project = :projectId')
            ->setParameters([':elementTypePIM' => $elementTypePIM, ':projectId' => $projectId])
            ->getQuery()
            ->getOneOrNullResult();
    }

    /**
     * @throws NonUniqueResultException
     *
     * @return int|mixed|string|null
     */
    public function findElementTypesByIdsProjects(array $elementTypePIM, int $projectId)
    {
        $qb = $this->entityManager
            ->createQueryBuilder();
            return $qb->select('et', 'l')
            ->from(ElementType::class, 'et')
            ->leftJoin('et.layouts', 'l')
            ->where($qb->expr()->in("et.elementTypePIM", $elementTypePIM))
            ->andWhere('et.project = :projectId')
            ->setParameter(':projectId' ,$projectId)
            ->getQuery()
            ->getResult();
    }

    /**
     * @throws NonUniqueResultException
     *
     * @return int|mixed|string|null
     */
    public function findNoElementTypeByIdProject(int $projectId)
    {
        return $this->entityManager
            ->createQueryBuilder()
            ->select('et', 'l')
            ->from(ElementType::class, 'et')
            ->leftJoin('et.layouts', 'l')
            ->where('et.elementTypePIM is null')
            ->andWhere('et.project = :projectId')
            ->setParameters([':projectId' => $projectId])
            ->getQuery()
            ->getOneOrNullResult()
        ;
    }

    public function list(int $projectId): array
    {
        return $this->entityManager
            ->createQueryBuilder()
            ->select('e')
            ->from(ElementType::class, 'e')
            ->where('e.project = :projectId')
            ->andWhere('e.elementTypePIM is not null')
            ->andWhere('e.deletedAt is NULL')
            ->setParameter('projectId', $projectId)
            ->getQuery()
            ->getResult();
    }

    public function getElementsByProject(int $projectId): array
    {
        return $this->entityManager
            ->createQueryBuilder()
            ->select('et')
            ->from(ElementType::class, 'et')
            ->where('et.project = :projectId')
            ->setParameter('projectId', $projectId)
            ->getQuery()
            ->getResult();
    }

    /**
     * @return mixed
     */
    public function getByExportId(int $exportId)
    {
        return $this->entityManager
            ->createQueryBuilder()
            ->select('et')
            ->from(ElementType::class, 'et')
            ->leftJoin('et.templates', 't')
            ->leftJoin('t.export', 'e')
            ->where('e.id = :id')
            ->andWhere('et.elementTypePIM is not null')
            ->setParameter('id', $exportId)
            ->getQuery()
            ->getResult();
    }

    public function selectOtherMultiElementType(array $idElementTypes, int $project_id)
    {

        $qb = $this->entityManager->createQueryBuilder();

        $qb->select('et')
            ->from(ElementType::class, 'et')
            ->leftJoin('et.project','p')
            ->where('p.id = :projectId')
            ->andWhere('et.elementTypePIM IS NOT NULL');
            if ($idElementTypes) {
                $qb->andWhere($qb->expr()->notIn('et.id', $idElementTypes));
            }
        return $qb->setParameter('projectId', $project_id)
            ->getQuery()
            ->getResult();
    }

    public function deleteMultiElementType(string $idElementTypes, int $project_id): void
    {
        $connection = $this->container->get('doctrine.dbal.projects_connection');

        $sql = '
              DELETE
              FROM project_element_type
              WHERE project_id = ' . $project_id;
        if ($idElementTypes) {
            $sql .= ' AND id NOT IN (' . $idElementTypes . ')';
        }

        $sql .= ' AND element_type_pim is not null';

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

    public function readMultiple(array $ids): array
    {
        $qb = $this->entityManager->createQueryBuilder();

        return $qb->select('et')
            ->from(ElementType::class, 'et')
            ->where($qb->expr()->in('et.id', $ids))
            ->getQuery()
            ->getResult();
    }

    public function deleteElementType(int $elementTypeId): bool
    {
        try {
            $dateNow = new \DateTime();

            $connection = $this->container->get('doctrine.dbal.projects_connection');

            $sql = '
                UPDATE project_element_type SET deletedAt = "' . $dateNow->format('Y-m-d H:m:s') . '" WHERE element_type_pim = ' . $elementTypeId;

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

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