<?php

namespace App\Entity;

use App\Entity\Traits\BlameableEntity;
use App\Entity\Traits\SoftDeletableEntity;
use App\Entity\Traits\TimestampableEntity;
use App\Repository\AssignmentRepository;
use Carbon\CarbonPeriod;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use Doctrine\DBAL\Types\Types;
use Doctrine\ORM\Mapping as ORM;
use Symfony\Component\Uid\Uuid;
use Symfony\Component\Validator\Constraints as Assert;

#[ORM\Entity(repositoryClass: AssignmentRepository::class)]
class Assignment implements BlameableEntityInterface, TimestampableEntityInterface, SoftDeletableEntityInterface
{
    use BlameableEntity;
    use TimestampableEntity;
    use SoftDeletableEntity;

    public const STATUS_DRAFT = 'draft';
    public const STATUS_PUBLISHED = 'published';

    public const STATUS_STAFFED = 'staffed';
    public const STATUS_PARTLY_STAFFED = 'partly_staffed';
    public const STATUS_STAFFING = 'staffing';
    public const STATUS_UNSTAFFED = 'unstaffed';
    public const STATUS_DELETED = 'deleted';
    public const STATUS_CALLED_OFF = 'called_off';

    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column]
    private ?int $id = null;

    #[ORM\Column(type: 'string', length: 36, unique: true)]
    private string $uuid;

    #[ORM\ManyToOne]
    #[Assert\NotNull(message: 'Bitte gib die Destination an')]
    private ?Destination $destination = null;

    #[ORM\ManyToOne]
    #[Assert\NotNull(message: 'Bitte gib das Jobprofil an')]
    private ?JobProfile $jobProfile = null;

    #[ORM\Column(type: Types::TEXT, nullable: true)]
    private ?string $jobProfileInfo = null;

    #[ORM\Column(nullable: true)]
    #[Assert\Range(min: 1, minMessage: 'Die Mindestanzahl ist 1')]
    private ?int $availableDispositions = 1;

    #[ORM\Column]
    private ?bool $showAvailableDispositions = false;

    #[ORM\Column(type: Types::DATE_IMMUTABLE, nullable: true)]
    private ?\DateTimeImmutable $dateFrom = null;

    #[ORM\Column(type: Types::DATE_IMMUTABLE, nullable: true)]
    #[Assert\GreaterThan(propertyPath: 'dateFrom', message: 'Das Enddatum muss nach dem Beginndatum liegen')]
    private ?\DateTimeImmutable $dateTo = null;

    #[ORM\Column(type: Types::DATE_IMMUTABLE, nullable: true)]
    private ?\DateTimeImmutable $pickupDate = null;

    #[ORM\Column(nullable: true)]
    private ?int $pickup = null;

    #[ORM\Column(type: Types::TEXT, nullable: true)]
    private ?string $benefits;

    #[ORM\Column(type: Types::TEXT, nullable: true)]
    private ?string $remarks = null;

    #[ORM\ManyToMany(targetEntity: Fee::class)]
    private Collection $fees;

    #[ORM\OneToMany(mappedBy: 'assignment', targetEntity: Application::class)]
    private Collection $applications;

    #[ORM\OneToMany(mappedBy: 'assignment', targetEntity: Disposition::class)]
    private Collection $dispositions;

    #[ORM\ManyToOne]
    private ?User $contact = null;

    #[ORM\ManyToMany(targetEntity: Teamer::class, mappedBy: 'bookmarks')]
    private Collection $teamers;

    #[ORM\ManyToOne]
    private ?User $owner = null;

    #[ORM\Column(length: 64)]
    private ?string $status;

    #[ORM\Column(length: 64)]
    private ?string $staffingStatus;

    public function __construct()
    {
        $this->uuid = Uuid::v4();
        $this->status = static::STATUS_DRAFT;
        $this->staffingStatus = static::STATUS_UNSTAFFED;
        $this->fees = new ArrayCollection();
        $this->applications = new ArrayCollection();
        $this->dispositions = new ArrayCollection();
        $this->teamers = new ArrayCollection();
        $this->benefits = "Anreise im E&P Reisebus\nUnterkunft\nVerpflegung\nSkipass\n";
    }

    public static function duplicate(Assignment $assignment): static
    {
        $instance = new static();

        $instance
            ->setDestination($assignment->getDestination())
            ->setJobProfile($assignment->getJobProfile())
            ->setAvailableDispositions($assignment->getAvailableDispositions())
            ->setShowAvailableDispositions($assignment->isShowAvailableDispositions())
            ->setDateFrom($assignment->getDateFrom())
            ->setDateTo($assignment->getDateTo())
            ->setPickupDate($assignment->getPickupDate())
            ->setPickup($assignment->getPickup())
            ->setBenefits($assignment->getBenefits())
            ->setContact($assignment->getContact());

        $assignment->getFees()->map(function (Fee $fee) use ($instance) {
            $instance->addFee($fee);
        });

        return $instance;
    }

    public function updateStaffingStatus(): void
    {
        $confirmedDispositions = $this->getValidDispositions();
        $validApplications = $this->getValidApplications();

        if ($this->availableDispositions === $confirmedDispositions->count()) {
            $this->setStaffingStatus(Assignment::STATUS_STAFFED);
        } elseif (
            $this->availableDispositions > $confirmedDispositions->count()
            && 0 < $confirmedDispositions->count()
        ) {
            $this->setStaffingStatus(Assignment::STATUS_PARTLY_STAFFED);
        } elseif (
            $this->availableDispositions > $confirmedDispositions->count()
            && 0 < $validApplications->count()
        ) {
            $this->setStaffingStatus(Assignment::STATUS_STAFFING);
        } else {
            $this->setStaffingStatus(Assignment::STATUS_UNSTAFFED);
        }
    }

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

    public function getUuid(): string
    {
        return $this->uuid;
    }

    public function getDestination(): ?Destination
    {
        return $this->destination;
    }

    public function setDestination(?Destination $destination): static
    {
        $this->destination = $destination;

        return $this;
    }

    public function getJobProfile(): ?JobProfile
    {
        return $this->jobProfile;
    }

    public function setJobProfile(?JobProfile $jobProfile): static
    {
        $this->jobProfile = $jobProfile;

        return $this;
    }

    public function getJobProfileInfo(): ?string
    {
        return $this->jobProfileInfo;
    }

    public function setJobProfileInfo(?string $jobProfileInfo): static
    {
        $this->jobProfileInfo = $jobProfileInfo;

        return $this;
    }

    public function getAvailableDispositions(): ?int
    {
        return $this->availableDispositions;
    }

    public function setAvailableDispositions(?int $availableDispositions): static
    {
        $this->availableDispositions = $availableDispositions;

        return $this;
    }

    public function isShowAvailableDispositions(): ?bool
    {
        return $this->showAvailableDispositions;
    }

    public function setShowAvailableDispositions(bool $showAvailableDispositions): static
    {
        $this->showAvailableDispositions = $showAvailableDispositions;

        return $this;
    }

    public function getDateFrom(): ?\DateTimeImmutable
    {
        return $this->dateFrom;
    }

    public function setDateFrom(?\DateTimeImmutable $dateFrom): static
    {
        $this->dateFrom = $dateFrom;

        return $this;
    }

    public function getDateTo(): ?\DateTimeImmutable
    {
        return $this->dateTo;
    }

    public function setDateTo(?\DateTimeImmutable $dateTo): static
    {
        $this->dateTo = $dateTo;

        return $this;
    }

    public function getEffectivePeriod(): ?CarbonPeriod
    {
        if (null !== $destination = $this->getDestination()) {
            $dateFrom = $this->getDateFrom() ?? $destination->getDateFrom();
            $dateTo = $this->getDateTo() ?? $destination->getDateTo();

            return new CarbonPeriod($dateFrom, $dateTo);
        }

        return null;
    }

    public function getEffectiveDateFrom(): ?\DateTimeImmutable
    {
        if (null !== $effectivePeriod = $this->getEffectivePeriod()) {
            return $effectivePeriod->start->toDateTimeImmutable();
        }

        return null;
    }

    public function getEffectiveDateTo(): ?\DateTimeImmutable
    {
        if (null !== $effectivePeriod = $this->getEffectivePeriod()) {
            return $effectivePeriod->end->toDateTimeImmutable();
        }

        return null;
    }

    public function getEffectivePickupDate(): ?\DateTimeImmutable
    {
        if (null !== $this->pickupDate) {
            return $this->pickupDate;
        }

        if (0 !== (int) $this->pickup && null !== $destination = $this->getDestination()) {
            return $destination
                ->getDateFrom()
                ->modify('-1 day')
            ;
        }

        return null;
    }

    public function getPickupDate(): ?\DateTimeImmutable
    {
        return $this->pickupDate;
    }

    public function setPickupDate(?\DateTimeImmutable $pickupDate): static
    {
        $this->pickupDate = $pickupDate;

        return $this;
    }

    public function getPickup(): ?int
    {
        return $this->pickup;
    }

    public function setPickup(null|int|string $pickup): static
    {
        $this->pickup = (int) $pickup;

        return $this;
    }

    public function getBenefits(): ?string
    {
        return $this->benefits;
    }

    public function setBenefits(?string $benefits): static
    {
        $this->benefits = $benefits;

        return $this;
    }

    public function getRemarks(): ?string
    {
        return $this->remarks;
    }

    public function setRemarks(?string $remarks): static
    {
        $this->remarks = $remarks;

        return $this;
    }

    /**
     * @return Collection<int, Fee>
     */
    public function getFees(): Collection
    {
        return $this->fees;
    }

    public function addFee(Fee $fee): static
    {
        if (!$this->fees->contains($fee)) {
            $this->fees->add($fee);
        }

        return $this;
    }

    public function removeFee(Fee $fee): static
    {
        $this->fees->removeElement($fee);

        return $this;
    }

    /**
     * @return Collection<int, Application>
     */
    public function getApplications(): Collection
    {
        return $this->applications;
    }

    public function getApplicationByTeamer(Teamer $teamer): ?Application
    {
        $applications = $this->applications->filter(function (Application $application) use ($teamer) {
            return $application->getTeamer() === $teamer;
        });

        if (0 === count($applications)) {
            return null;
        }

        return $applications->first();
    }

    public function getValidApplications(): Collection
    {
        return $this->applications->filter(function (Application $application) {
            return Application::STATUS_REJECTED !== $application->getStatus();
        });
    }

    public function addApplication(Application $application): static
    {
        if (!$this->applications->contains($application)) {
            $this->applications->add($application);
            $application->setAssignment($this);
        }

        return $this;
    }

    public function removeApplication(Application $application): static
    {
        if ($this->applications->removeElement($application)) {
            // set the owning side to null (unless already changed)
            if ($application->getAssignment() === $this) {
                $application->setAssignment(null);
            }
        }

        return $this;
    }

    /**
     * @return Collection<int, Disposition>
     */
    public function getDispositions(): Collection
    {
        return $this->dispositions;
    }

    public function addDisposition(Disposition $disposition): static
    {
        if (!$this->dispositions->contains($disposition)) {
            $this->dispositions->add($disposition);
            $disposition->setAssignment($this);
        }

        return $this;
    }

    public function removeDisposition(Disposition $disposition): static
    {
        if ($this->dispositions->removeElement($disposition)) {
            // set the owning side to null (unless already changed)
            if ($disposition->getAssignment() === $this) {
                $disposition->setAssignment(null);
            }
        }

        return $this;
    }

    public function getValidDispositions(): Collection
    {
        return $this->dispositions->filter(function (Disposition $disposition) {
            return true === in_array($disposition->getStatus(), [
                Disposition::STATUS_NEW,
                Disposition::STATUS_CHECKING_CONTRACT,
                Disposition::STATUS_CONFIRMED,
            ]);
        });
    }

    public function getContact(): ?User
    {
        return $this->contact;
    }

    public function setContact(?User $contact): static
    {
        $this->contact = $contact;

        return $this;
    }

    /**
     * @return Collection<int, Teamer>
     */
    public function getTeamers(): Collection
    {
        return $this->teamers;
    }

    public function addTeamer(Teamer $teamer): static
    {
        if (!$this->teamers->contains($teamer)) {
            $this->teamers->add($teamer);
        }

        return $this;
    }

    public function removeTeamer(Teamer $teamer): static
    {
        $this->teamers->removeElement($teamer);

        return $this;
    }

    public function getOwner(): ?User
    {
        return $this->owner;
    }

    public function setOwner(?User $owner): static
    {
        $this->owner = $owner;

        return $this;
    }

    public function getStatus(): ?string
    {
        return $this->status;
    }

    public function setStatus(string $status): static
    {
        $this->status = $status;

        return $this;
    }

    public function getStaffingStatus(): ?string
    {
        return $this->staffingStatus;
    }

    public function setStaffingStatus(?string $staffingStatus): static
    {
        $this->staffingStatus = $staffingStatus;

        return $this;
    }
}