<?php

namespace Chill\PersonBundle\Controller;

use Chill\PersonBundle\Entity\Household\Position;
use Chill\PersonBundle\Security\Authorization\PersonVoter;
use Chill\PersonBundle\Entity\Person;
use Chill\PersonBundle\Entity\Household\Household;
use Chill\PersonBundle\Form\HouseholdMemberType;
use Chill\PersonBundle\Entity\Household\HouseholdMember;
use Symfony\Component\HttpFoundation\Exception\BadRequestException;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
use Symfony\Component\Serializer\Exception;
use Symfony\Component\Routing\Annotation\Route;
use Chill\MainBundle\CRUD\Controller\ApiController;
use Symfony\Component\Translation\TranslatorInterface;
use Chill\PersonBundle\Household\MembersEditor;
use Symfony\Component\Serializer\Normalizer\AbstractNormalizer;

class HouseholdMemberController extends ApiController
{
    private UrlGeneratorInterface $generator;

    private TranslatorInterface $translator;


    public function __construct(UrlGeneratorInterface $generator, TranslatorInterface $translator)
    {
        $this->generator = $generator;
        $this->translator = $translator;
    }
    
    /**
     * @Route(
     *      "/api/1.0/person/household/members/move.{_format}",
     *      name="chill_api_person_household_members_move"
     *  )
     */
    public function move(Request $request, $_format): Response
    {
        try {
            $editor = $this->getSerializer()
                ->deserialize($request->getContent(), MembersEditor::class,
                    $_format, ['groups' => [ "read" ]]);
        } catch (Exception\InvalidArgumentException | Exception\UnexpectedValueException $e) {
            throw new BadRequestException("Deserialization error: {$e->getMessage()}", 45896, $e);
        }

        // TODO ACL
        //
        // TODO validation
        //
        $em = $this->getDoctrine()->getManager();

        // if new household, persist it
        if (
            $editor->hasHousehold()
            &&
            FALSE === $em->contains($editor->getHousehold())
        ) {
            $em->persist($editor->getHousehold());
        }

        foreach ($editor->getPersistable() as $el) {
           $em->persist($el); 
        }
        $em->flush();

        return $this->json($editor->getHousehold(), Response::HTTP_OK, [], ["groups" => ["read"]]);
    }

    /**
     * @Route(
     *      "/{_locale}/person/household/members/editor",
     *      name="chill_person_household_members_editor"
     *  )
     */
    public function editor(Request $request)
    {
        $em = $this->getDoctrine()->getManager();

        if ($request->query->has('persons')) {
            $ids = $request->query->get('persons', []);

            if (0 === count($ids)) {
                throw new BadRequestExceptions("parameters persons in query ".
                    "is not an array or empty");
            }

            $persons = $em->getRepository(Person::class)
                ->findById($ids)
                ;

            foreach ($persons as $person) {
                $this->denyAccessUnlessGranted(PersonVoter::SEE, $person, 
                    "You are not allowed to see person with id {$person->getId()}"
                );
            }
        }

        if ($householdId = $request->query->get('household', false)) {
            $household = $em->getRepository(Household::class)
                ->find($householdId)
                ;
            $allowHouseholdCreate = false;
            $allowHouseholdSearch = false;
            $allowLeaveWithoutHousehold = false;

            if (NULL === $household) {
                throw $this->createNotFoundException('household not found');
            }
            // TODO ACL on household
        }

        $positions = $this->getDoctrine()->getManager()
            ->getRepository(Position::class)
            ->findAll()
            ;

        $data = [
            'persons' => $persons ?? false ? 
                $this->getSerializer()->normalize($persons, 'json', [ 'groups' => [ 'read' ]]) : [],
            'household' => $household ?? false ?
                $this->getSerializer()->normalize($household, 'json', [ 'groups' => [ 'read' ]]) : null,
            'positions' => 
                $this->getSerializer()->normalize($positions, 'json', [ 'groups' => [ 'read' ]]),
            'allowHouseholdCreate' => $allowHouseholdCreate ?? true,
            'allowHouseholdSearch' => $allowHouseholdSearch ?? true,
            'allowLeaveWithoutHousehold' => $allowLeaveWithoutHousehold ?? $request->query->has('allow_leave_without_household'),
        ];

        return $this->render('@ChillPerson/Household/members_editor.html.twig', [
            'data' => $data 
        ]);
    }

    /**
     * @Route(
     *      "/{_locale}/person/household/member/{id}/edit",
     *      name="chill_person_household_member_edit"
     *  )
     */
    public function editMembership(Request $request, HouseholdMember $member): Response
    {
        // TODO ACL

        $form = $this->createForm(HouseholdMemberType::class, $member);
        $form->handleRequest($request);

        if ($form->isSubmitted() && $form->isValid()) {
            $this->getDoctrine()->getManager()->flush();

            $this->addFlash('success', $this->translator
                ->trans('household.successfully saved member')) 
                ;

            return $this->redirect(
                $request->get('returnPath', null) ??
                $this->generator->generate('chill_person_household_members', [ 'household_id' => 
                    $member->getHousehold()->getId() ])
                );
        }

        return $this->render('@ChillPerson/Household/Member/edit.html.twig', [
            'household' => $member->getHousehold(),
            'member' => $member,
            'form' => $form->createView()
        ]);

    }
}