<?php

namespace Chill\PersonBundle\Entity;

/*
 * Chill is a software for social workers
 *
 * Copyright (C) 2014-2015, Champs Libres Cooperative SCRLFS,
 * <http://www.champs-libres.coop>, <info@champs-libres.coop>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

use ArrayIterator;
use Chill\MainBundle\Doctrine\Model\TrackCreationInterface;
use Chill\MainBundle\Doctrine\Model\TrackUpdateInterface;
use Chill\MainBundle\Entity\Center;
use Chill\MainBundle\Entity\Country;
use Chill\MainBundle\Entity\User;
use Chill\PersonBundle\Entity\AccompanyingPeriod;
use Chill\PersonBundle\Entity\Household\Household;
use Chill\PersonBundle\Entity\MaritalStatus;
use Chill\PersonBundle\Entity\Household\HouseholdMember;
use Chill\MainBundle\Entity\HasCenterInterface;
use Chill\MainBundle\Entity\Address;
use Chill\MainBundle\Entity\Civility;
use Chill\MainBundle\Entity\Embeddable\CommentEmbeddable;
use Chill\PersonBundle\Entity\Person\PersonCurrentAddress;
use DateTime;
use Doctrine\ORM\Mapping as ORM;
use Doctrine\Common\Collections\Collection;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Criteria;
use Symfony\Component\Validator\Context\ExecutionContextInterface;
use Symfony\Component\Serializer\Annotation\DiscriminatorMap;
use Chill\PersonBundle\Entity\Household\PersonHouseholdAddress;
use Symfony\Component\Validator\Constraints as Assert;
use Chill\PersonBundle\Validator\Constraints\Person\Birthdate;
use Chill\MainBundle\Validation\Constraint\PhonenumberConstraint;
use Chill\PersonBundle\Validator\Constraints\Person\PersonHasCenter;
use Chill\PersonBundle\Validator\Constraints\Household\HouseholdMembershipSequential;
use DateTimeInterface;

/**
 * Person Class
 *
 * @ORM\Entity
 * @ORM\Table(name="chill_person_person",
 *     indexes={@ORM\Index(
 *          name="person_names",
 *          columns={"firstName", "lastName"}
 * )})
 * @ORM\HasLifecycleCallbacks()
 * @DiscriminatorMap(typeProperty="type", mapping={
 *   "person"=Person::class
 * })
 * @PersonHasCenter(
 *     groups={"general", "creation"}
 * )
 * @HouseholdMembershipSequential(
 *     groups={"household_memberships"}
 * )
 */
class Person implements HasCenterInterface, TrackCreationInterface, TrackUpdateInterface
{
    /**
     * The person's id
     *
     * @ORM\Id
     * @ORM\Column(name="id", type="integer")
     * @ORM\GeneratedValue(strategy="AUTO")
     */
    private int $id;

    /**
     * The person's first name
     * @var string
     *
     * @ORM\Column(type="string", length=255)
     * @Assert\NotBlank(
     *     groups={"general", "creation"}
     * )
     * @Assert\Length(
     *     max=255,
     *     groups={"general", "creation"}
     * )
     */
    private $firstName;

    /**
     * The person's last name
     * @var string
     *
     * @ORM\Column(type="string", length=255)
     * @Assert\NotBlank(
     *     groups={"general", "creation"}
     * )
     * @Assert\Length(
     *     max=255,
     *     groups={"general", "creation"}
     * )
     */
    private $lastName;

    /**
     * @var Collection
     *
     * @ORM\OneToMany(
     *     targetEntity="Chill\PersonBundle\Entity\PersonAltName",
     *     mappedBy="person",
     *     cascade={"persist", "remove", "merge", "detach"},
     *     orphanRemoval=true)
     */
    private $altNames;

    /**
     * The person's birthdate
     * @var \DateTime
     *
     * @ORM\Column(type="date", nullable=true)
     * @Assert\Date(
     *     groups={"general", "creation"}
     * )
     * @Birthdate(
     *     groups={"general", "creation"}
     * )
     */
    private $birthdate;

    /**
     * The person's deathdate
     * @var \DateTimeImmutable
     *
     * @ORM\Column(type="date_immutable", nullable=true)
     * @Assert\Date(
     *     groups={"general", "creation"}
     * )
     */
    private ?\DateTimeImmutable $deathdate = null;

    /**
     * The person's place of birth
     * @var string
     *
     * @ORM\Column(type="string", length=255, name="place_of_birth")
     */
    private $placeOfBirth = '';

    /**
     * The person's country of birth
     * @var Country
     *
     * @ORM\ManyToOne(targetEntity="Chill\MainBundle\Entity\Country")
     *
     *     sf4 check: option inversedBy="birthsIn" return error mapping !!
     *
     * @ORM\JoinColumn(nullable=true)
     */
    private $countryOfBirth;

    /**
     * The person's nationality
     * @var Country
     *
     * @ORM\ManyToOne(targetEntity="Chill\MainBundle\Entity\Country")
     *
     *    sf4 check: option inversedBy="nationals" return error mapping !!
     *
     * @ORM\JoinColumn(nullable=true)
     */
    private $nationality;

    /**
     * The person's gender
     * @var string
     *
     * @ORM\Column(type="string", length=9, nullable=true)
     * @Assert\NotNull(
     *     groups={"general", "creation"}
     * )
     */
    private $gender;

    const MALE_GENDER = 'man';
    const FEMALE_GENDER = 'woman';
    const BOTH_GENDER = 'both';
    const NO_INFORMATION = 'unknown';

    /**
     * Comment on gender
     * @var CommentEmbeddable
     * @ORM\Embedded(class="Chill\MainBundle\Entity\Embeddable\CommentEmbeddable", columnPrefix="genderComment_")
     */
    private CommentEmbeddable $genderComment;

    /**
     * The marital status of the person
     * @var MaritalStatus
     *
     * @ORM\ManyToOne(targetEntity="Chill\PersonBundle\Entity\MaritalStatus")
     * @ORM\JoinColumn(nullable=true)
     */
    private $maritalStatus;

   /**
     * The marital status of the person
     * @var Civility
     *
     * @ORM\ManyToOne(targetEntity="Chill\MainBundle\Entity\Civility")
     * @ORM\JoinColumn(nullable=true)
     */
    private $civility;

    /**
     * The date of the last marital status change of the person
     * @var \DateTime
     *
     * @ORM\Column(type="date", nullable=true)
     * @Assert\Date(
     *     groups={"general", "creation"}
     * )
     */
    private ?\DateTime $maritalStatusDate;

    /**
     * Comment on marital status
     * @var CommentEmbeddable
     * @ORM\Embedded(class="Chill\MainBundle\Entity\Embeddable\CommentEmbeddable", columnPrefix="maritalStatusComment_")
     */
    private CommentEmbeddable $maritalStatusComment;

    /**
     * Contact information for contacting the person
     * @var string
     *
     * @ORM\Column(type="text", nullable=true)
     */
    private $contactInfo = '';

    /**
     * The person's email
     * @var string
     *
     * @ORM\Column(type="text", nullable=true)
     * @Assert\Email(
     *     checkMX=true,
     *     groups={"general", "creation"}
     * )
     */
    private $email = '';

    /**
     * The person's phonenumber
     * @var string
     *
     * @ORM\Column(type="text", length=40, nullable=true)
     * @Assert\Regex(
     *     pattern="/^([\+{1}])([0-9\s*]{4,20})$/",
     *     groups={"general", "creation"}
     * )
     * @PhonenumberConstraint(
     *     type="landline",
     *     groups={"general", "creation"}
     * )
     */
    private $phonenumber = '';

    /**
     * The person's mobile phone number
     * @var string
     *
     * @ORM\Column(type="text", length=40, nullable=true)
     * @Assert\Regex(
     *     pattern="/^([\+{1}])([0-9\s*]{4,20})$/",
     *     groups={"general", "creation"}
     * )
     * @PhonenumberConstraint(
     *     type="mobile",
     *     groups={"general", "creation"}
     * )
     */
    private $mobilenumber = '';

    /**
     * @var Collection
     *
     * @ORM\OneToMany(
     *     targetEntity="Chill\PersonBundle\Entity\PersonPhone",
     *     mappedBy="person",
     *     cascade={"persist", "remove", "merge", "detach"},
     *     orphanRemoval=true
     * )
     * @Assert\Valid(
     *     traverse=true,
     *     groups={"general", "creation"}
     * )
     */
    private $otherPhoneNumbers;

    /**
     * The person's spoken languages
     * @var ArrayCollection
     *
     * @ORM\ManyToMany(targetEntity="Chill\MainBundle\Entity\Language")
     * @ORM\JoinTable(
     *     name="persons_spoken_languages",
     *     joinColumns={@ORM\JoinColumn(name="person_id", referencedColumnName="id")},
     *     inverseJoinColumns={@ORM\JoinColumn(name="language_id", referencedColumnName="id")}
     * )
     */
    private $spokenLanguages;

    /**
     * The person's center
     * @var Center
     *
     * @ORM\ManyToOne(targetEntity="Chill\MainBundle\Entity\Center")
     */
    private $center;

    /**
     * The person's accompanying periods (when the person was accompanied by the center)
     * @var Collection
     *
     * @ORM\OneToMany(targetEntity=AccompanyingPeriodParticipation::class,
     *     mappedBy="person",
     *     cascade={"persist", "remove", "merge", "detach"})
     */
    private $accompanyingPeriodParticipations;

    /**
     * The accompanying period requested by the Person
     *
     * @ORM\OneToMany(targetEntity=AccompanyingPeriod::class,
     *     mappedBy="requestorPerson")
     * @var Collection|AccompanyingPeriod[]
     */
    private Collection $accompanyingPeriodRequested;

    /**
     * A remark over the person
     * @var string
     *
     * @ORM\Column(type="text")
     */
    private $memo = ''; // TO-CHANGE in remark


    /**
     * Accept short text message (aka SMS)
     * @var boolean
     *
     * @ORM\Column(type="boolean", options={"default" : false})
     */
    private ?bool $acceptSMS = false;

    /**
     * Accept receiving email
     * @var boolean
     *
     * @ORM\Column(type="boolean", options={"default" : false})
     */
    private ?bool $acceptEmail = false;

    /**
     * Number of children
     * @var int
     *
     * @ORM\Column(type="integer", nullable=true)
     */
    private ?int $numberOfChildren = null;

    /**
     * @ORM\ManyToOne(targetEntity=User::class)
     * @ORM\JoinColumn(nullable=true)
     */
    private $createdBy;

    /**
     * @ORM\Column(type="datetime", nullable=true, options={"default": NULL})
     */
    private $createdAt;

    /**
     * @ORM\ManyToOne(
     *    targetEntity=User::class
     * )
     */
    private $updatedBy;

    /**
     * @ORM\Column(type="datetime", nullable=true, options={"default": NULL})
     */
    private $updatedAt;

    /**
     * @var boolean
     * @deprecated
     *
     * @ORM\Column(type="boolean")
     */
    private $proxyAccompanyingPeriodOpenState = false; //TO-DELETE ?

    /**
     * Array where customfield's data are stored
     * @var array
     *
     * @ORM\Column(type="json")
     */
    private $cFData;

    /**
     * Addresses
     * @var Collection
     *
     * @ORM\ManyToMany(
     *     targetEntity="Chill\MainBundle\Entity\Address",
     *     cascade={"persist", "remove", "merge", "detach"})
     * @ORM\JoinTable(name="chill_person_persons_to_addresses")
     * @ORM\OrderBy({"validFrom" = "DESC"})
     */
    private $addresses;

    /**
     * The current person address.
     *
     * This is computed through database and is optimized on database side.
     *
     * @var PersonCurrentAddress|null
     * @ORM\OneToOne(targetEntity=PersonCurrentAddress::class, mappedBy="person")
     */
    private ?PersonCurrentAddress $currentPersonAddress = null;

    /**
     * fullname canonical. Read-only field, which is calculated by
     * the database.
     * @var string
     *
     * @ORM\Column(type="text", nullable=true)
     */
    private $fullnameCanonical;

    /**
     * @ORM\OneToMany(
     *  targetEntity=HouseholdMember::class,
     *  mappedBy="person"
     * )
     */
    private Collection $householdParticipations;

    /**
     * Cache the computation of household
     */
    private array $currentHouseholdAt = [];

    /**
     * Read-only field, computed by the database
     *
     * @ORM\OneToMany(
     *  targetEntity=PersonHouseholdAddress::class,
     *  mappedBy="person"
     * )
     */
    private Collection $householdAddresses;

    /**
     * @ORM\OneToMany(
     *  targetEntity=AccompanyingPeriod::class,
     *  mappedBy="personLocation"
     * )
     */
    private Collection $periodLocatedOn;

    /**
     * Person constructor.
     */
    public function __construct()
    {
        $this->accompanyingPeriodParticipations = new ArrayCollection();
        $this->spokenLanguages = new ArrayCollection();
        $this->addresses = new ArrayCollection();
        $this->altNames = new ArrayCollection();
        $this->otherPhoneNumbers = new ArrayCollection();
        $this->householdParticipations = new ArrayCollection();
        $this->householdAddresses = new ArrayCollection();
        $this->genderComment = new CommentEmbeddable();
        $this->maritalStatusComment = new CommentEmbeddable();
        $this->periodLocatedOn = new ArrayCollection();
        $this->accompanyingPeriodRequested = new ArrayCollection();
    }

    /**
     * This private function scan accompanyingPeriodParticipations Collection,
     * searching for a given AccompanyingPeriod
     */
    private function participationsContainAccompanyingPeriod(AccompanyingPeriod $accompanyingPeriod): ?AccompanyingPeriodParticipation
    {
        foreach ($this->accompanyingPeriodParticipations as $participation) {
            /** @var AccompanyingPeriodParticipation $participation */
            if ($accompanyingPeriod === $participation->getAccompanyingPeriod()) {
                return $participation;
        }}

        return null;
    }

    /**
     * This public function is the same but return only true or false
     */
    public function containsAccompanyingPeriod(AccompanyingPeriod $accompanyingPeriod): bool
    {
        return ($this->participationsContainAccompanyingPeriod($accompanyingPeriod)) ? false : true;
    }

    /**
     * Add AccompanyingPeriodParticipation
     *
     * @uses AccompanyingPeriod::addPerson
     */
    public function addAccompanyingPeriod(AccompanyingPeriod $accompanyingPeriod): self
    {
        $participation = new AccompanyingPeriodParticipation($accompanyingPeriod, $this);
        $this->accompanyingPeriodParticipations->add($participation);

        return $this;
    }

    /**
     * Remove AccompanyingPeriod
     */
    public function removeAccompanyingPeriod(AccompanyingPeriod $accompanyingPeriod) : void
    {
        $participation = $this->participationsContainAccompanyingPeriod($accompanyingPeriod);

        if (! null === $participation) {
            $participation->setEndDate(\DateTimeImmutable::class);
            $this->accompanyingPeriodParticipations->removeElement($participation);
        }
    }

    /**
     * set the Person file as open at the given date.
     *
     * For updating a opening's date, you should update AccompanyingPeriod instance
     * directly.
     *
     * For closing a file, @see this::close
     *
     * To check if the Person and its accompanying period is consistent, use validation.
     */
    public function open(AccompanyingPeriod $accompanyingPeriod) : void
    {
        $this->proxyAccompanyingPeriodOpenState = true;
        $this->addAccompanyingPeriod($accompanyingPeriod);
    }

    /**
     * Set the Person file as closed at the given date.
     *
     * For update a closing date, you should update AccompanyingPeriod instance
     * directly.
     *
     * To check if the Person and its accompanying period are consistent, use validation.
     *
     * @throws \Exception if two lines of the accompanying period are open.
     */
    public function close(AccompanyingPeriod $accompanyingPeriod = null) : void
    {
        $this->proxyAccompanyingPeriodOpenState = false;
    }

    /**
     * Return the opened accompanying period.
     */
    public function getOpenedAccompanyingPeriod() : ?AccompanyingPeriod
    {
        if ($this->isOpen() === false) {
            return null;
        }

        foreach ($this->accompanyingPeriodParticipations as $participation) {
            /** @var AccompanyingPeriodParticipation $participation */
            if ($participation->getAccompanyingPeriod()->isOpen()) {
                return $participation->getAccompanyingPeriod();
            }
        }

        return null;
    }

    /**
     * Returns the opened accompanying period.
     *
     * @deprecated since 1.1 use `getOpenedAccompanyingPeriod instead
     */
    public function getCurrentAccompanyingPeriod() : ?AccompanyingPeriod
    {
        return $this->getOpenedAccompanyingPeriod();
    }

    /**
     * Get AccompanyingPeriods array
     */
    public function getAccompanyingPeriods(): array
    {
        $accompanyingPeriods = [];
        foreach ($this->accompanyingPeriodParticipations as $participation)
        {
            /** @var AccompanyingPeriodParticipation $participation */
            $accompanyingPeriods[] = $participation->getAccompanyingPeriod();
        }
        return $accompanyingPeriods;
    }

    /**
     * Get current accompanyingPeriods array
     */
    public function getCurrentAccompanyingPeriods(): array
    {
        $currentAccompanyingPeriods = [];
        $currentDate = new DateTime();

        foreach ($this->accompanyingPeriodParticipations as $participation)
        {
            $endDate = $participation->getEndDate();

            if ($endDate === null || $endDate > $currentDate){
                $currentAccompanyingPeriods[] = $participation->getAccompanyingPeriod();
            }
        }

        return $currentAccompanyingPeriods;
    }

    /**
     * Get AccompanyingPeriodParticipations Collection
     *
     * @return AccompanyingPeriodParticipation[]|Collection
     */
    public function getAccompanyingPeriodParticipations(): Collection
    {
        return $this->accompanyingPeriodParticipations;
    }

    /**
     * Return a collection of participation, where the participation
     * is still opened, not a draft, and the period is still opened
     *
     * @return AccompanyingPeriodParticipation[]|Collection
     */
    public function getOpenedParticipations(): Collection
    {
        // create a criteria for filtering easily
        $criteria = Criteria::create();
        $criteria
            ->andWhere(Criteria::expr()->eq('endDate', NULL))
            ->orWhere(Criteria::expr()->gt('endDate', new \DateTime('now')))
            ;

        return $this->getAccompanyingPeriodParticipations()
            ->matching($criteria)
            ->filter(function (AccompanyingPeriodParticipation $app) {
                $period = $app->getAccompanyingPeriod();
                return (
                        NULL === $period->getClosingDate()
                            || new \DateTime('now') < $period->getClosingDate()
                    )
                    && AccompanyingPeriod::STEP_DRAFT !== $period->getStep();
            });
    }

    /**
     * Get the accompanying periods of a give person with the chronological order.
     */
    public function getAccompanyingPeriodsOrdered(): array
    {
        $periods = $this->getAccompanyingPeriods();

        //order by date :
        usort($periods, function($a, $b) {
            $dateA = $a->getOpeningDate();
            $dateB = $b->getOpeningDate();

            if ($dateA == $dateB) {
                $dateEA = $a->getClosingDate();
                $dateEB = $b->getClosingDate();

                if ($dateEA == $dateEB) {
                    return 0;
                }

                if ($dateEA < $dateEB) {
                    return -1;
                } else {
                    return +1;
                }
            }

            if ($dateA < $dateB) {
                return -1 ;
            } else {
                return 1;
            }
        });

        return $periods;
    }

    /**
     * Check if the person is opened
     */
    public function isOpen() : bool
    {
        foreach ($this->getAccompanyingPeriods() as $period) {
            if ($period->isOpen()) {
                return true;
            }
        }

        return false;
    }

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

    /**
     * Set firstName
     *
     * @param string $firstName
     * @return Person
     */
    public function setFirstName($firstName)
    {
        $this->firstName = $firstName;

        return $this;
    }

    /**
     * Get firstName
     *
     * @return string
     */
    public function getFirstName()
    {
        return $this->firstName;
    }

    /**
     * Set lastName
     *
     * @param string $lastName
     * @return Person
     */
    public function setLastName($lastName)
    {
        $this->lastName = $lastName;

        return $this;
    }

    /**
     * Get lastName
     *
     * @return string
     */
    public function getLastName()
    {
        return $this->lastName;
    }

    /**
     * @return Collection
     */
    public function getAltNames(): Collection
    {
        return $this->altNames;
    }

    /**
     * @param Collection $altNames
     * @return $this
     */
    public function setAltNames(Collection $altNames)
    {
        $this->altNames = $altNames;

        return $this;
    }

    /**
     * @param PersonAltName $altName
     * @return $this
     */
    public function addAltName(PersonAltName $altName)
    {
        if (FALSE === $this->altNames->contains($altName)) {
            $this->altNames->add($altName);
            $altName->setPerson($this);
        }

        return $this;
    }

    /**
     * @param PersonAltName $altName
     * @return $this
     */
    public function removeAltName(PersonAltName $altName)
    {
        if ($this->altNames->contains($altName)) {
            $altName->setPerson(null);
            $this->altNames->removeElement($altName);
        }

        return $this;
    }

    /**
     * Set birthdate
     *
     * @param \DateTime $birthdate
     * @return Person
     */
    public function setBirthdate($birthdate)
    {
        $this->birthdate = $birthdate;

        return $this;
    }

    /**
     * Get birthdate
     *
     * @return \DateTime
     */
    public function getBirthdate()
    {
        return $this->birthdate;
    }

    /**
     * Return the age of a person, calculated at the date 'now'.
     *
     * If the person has a deathdate, calculate the age at the deathdate.
     *
     * @param string $at a valid string to create a DateTime
     * @return int|null
     */
    public function getAge($at = 'now'): ?int
    {
        if ($this->birthdate instanceof \DateTimeInterface) {
            if ($this->deathdate instanceof \DateTimeInterface) {
                return date_diff($this->birthdate, $this->deathdate)->format("%y");
            }
            return date_diff($this->birthdate, date_create($at))->format("%y");
        }

        return null;
    }

    /**
     * Set placeOfBirth
     *
     * @param string $placeOfBirth
     * @return Person
     */
    public function setPlaceOfBirth($placeOfBirth)
    {
        if ($placeOfBirth === null) {
            $placeOfBirth = '';
        }

        $this->placeOfBirth = $placeOfBirth;

        return $this;
    }

    /**
     * Get placeOfBirth
     *
     * @return string
     */
    public function getPlaceOfBirth()
    {
        return $this->placeOfBirth;
    }

    /**
     * Set gender
     *
     * @param string $gender
     * @return Person
     */
    public function setGender($gender)
    {
        $this->gender = $gender;

        return $this;
    }

    /**
     * Get gender
     *
     * @return string
     */
    public function getGender()
    {
        return $this->gender;
    }

    /**
     * return gender as a Numeric form.
     * This is used for translations
     * @return int
     * @deprecated Keep for legacy. Used in Chill 1.5 for feminize before icu translations
     */
    public function getGenderNumeric()
    {
        switch ($this->getGender()) {
            case self::FEMALE_GENDER:
                return 1;
            case self::MALE_GENDER:
                return 0;
            case self::BOTH_GENDER:
                return 2;
            default:
                return -1;
        }
    }

    /**
     * Set memo
     *
     * @param string $memo
     * @return Person
     */
    public function setMemo($memo)
    {
        if ($memo === null) {
            $memo = '';
        }

        if ($this->memo !== $memo) {
            $this->memo = $memo;
        }

        return $this;
    }

    /**
     * Get memo
     *
     * @return string
     */
    public function getMemo()
    {
        return $this->memo;
    }

    /**
     * Set maritalStatus
     *
     * @param MaritalStatus $maritalStatus
     * @return Person
     */
    public function setMaritalStatus(MaritalStatus $maritalStatus = null)
    {
        $this->maritalStatus = $maritalStatus;
        return $this;
    }

    /**
     * Get maritalStatus
     *
     * @return MaritalStatus
     */
    public function getMaritalStatus()
    {
        return $this->maritalStatus;
    }

    /**
     * Set civility
     *
     * @param Civility $civility
     * @return Person
     */
    public function setCivility(Civility $civility = null)
    {
        $this->civility = $civility;
        return $this;
    }

    /**
     * Get civility
     *
     * @return Civility
     */
    public function getCivility()
    {
        return $this->civility;
    }

    /**
      * Set contactInfo
      *
      * @param string $contactInfo
      * @return Person
      */
     public function setcontactInfo($contactInfo)
     {
         if ($contactInfo === null) {
             $contactInfo = '';
         }

         $this->contactInfo = $contactInfo;

         return $this;
     }

     /**
      * Get contactInfo
      *
      * @return string
      */
     public function getcontactInfo()
     {
         return $this->contactInfo;
     }

    /**
     * Set email
     *
     * @param string $email
     * @return Person
     */
    public function setEmail($email)
    {
        if ($email === null) {
            $email = '';
        }

        $this->email = $email;

        return $this;
    }

    /**
     * Get email
     *
     * @return string
     */
    public function getEmail()
    {
        return $this->email;
    }

    /**
     * Set countryOfBirth
     *
     * @param Chill\MainBundle\Entity\Country $countryOfBirth
     * @return Person
     */
    public function setCountryOfBirth(Country $countryOfBirth = null)
    {
        $this->countryOfBirth = $countryOfBirth;
        return $this;
    }

    /**
     * Get countryOfBirth
     *
     * @return Chill\MainBundle\Entity\Country
     */
    public function getCountryOfBirth()
    {
        return $this->countryOfBirth;
    }

    /**
     * Set nationality
     *
     * @param Chill\MainBundle\Entity\Country $nationality
     * @return Person
     */
    public function setNationality(Country $nationality = null)
    {
        $this->nationality = $nationality;

        return $this;
    }

    /**
     * Get nationality
     *
     * @return Chill\MainBundle\Entity\Country
     */
    public function getNationality()
    {
        return $this->nationality;
    }

    /**
     * @return string
     */
    public function getLabel()
    {
        return $this->getFirstName()." ".$this->getLastName();
    }

    /**
     * Get center
     *
     * @return Center
     */
    public function getCenter()
    {
        return $this->center;
    }

    /**
     * Set the center
     *
     * @param Center $center
     * @return \Chill\PersonBundle\Entity\Person
     */
    public function setCenter(Center $center)
    {
        $this->center = $center;
        return $this;
    }

    /**
     * Set cFData
     *
     * @param array $cFData
     *
     * @return Report
     */
    public function setCFData($cFData)
    {
        $this->cFData = $cFData;

        return $this;
    }

    /**
     * Get cFData
     *
     * @return array
     */
    public function getCFData()
    {
        if ($this->cFData === null) {
            $this->cFData = [];
        }
        return $this->cFData;
    }

    /**
     * Set phonenumber
     *
     * @param string $phonenumber
     * @return Person
     */
    public function setPhonenumber(?string $phonenumber = '')
    {
        $this->phonenumber = (string) $phonenumber;

        return $this;
    }

    /**
     * Get phonenumber
     *
     * @return string
     */
    public function getPhonenumber()
    {
        return $this->phonenumber;
    }

    /**
     * Set mobilenumber
     *
     * @param string $mobilenumber
     * @return Person
     */
    public function setMobilenumber(?string $mobilenumber = '')
    {
        $this->mobilenumber = (string) $mobilenumber;

        return $this;
    }

    /**
     * Get mobilenumber
     *
     * @return string
     */
    public function getMobilenumber()
    {
        return $this->mobilenumber;
    }

    /**
     * @return Collection
     */
    public function getOtherPhoneNumbers(): Collection
    {
        return $this->otherPhoneNumbers;
    }

    /**
     * @param Collection $otherPhoneNumbers
     * @return $this
     */
    public function setOtherPhoneNumbers(Collection $otherPhoneNumbers)
    {
        $this->otherPhoneNumbers = $otherPhoneNumbers;

        return $this;
    }

    /**
     * @param PersonPhone $otherPhoneNumber
     * @return $this
     */
    public function addOtherPhoneNumber(PersonPhone $otherPhoneNumber)
    {
        if (false === $this->otherPhoneNumbers->contains($otherPhoneNumber)) {
            $otherPhoneNumber->setPerson($this);
            $this->otherPhoneNumbers->add($otherPhoneNumber);
        }

        return $this;
    }

    /**
     * @param PersonPhone $otherPhoneNumber
     * @return $this
     */
    public function removeOtherPhoneNumber(PersonPhone $otherPhoneNumber)
    {
        if ($this->otherPhoneNumbers->contains($otherPhoneNumber)) {
            $this->otherPhoneNumbers->removeElement($otherPhoneNumber);
        }

        return $this;
    }

    /**
     * @return string
     */
    public function __toString()
    {
        return $this->getLabel();
    }

    /**
     * Set spokenLanguages
     *
     * @param type $spokenLanguages
     * @return Person
     */
    public function setSpokenLanguages($spokenLanguages)
    {
        $this->spokenLanguages = $spokenLanguages;

        return $this;
    }

    /**
     * Get spokenLanguages
     *
     * @return ArrayCollection
     */
    public function getSpokenLanguages()
    {
        return $this->spokenLanguages;
    }

    /**
     * @param Address $address
     * @return $this
     */
    public function addAddress(Address $address)
    {
        $this->addresses[] = $address;

        return $this;
    }

    /**
     * @param Address $address
     */
    public function removeAddress(Address $address)
    {
        $this->addresses->removeElement($address);
    }

    /**
     * By default, the addresses are ordered by date, descending (the most
     * recent first)
     */
    public function getAddresses(): Collection
    {
        return $this->addresses;
    }

    /**
     * @deprecated Use `getCurrentPersonAddress` instead
     * @param DateTime|null $from
     * @return false|mixed|null
     * @throws \Exception
     */
    public function getLastAddress(DateTime $from = null)
    {
        return $this->getCurrentPersonAddress($from);
    }

    /**
     * get the address associated with the person at the given date
     *
     * If the `$at` parameter is now, use the method `getCurrentPersonAddress`, which is optimized
     * on database side.
     *
     * @param DateTime|null $at
     * @return Address|null
     * @throws \Exception
     */
    public function getAddressAt(?\DateTime $at = null): ?Address
    {
        $at ??= new DateTime('now');

        /** @var ArrayIterator $addressesIterator */
        $addressesIterator = $this->getAddresses()
            ->filter(static fn (Address $address): bool => $address->getValidFrom() <= $at)
            ->getIterator();

        $addressesIterator->uasort(
            static fn (Address $left, Address $right): int => $right->getValidFrom() <=> $left->getValidFrom()
        );

        return [] === ($addresses = iterator_to_array($addressesIterator)) ?
            null :
            current($addresses);
    }

    /**
     * Get the current person address
     *
     * @return Address|null
     */
    public function getCurrentPersonAddress(): ?Address
    {
        if (null === $this->currentPersonAddress) {
            return null;
        }

        return $this->currentPersonAddress->getAddress();
    }

    /**
     * Validation callback that checks if the accompanying periods are valid
     *
     * This method add violation errors.
     *
     * @Assert\Callback(
     *      groups={"accompanying_period_consistent"}
     * )
     */
    public function isAccompanyingPeriodValid(ExecutionContextInterface $context)
    {
        $r = $this->checkAccompanyingPeriodsAreNotCollapsing();

        if ($r !== true) {
            if ($r['result'] === self::ERROR_PERIODS_ARE_COLLAPSING) {
                $context->buildViolation('Two accompanying periods have days in commun')
                    ->atPath('accompanyingPeriods')
                    ->addViolation();
            }

            if ($r['result'] === self::ERROR_ADDIND_PERIOD_AFTER_AN_OPEN_PERIOD) {
                $context->buildViolation('A period is opened and a period is added after it')
                    ->atPath('accompanyingPeriods')
                    ->addViolation();
            }
        }
    }

    /**
     * Return true if the person has two addresses with the
     * same validFrom date (in format 'Y-m-d')
     */
    public function hasTwoAdressWithSameValidFromDate()
    {
        $validYMDDates = array();

        foreach ($this->addresses as $ad) {
            $validDate = $ad->getValidFrom()->format('Y-m-d');

            if (in_array($validDate, $validYMDDates)) {
                return true;
            }
            $validYMDDates[] = $validDate;
        }

        return false;
    }

    /**
     * Validation callback that checks if the addresses are valid (do not have
     * two addresses with the same validFrom date)
     *
     * This method add violation errors.
     *
     * @Assert\Callback(
     *     groups={"addresses_consistent"}
     * )
     */
    public function isAddressesValid(ExecutionContextInterface $context)
    {
        if ($this->hasTwoAdressWithSameValidFromDate()) {
            $context
                ->buildViolation('Two addresses has the same validFrom date')
                ->atPath('addresses')
                ->addViolation()
                ;
        }
    }


    const ERROR_PERIODS_ARE_COLLAPSING = 1; // when two different periods
    // have days in commun
    const ERROR_ADDIND_PERIOD_AFTER_AN_OPEN_PERIOD = 2; // where there exist
    // a period opened and another one after it

    /**
     * Function used for validation that check if the accompanying periods of
     * the person are not collapsing (i.e. have not shared days) or having
     * a period after an open period.
     *
     * @return true | array True if the accompanying periods are not collapsing,
     * an array with data for displaying the error
     */
    public function checkAccompanyingPeriodsAreNotCollapsing()
    {
        $periods = $this->getAccompanyingPeriodsOrdered();
        $periodsNbr = sizeof($periods);
        $i = 0;

        while($i < $periodsNbr - 1) {
            $periodI = $periods[$i];
            $periodAfterI = $periods[$i + 1];

            if($periodI->isOpen()) {
                return array(
                    'result' => self::ERROR_ADDIND_PERIOD_AFTER_AN_OPEN_PERIOD,
                    'dateOpening' => $periodAfterI->getOpeningDate(),
                    'dateClosing' => $periodAfterI->getClosingDate(),
                    'date' => $periodI->getOpeningDate()
                );
            } elseif ($periodI->getClosingDate() >= $periodAfterI->getOpeningDate()) {
                return array(
                    'result' => self::ERROR_PERIODS_ARE_COLLAPSING,
                    'dateOpening' => $periodI->getOpeningDate(),

                    'dateClosing' => $periodI->getClosingDate(),
                    'date' => $periodAfterI->getOpeningDate()
                );
            }
            $i++;
        }

        return true;
    }

    public function getFullnameCanonical() : string
    {
        return $this->fullnameCanonical;
    }

    public function setFullnameCanonical($fullnameCanonical) : Person
    {
        $this->fullnameCanonical = $fullnameCanonical;
        return $this;
    }

    public function addHouseholdParticipation(HouseholdMember $member): self
    {
        $this->householdParticipations[] = $member;

        return $this;
    }

    public function getHouseholdParticipations(): Collection
    {
        return $this->householdParticipations;
    }

    /**
     * Get participation where the person does share the household.
     *
     * Order by startDate, desc
     */
    public function getHouseholdParticipationsShareHousehold(): Collection
    {
        $criteria = new Criteria();
        $expr = Criteria::expr();

        $criteria
            ->where(
                $expr->eq('shareHousehold', true)
            )
            ->orderBy(['startDate' => Criteria::DESC])
            ;

        return $this->getHouseholdParticipations()
            ->matching($criteria)
            ;
    }

    /**
     * Get participation where the person does not share the household.
     *
     * Order by startDate, desc
     */
    public function getHouseholdParticipationsNotShareHousehold(): Collection
    {
        $criteria = new Criteria();
        $expr = Criteria::expr();

        $criteria
            ->where(
                $expr->eq('shareHousehold', false)
            )
            ->orderBy(['startDate' => Criteria::DESC])
            ;

        return $this->getHouseholdParticipations()
            ->matching($criteria)
            ;
    }

    public function getCurrentHousehold(?\DateTimeImmutable $at = null): ?Household
    {
        $participation = $this->getCurrentHouseholdParticipationShareHousehold($at);

        return $participation instanceof HouseholdMember ?
            $participation->getHousehold()
            : null;
    }

    public function getCurrentHouseholdParticipationShareHousehold(?\DateTimeImmutable $at = null): ?HouseholdMember
    {
        $criteria = new Criteria();
        $expr = Criteria::expr();
        $date = NULL === $at ? new \DateTimeImmutable('today') : $at;
        $datef = $date->format('Y-m-d');

        if (
            NULL !== ($this->currentHouseholdParticipationAt[$datef] ?? NULL)) {
            return $this->currentHouseholdParticipationAt[$datef];
        }

        $criteria
            ->where(
                $expr->andX(
                    $expr->lte('startDate', $date),
                    $expr->orX(
                        $expr->isNull('endDate'),
                        $expr->gt('endDate', $date)
                    ),
                    $expr->eq('shareHousehold', true)
                )
            );

        $participations = $this->getHouseholdParticipations()
            ->matching($criteria)
            ;

        return $participations->count() > 0 ?
            $this->currentHouseholdParticipationAt[$datef] = $participations->first()
            : null;
    }

    public function isSharingHousehold(?\DateTimeImmutable $at = null): bool
    {
        return NULL !== $this->getCurrentHousehold($at);
    }

    public function getHouseholdAddresses(): Collection
    {
        return $this->householdAddresses;
    }

    public function getCurrentHouseholdAddress(?\DateTimeImmutable $at = null): ?Address
    {
        if (
            NULL === $at
            ||
            $at->format('Ymd') === (new \DateTime('today'))->format('Ymd')
        ) {
            return $this->currentPersonAddress instanceof PersonCurrentAddress
                ? $this->currentPersonAddress->getAddress() : NULL;
        }

        // if not now, compute the date from history
        $criteria = new Criteria();
        $expr = Criteria::expr();

        $criteria->where(
                $expr->lte('validFrom', $at)
            )
            ->andWhere(
                $expr->orX(
                    $expr->isNull('validTo'),
                    $expr->gte('validTo', $at)
                )
            );

        $addrs = $this->getHouseholdAddresses()
            ->matching($criteria)
            ;

        if ($addrs->count() > 0) {
            return $addrs->first()->getAddress();
        } else {
            return null;
        }
    }

    public function hasCurrentHouseholdAddress(?\DateTimeImmutable $at = null): bool
    {
        return null !== $this->getCurrentHouseholdAddress($at);
    }

    public function getGenderComment(): CommentEmbeddable
    {
        return $this->genderComment;
    }

    public function setGenderComment(CommentEmbeddable $genderComment): self
    {
        $this->genderComment = $genderComment;

        return $this;
    }

    public function getMaritalStatusComment(): CommentEmbeddable
    {
        return $this->maritalStatusComment;
    }

    public function setMaritalStatusComment(CommentEmbeddable $maritalStatusComment): self
    {
        $this->maritalStatusComment = $maritalStatusComment;

        return $this;
    }

    public function getDeathdate(): ?\DateTimeInterface
    {
        return $this->deathdate;
    }

    public function setDeathdate(?\DateTimeInterface $deathdate): self
    {
        $this->deathdate = $deathdate;

        return $this;
    }

    public function getMaritalStatusDate(): ?\DateTimeInterface
    {
        return $this->maritalStatusDate;
    }

    public function setMaritalStatusDate(?\DateTimeInterface $maritalStatusDate): self
    {
        $this->maritalStatusDate = $maritalStatusDate;

        return $this;
    }

    public function getAcceptSMS(): ?bool
    {
        return $this->acceptSMS;
    }

    public function setAcceptSMS(bool $acceptSMS): self
    {
        $this->acceptSMS = $acceptSMS;

        return $this;
    }

    public function getAcceptEmail(): ?bool
    {
        return $this->acceptEmail;
    }

    public function setAcceptEmail(bool $acceptEmail): self
    {
        $this->acceptEmail = $acceptEmail;

        return $this;
    }

    public function getNumberOfChildren(): ?int
    {
        return $this->numberOfChildren;
    }

    public function setNumberOfChildren(int $numberOfChildren): self
    {
        $this->numberOfChildren = $numberOfChildren;

        return $this;
    }

    /**
     * @return AccompanyingPeriod[]|Collection
     */
    public function getAccompanyingPeriodRequested(): Collection
    {
        return $this->accompanyingPeriodRequested;
    }

    /**
     * Return a list of all accompanying period where the person is involved:
     *
     * * as requestor;
     * * as participant, only for opened participation;
     *
     * @param bool $asParticipantOpen add participation which are still opened
     * @param bool $asRequestor add accompanying period where the person is requestor
     * @return AccompanyingPeriod[]|Collection
     */
    public function getAccompanyingPeriodInvolved(
        bool $asParticipantOpen = true,
        bool $asRequestor = true
    ): Collection
    {
       $result = new ArrayCollection();

       if ($asParticipantOpen) {
           foreach ($this->getOpenedParticipations()
                        ->map(fn (AccompanyingPeriodParticipation $app) =>
                            $app->getAccompanyingPeriod())
               as $period
           ) {
               if (!$result->contains($period)) {
                   $result->add($period);
               }
           }
       }

       if ($asRequestor) {
           foreach ($this->accompanyingPeriodRequested as $period) {
               if (!$result->contains($period)) {
                   $result->add($period);
               }
           }
       }

       return $result;
    }

    /**
     * Handy method to get the AccompanyingPeriodParticipation
     * matching a given AccompanyingPeriod.
     *
     * Used in template, to find the participation when iterating on a list
     * of period.
     *
     * @param \Chill\PersonBundle\Entity\AccompanyingPeriod $period
     * @return AccompanyingPeriodParticipation
     */
    public function findParticipationForPeriod(AccompanyingPeriod $period): ?AccompanyingPeriodParticipation
    {
        $closeCandidates = [];

        foreach ($this->getAccompanyingPeriodParticipations() as $participation) {
            if ($participation->getAccompanyingPeriod() === $period) {
                if ($participation->isOpen()) {
                    return $participation;
                }
                $closeCandidates[] = $participation;
            }
        }

        if (0 < count($closeCandidates)) {
            return $closeCandidates[0];
        }

        return null;
    }

    public function getCreatedBy(): ?User
    {
        return $this->createdBy;
    }

    public function setCreatedBy(User $createdBy): self
    {
        $this->createdBy = $createdBy;

        return $this;
    }

    public function getCreatedAt(): ?DateTimeInterface
    {
        return $this->createdAt;
    }

    public function setCreatedAt(\DateTimeInterface $datetime): self
    {
        $this->createdAt = $datetime;

        return $this;
    }

    public function getUpdatedBy(): ?User
    {
        return $this->updatedBy;
    }

    public function getUpdatedAt(): ?DateTimeInterface
    {
        return $this->updatedAt;
    }

    public function setUpdatedBy(User $user): self
    {
        $this->updatedBy = $user;

        return $this;
    }

    public function setUpdatedAt(\DateTimeInterface $datetime): self
    {
        $this->updatedAt = $datetime;

        return $this;
    }

}