<?php

/**
 * Chill is a software for social workers
 *
 * For the full copyright and license information, please view
 * the LICENSE file that was distributed with this source code.
 */

declare(strict_types=1);

namespace Chill\PersonBundle\Serializer\Normalizer;

use Chill\DocGeneratorBundle\Serializer\Helper\NormalizeNullValueHelper;
use Chill\MainBundle\Templating\TranslatableStringHelper;
use Chill\PersonBundle\Entity\Household\Household;
use Chill\PersonBundle\Entity\Person;
use Chill\PersonBundle\Entity\PersonAltName;
use Chill\PersonBundle\Repository\Relationships\RelationRepository;
use Chill\PersonBundle\Repository\Relationships\RelationshipRepository;
use Chill\PersonBundle\Templating\Entity\PersonRender;
use DateTimeInterface;
use Symfony\Component\Serializer\Normalizer\ContextAwareNormalizerInterface;
use Symfony\Component\Serializer\Normalizer\NormalizerAwareInterface;
use Symfony\Component\Serializer\Normalizer\NormalizerAwareTrait;
use Symfony\Contracts\Translation\TranslatorInterface;
use function array_key_exists;
use function array_map;
use function implode;

class PersonDocGenNormalizer implements
    ContextAwareNormalizerInterface,
    NormalizerAwareInterface
{
    use NormalizerAwareTrait;

    private PersonRender $personRender;

    private RelationshipRepository $relationshipRepository;

    private TranslatableStringHelper $translatableStringHelper;

    private TranslatorInterface $translator;

    public function __construct(
        PersonRender $personRender,
        RelationshipRepository $relationshipRepository,
        TranslatorInterface $translator,
        TranslatableStringHelper $translatableStringHelper
    ) {
        $this->personRender = $personRender;
        $this->relationshipRepository = $relationshipRepository;
        $this->translator = $translator;
        $this->translatableStringHelper = $translatableStringHelper;
    }

    public function normalize($person, ?string $format = null, array $context = [])
    {
        /** @var Person $person */
        $dateContext = $context;
        $dateContext['docgen:expects'] = DateTimeInterface::class;

        if (null === $person) {
            return $this->normalizeNullValue($format, $context);
        }

        $data = [
            'firstname' => $person->getFirstName(),
            'lastname' => $person->getLastName(),
            'altNames' => implode(
                ', ',
                array_map(
                    static function (PersonAltName $altName) {
                        return $altName->getLabel();
                    },
                    $person->getAltNames()->toArray()
                )
            ),
            'text' => $this->personRender->renderString($person, []),
            'birthdate' => $this->normalizer->normalize($person->getBirthdate(), $format, $dateContext),
            'deathdate' => $this->normalizer->normalize($person->getDeathdate(), $format, $dateContext),
            'gender' => $this->translator->trans($person->getGender()),
            'maritalStatus' => null !== ($ms = $person->getMaritalStatus()) ? $this->translatableStringHelper->localize($ms->getName()) : '',
            'maritalStatusDate' => $this->normalizer->normalize($person->getMaritalStatusDate(), $format, $dateContext),
            'email' => $person->getEmail(),
            'firstPhoneNumber' => $person->getPhonenumber() ?? $person->getMobilenumber(),
            'fixPhoneNumber' => $person->getPhonenumber(),
            'mobilePhoneNumber' => $person->getMobilenumber(),
            'nationality' => null !== ($c = $person->getNationality()) ? $this->translatableStringHelper->localize($c->getName()) : '',
            'placeOfBirth' => $person->getPlaceOfBirth(),
            'memo' => $person->getMemo(),
            'numberOfChildren' => (string) $person->getNumberOfChildren(),
        ];

        if ($context['docgen:person:with-household'] ?? false) {
            $data['household'] = $this->normalizer->normalize(
                $person->getCurrentHousehold(),
                $format,
                array_merge($context, ['docgen:expects' => Household::class])
            );
        }

        if ($context['docgen:person:with-relations'] ?? false) {
            $data['relations'] = $this->normalizer->normalize(
                $this->relationshipRepository->findByPerson($person),
                $format,
                array_merge($context, [
                    'docgen:person:with-household' => false,
                    'docgen:person:with-relation' => false,
                    'docgen:relationship:counterpart' => $person
                    ])
            );
        }

        return $data;
    }

    public function supportsNormalization($data, ?string $format = null, array $context = [])
    {
        if ('docgen' !== $format) {
            return false;
        }

        return
            $data instanceof Person
            || (
                array_key_exists('docgen:expects', $context)
                && Person::class === $context['docgen:expects']
            );
    }

    private function normalizeNullValue(string $format, array $context)
    {
        $normalizer = new NormalizeNullValueHelper($this->normalizer);

        $attributes = [
            'firstname', 'lastname', 'altNames', 'text',
            'birthdate' => DateTimeInterface::class,
            'deathdate' => DateTimeInterface::class,
            'gender', 'maritalStatus',
            'maritalStatusDate' => DateTimeInterface::class,
            'email', 'firstPhoneNumber', 'fixPhoneNumber', 'mobilePhoneNumber', 'nationality',
            'placeOfBirth', 'memo', 'numberOfChildren',
        ];

        return $normalizer->normalize($attributes, $format, $context);
    }
}