<?php
declare (strict_types=1);

namespace App\Entity\Place;

use ApiPlatform\Metadata\Get;
use ApiPlatform\Metadata\ApiResource;
use App\Entity\Booking\Course;
use App\Entity\Booking\EducationalProject;
use App\Entity\Booking\Event;
use App\Entity\Booking\Examen;
use App\Entity\Core\ContactPoint;
use App\Entity\Product\Equipment;

//use DH\Auditor\Provider\Doctrine\Auditing\Annotation\Auditable;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use Doctrine\ORM\Mapping as ORM;

/**
 * Classe ... qui ...
 */
#[ApiResource(
    operations: [
        new Get(
            security: 'is_granted(\'ROLE_ADMIN\') and object.getPlace().getOrganization().getId() == user.getOrganization().getId()'
        )
    ]
)]
//#[Auditable]
#[ORM\Entity]
class Room
{
    #[ORM\Id]
    #[ORM\Column]
    #[ORM\GeneratedValue]
    private ?int $id = null;

    #[ORM\ManyToOne(targetEntity: Place::class, inversedBy: 'rooms')]
    private Place $place;

    #[ORM\ManyToMany(targetEntity: ContactPoint::class)]
    private Collection $contactpoint;

    #[ORM\ManyToMany(targetEntity: Equipment::class, cascade: ['persist'])]
    #[ORM\JoinColumn(name: 'room_id', referencedColumnName: 'id')]
    #[ORM\InverseJoinColumn(name: 'equipment_id', referencedColumnName: 'id', unique: true)]
    private Collection $equipments;

    #[ORM\OneToMany(mappedBy: 'room', targetEntity: RoomControl::class, cascade: ['persist'], orphanRemoval: true)]
    #[ORM\JoinColumn(nullable: false)]
    private Collection $controls;

    #[ORM\OneToMany(mappedBy: 'room', targetEntity: RoomRepair::class, cascade: ['persist'], orphanRemoval: true)]
    #[ORM\JoinColumn(nullable: false)]
    private Collection $repairs;

    #[ORM\OneToMany(mappedBy: 'room', targetEntity: Course::class)]
    private Collection $courses;

    #[ORM\OneToMany(mappedBy: 'room', targetEntity: EducationalProject::class)]
    private Collection $educationalProjects;

    #[ORM\OneToMany(mappedBy: 'room', targetEntity: Event::class)]
    private Collection $events;

    #[ORM\OneToMany(mappedBy: 'room', targetEntity: Examen::class)]
    private Collection $examens;

    #[ORM\OneToMany(mappedBy: 'roomStorage', targetEntity: Equipment::class)]
    private Collection $equipmentStorages;

    #[ORM\OneToMany(mappedBy: 'roomWhereIsUsed', targetEntity: Equipment::class)]
    private Collection $equipmentUseds;

    public function __construct()
    {
        $this->contactpoint = new ArrayCollection();
        $this->equipments = new ArrayCollection();
        $this->controls = new ArrayCollection();
        $this->repairs = new ArrayCollection();
        $this->courses = new ArrayCollection();
        $this->educationalProjects = new ArrayCollection();
        $this->events = new ArrayCollection();
        $this->examens = new ArrayCollection();
        $this->equipmentStorages = new ArrayCollection();
        $this->equipmentUseds = new ArrayCollection();
    }

    public function getId(): ?int
    {
        return $this->id;
    }

    public function getPlace(): ?Place
    {
        return $this->place;
    }

    public function setPlace(?Place $place): self
    {
        $this->place = $place;
        return $this;
    }

    /**
     * @return Collection<int, ContactPoint>
     */
    public function getContactpoint(): Collection
    {
        return $this->contactpoint;
    }

    public function addContactpoint(ContactPoint $contactpoint): self
    {
        if (!$this->contactpoint->contains($contactpoint)) {
            $this->contactpoint[] = $contactpoint;
        }
        return $this;
    }

    public function removeContactpoint(ContactPoint $contactpoint): self
    {
        $this->contactpoint->removeElement($contactpoint);
        return $this;
    }

    /**
     * @return Collection<int, Equipment>
     */
    public function getEquipments(): Collection
    {
        return $this->equipments;
    }

    public function addEquipment(Equipment $equipment): self
    {
        if (!$this->equipments->contains($equipment)) {
            $this->equipments[] = $equipment;
        }
        return $this;
    }

    public function removeEquipment(Equipment $equipment): self
    {
        $this->equipments->removeElement($equipment);
        return $this;
    }

    /**
     * @return Collection<int, RoomControl>
     */
    public function getControls(): Collection
    {
        return $this->controls;
    }

    public function addControl(RoomControl $control): self
    {
        if (!$this->controls->contains($control)) {
            $this->controls[] = $control;
            $control->setRoom($this);
        }
        return $this;
    }

    public function removeControl(RoomControl $control): self
    {
        if ($this->controls->removeElement($control)) {
            // set the owning side to null (unless already changed)
            if ($control->getRoom() === $this) {
                $control->setRoom(null);
            }
        }
        return $this;
    }

    /**
     * @return Collection<int, RoomRepair>
     */
    public function getRepairs(): Collection
    {
        return $this->repairs;
    }

    public function addRepair(RoomRepair $repair): self
    {
        if (!$this->repairs->contains($repair)) {
            $this->repairs[] = $repair;
            $repair->setRoom($this);
        }
        return $this;
    }

    public function removeRepair(RoomRepair $repair): self
    {
        if ($this->repairs->removeElement($repair)) {
            // set the owning side to null (unless already changed)
            if ($repair->getRoom() === $this) {
                $repair->setRoom(null);
            }
        }
        return $this;
    }

    /**
     * @return Collection<int, Course>
     */
    public function getCourses(): Collection
    {
        return $this->courses;
    }

    public function addCourse(Course $course): self
    {
        if (!$this->courses->contains($course)) {
            $this->courses[] = $course;
            $course->setRoom($this);
        }
        return $this;
    }

    public function removeCourse(Course $course): self
    {
        if ($this->courses->removeElement($course)) {
            // set the owning side to null (unless already changed)
            if ($course->getRoom() === $this) {
                $course->setRoom(null);
            }
        }
        return $this;
    }

    /**
     * @return Collection<int, EducationalProject>
     */
    public function getEducationalProjects(): Collection
    {
        return $this->educationalProjects;
    }

    public function addEducationalProject(EducationalProject $educationalProject): self
    {
        if (!$this->educationalProjects->contains($educationalProject)) {
            $this->educationalProjects[] = $educationalProject;
            $educationalProject->setRoom($this);
        }
        return $this;
    }

    public function removeEducationalProject(EducationalProject $educationalProject): self
    {
        if ($this->educationalProjects->removeElement($educationalProject)) {
            // set the owning side to null (unless already changed)
            if ($educationalProject->getRoom() === $this) {
                $educationalProject->setRoom(null);
            }
        }
        return $this;
    }

    /**
     * @return Collection<int, Event>
     */
    public function getEvents(): Collection
    {
        return $this->events;
    }

    public function addEvent(Event $event): self
    {
        if (!$this->events->contains($event)) {
            $this->events[] = $event;
            $event->setRoom($this);
        }
        return $this;
    }

    public function removeEvent(Event $event): self
    {
        if ($this->events->removeElement($event)) {
            // set the owning side to null (unless already changed)
            if ($event->getRoom() === $this) {
                $event->setRoom(null);
            }
        }
        return $this;
    }

    /**
     * @return Collection<int, Examen>
     */
    public function getExamens(): Collection
    {
        return $this->examens;
    }

    public function addExamen(Examen $examen): self
    {
        if (!$this->examens->contains($examen)) {
            $this->examens[] = $examen;
            $examen->setRoom($this);
        }
        return $this;
    }

    public function removeExamen(Examen $examen): self
    {
        if ($this->examens->removeElement($examen)) {
            // set the owning side to null (unless already changed)
            if ($examen->getRoom() === $this) {
                $examen->setRoom(null);
            }
        }
        return $this;
    }

    /**
     * @return Collection<int, Equipment>
     */
    public function getEquipmentStorages(): Collection
    {
        return $this->equipmentStorages;
    }

    public function addEquipmentStorage(Equipment $equipmentStorage): self
    {
        if (!$this->equipmentStorages->contains($equipmentStorage)) {
            $this->equipmentStorages[] = $equipmentStorage;
            $equipmentStorage->setRoomStorage($this);
        }
        return $this;
    }

    public function removeEquipmentStorage(Equipment $equipmentStorage): self
    {
        if ($this->equipmentStorages->removeElement($equipmentStorage)) {
            // set the owning side to null (unless already changed)
            if ($equipmentStorage->getRoomStorage() === $this) {
                $equipmentStorage->setRoomStorage(null);
            }
        }
        return $this;
    }

    /**
     * @return Collection<int, Equipment>
     */
    public function getEquipmentUseds(): Collection
    {
        return $this->equipmentUseds;
    }

    public function addEquipmentUsed(Equipment $equipmentUsed): self
    {
        if (!$this->equipmentUseds->contains($equipmentUsed)) {
            $this->equipmentUseds[] = $equipmentUsed;
            $equipmentUsed->setRoomWhereIsUsed($this);
        }
        return $this;
    }

    public function removeEquipmentUsed(Equipment $equipmentUsed): self
    {
        if ($this->equipmentUseds->removeElement($equipmentUsed)) {
            // set the owning side to null (unless already changed)
            if ($equipmentUsed->getRoomWhereIsUsed() === $this) {
                $equipmentUsed->setRoomWhereIsUsed(null);
            }
        }
        return $this;
    }
}