<?php

declare(strict_types=1);

namespace Mummert\SurveyBundle\Controller\FrontendModule;

use Contao\Config;
use Contao\CoreBundle\Controller\FrontendModule\AbstractFrontendModuleController;
use Contao\CoreBundle\DependencyInjection\Attribute\AsFrontendModule;
use Contao\CoreBundle\Twig\FragmentTemplate;
use Contao\FrontendUser;
use Contao\ModuleModel;
use Contao\PageModel;
use Mummert\SurveyBundle\Form\Model\SurveyEditorData;
use Mummert\SurveyBundle\Form\Model\SurveyQuestionData;
use Mummert\SurveyBundle\Form\SurveyEditorType;
use Mummert\SurveyBundle\Form\SurveyQuestionEditorType;
use Mummert\SurveyBundle\Model\SurveyModel;
use Mummert\SurveyBundle\Repository\SurveyConditionRepository;
use Mummert\SurveyBundle\Repository\SurveyEditorRepository;
use Mummert\SurveyBundle\Repository\SurveyQuestionRepository;
use Mummert\SurveyBundle\Repository\SurveyRepository;
use Mummert\SurveyBundle\Service\SurveyEditorService;
use Mummert\SurveyBundle\Service\SurveySubmissionService;
use Symfony\Component\Form\FormFactoryInterface;
use Symfony\Component\Form\FormInterface;
use Symfony\Component\HttpFoundation\RedirectResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;

#[AsFrontendModule(type: 'member_survey_edit', category: 'survey', template: 'member_survey_edit')]
final class MemberSurveyEditController extends AbstractFrontendModuleController
{
    public function __construct(
        private readonly SurveyRepository $surveyRepository,
        private readonly SurveyQuestionRepository $surveyQuestionRepository,
        private readonly SurveyConditionRepository $surveyConditionRepository,
        private readonly SurveyEditorRepository $surveyEditorRepository,
        private readonly SurveyEditorService $surveyEditorService,
        private readonly SurveySubmissionService $surveySubmissionService,
        private readonly FormFactoryInterface $formFactory,
    ) {
    }

    protected function getResponse(FragmentTemplate $template, ModuleModel $model, Request $request): Response
    {
        $memberId = $this->resolveEditorMemberId($request);

        if ($memberId <= 0) {
            $template->set('loginRequired', true);
            $template->set('entryNotAllowed', false);
            $template->set('backUrl', $this->resolveListUrl($model));
            $template->set('createQuestionMode', false);

            return $template->getResponse();
        }

        if (!$this->isEditorEntryAllowed($request)) {
            $template->set('loginRequired', false);
            $template->set('entryNotAllowed', true);
            $template->set('createMode', false);
            $template->set('survey', null);
            $template->set('backUrl', $this->resolveListUrl($model));
            $template->set('createQuestionMode', false);

            return $template->getResponse();
        }

        $survey = $this->resolveSurvey($request, $memberId);
        $createQuestionMode = $this->isCreateQuestionRequested($request);

        if ($survey instanceof SurveyModel && $request->isMethod('POST') && $request->request->has('_survey_action')) {
            return $this->handleAction($survey, $request, $model, $memberId);
        }

        $surveyForm = $this->formFactory->createNamed('survey_meta', SurveyEditorType::class, $survey instanceof SurveyModel ? SurveyEditorData::fromModel($survey) : new SurveyEditorData());
        $surveyForm->handleRequest($request);

        if ($surveyForm->isSubmitted() && $surveyForm->isValid()) {
            try {
                if ($survey instanceof SurveyModel) {
                    $this->surveyEditorService->updateSurvey($survey, $memberId, $surveyForm->getData());
                    $this->addFlash('success', 'Die Umfrage wurde gespeichert.');

                    return new RedirectResponse($this->buildEditUrl($model, $request, (int) $survey->id));
                }

                $createdSurvey = $this->surveyEditorService->createSurvey($memberId, $surveyForm->getData());
                $this->addFlash('success', 'Die Umfrage wurde angelegt.');

                return new RedirectResponse($this->buildEditUrl($model, $request, (int) $createdSurvey->id));
            } catch (\Throwable $exception) {
                $this->addFlash('error', $exception->getMessage());
            }
        }

        if (!$survey instanceof SurveyModel) {
            $template->set('loginRequired', false);
            $template->set('entryNotAllowed', false);
            $template->set('createMode', true);
            $template->set('structureLocked', false);
            $template->set('surveyForm', $surveyForm->createView());
            $template->set('backUrl', $this->resolveListUrl($model));
            $template->set('publicUrl', null);
            $template->set('survey', null);
            $template->set('questions', []);
            $template->set('conditions', []);
            $template->set('editors', []);
            $template->set('submissions', []);
            $template->set('activeQuestionId', 0);
            $template->set('createQuestionMode', false);

            return $template->getResponse();
        }

        $structureLocked = $this->surveyEditorService->isStructureLocked($survey);

        $questions = $this->surveyQuestionRepository->findAllBySurvey((int) $survey->id);
        $activeQuestion = $this->resolveActiveQuestion($request, (int) $survey->id);
        $activeQuestionId = $activeQuestion ? (int) $activeQuestion->id : 0;
        $questionFormViews = [];
        $newQuestionFormView = null;

        if (!$structureLocked) {
            foreach ($questions as $question) {
                $questionId = (int) $question->id;
                $questionForm = $this->formFactory->createNamed('survey_question_'.$questionId, SurveyQuestionEditorType::class, SurveyQuestionData::fromModel($question), [
                    'question_choices' => $this->buildQuestionChoices((int) $survey->id, $questionId),
                ]);
                $questionForm->handleRequest($request);

                if ($questionForm->isSubmitted()) {
                    $activeQuestionId = $questionId;
                    $createQuestionMode = false;

                    if ($questionForm->isValid()) {
                        try {
                            $this->surveyEditorService->saveQuestion($survey, $questionForm->getData(), $questionId);
                            $this->addFlash('success', 'Die Frage wurde aktualisiert.');

                            return new RedirectResponse($this->buildEditUrl($model, $request, (int) $survey->id));
                        } catch (\Throwable $exception) {
                            $this->addFlash('error', $exception->getMessage());
                        }
                    } else {
                        $this->addFlash('error', 'Frage konnte nicht gespeichert werden: '.$this->describeFormErrors($questionForm));
                    }
                }

                $questionFormViews[$questionId] = $questionForm->createView();
            }

            $newQuestionForm = $this->formFactory->createNamed('survey_question_new', SurveyQuestionEditorType::class, new SurveyQuestionData(), [
                'question_choices' => $this->buildQuestionChoices((int) $survey->id),
            ]);
            $newQuestionForm->handleRequest($request);

            if ($newQuestionForm->isSubmitted()) {
                $activeQuestionId = 0;
                $createQuestionMode = true;

                if ($newQuestionForm->isValid()) {
                    try {
                        $this->surveyEditorService->saveQuestion($survey, $newQuestionForm->getData(), 0);
                        $this->addFlash('success', 'Die Frage wurde angelegt.');

                        return new RedirectResponse($this->buildEditUrl($model, $request, (int) $survey->id));
                    } catch (\Throwable $exception) {
                        $this->addFlash('error', $exception->getMessage());
                    }
                } else {
                    $this->addFlash('error', 'Neue Frage konnte nicht gespeichert werden: '.$this->describeFormErrors($newQuestionForm));
                }
            }

            $newQuestionFormView = $newQuestionForm->createView();
        }

        $template->set('loginRequired', false);
        $template->set('entryNotAllowed', false);
        $template->set('createMode', false);
        $template->set('structureLocked', $structureLocked);
        $template->set('createQuestionMode', $createQuestionMode);
        $template->set('survey', $survey);
        $template->set('surveyForm', $surveyForm->createView());
        $template->set('questionForms', $questionFormViews);
        $template->set('newQuestionForm', $newQuestionFormView);
        $template->set('questions', $questions);
        $conditionOverview = $this->surveyConditionRepository->findOverviewBySurvey((int) $survey->id);

        $template->set('conditions', $this->buildJumpRuleOverview($questions, $conditionOverview));
        $template->set('editors', $this->surveyEditorRepository->findEditorsBySurvey((int) $survey->id));
        $template->set('submissions', $this->surveySubmissionService->getSubmissionOverview($survey));
        $template->set('activeQuestionId', $activeQuestionId);
        $template->set('backUrl', $this->resolveListUrl($model));
        $template->set('publicUrl', $this->resolveReaderUrl($model, (string) $survey->alias));
        $template->set('metadataFormActionUrl', $this->buildEditUrl($model, $request, (int) $survey->id));

        return $template->getResponse();
    }

    private function resolveSurvey(Request $request, int $memberId): ?SurveyModel
    {
        $surveyId = (int) $request->query->get('survey', 0);

        if ($surveyId <= 0) {
            return null;
        }

        $survey = $this->surveyRepository->findById($surveyId);

        if (!$survey instanceof SurveyModel) {
            throw new \RuntimeException('Die Umfrage wurde nicht gefunden.');
        }

        if (!$this->surveyEditorRepository->isEditor((int) $survey->id, $memberId)) {
            throw new \RuntimeException('Sie dürfen diese Umfrage nicht bearbeiten.');
        }

        return $survey;
    }

    private function resolveEditorMemberId(Request $request): int
    {
        $user = $this->getUser();

        if ($user instanceof FrontendUser) {
            return (int) $user->id;
        }

        return $this->isDebugAccessAllowed($request) ? $this->resolveDebugMemberId($request) : 0;
    }

    private function resolveDebugMemberId(Request $request): int
    {
        $memberId = (int) $request->query->get('debugMember', 0);

        if ($memberId > 0) {
            return $memberId;
        }

        $surveyId = (int) $request->query->get('survey', 0);

        if ($surveyId <= 0) {
            return 0;
        }

        $memberIds = $this->surveyEditorRepository->findMemberIdsBySurvey($surveyId);

        return $memberIds[0] ?? 0;
    }

    private function isDebugAccessAllowed(Request $request): bool
    {
        $host = strtolower((string) ($request->server->get('HTTP_HOST') ?: $request->getHost()));

        return (
            'localhost' === $host
            || '127.0.0.1' === $host
            || str_ends_with($host, '.ddev.site')
        ) && $request->query->getBoolean('debugAccess');
    }

    private function handleAction(SurveyModel $survey, Request $request, ModuleModel $model, int $memberId): Response
    {
        $action = (string) $request->request->get('_survey_action');
        $itemId = (int) $request->request->get('item_id', 0);
        $token = (string) $request->request->get('_token');

        if (!$this->isCsrfTokenValid($action.'-'.$itemId, $token)) {
            throw new \RuntimeException('Ungültiger CSRF-Token.');
        }

        try {
            if ('publish-survey' === $action) {
                $this->surveyEditorService->publishSurvey($survey, $memberId);
                $this->addFlash('success', 'Die Umfrage ist jetzt veröffentlicht.');
            }

            if ('toggle-active' === $action) {
                $isActive = $this->surveyEditorService->toggleSurveyActive($survey, $memberId);
                $this->addFlash('success', $isActive ? 'Die Umfrage ist jetzt wieder aktiv.' : 'Die Umfrage wurde vorübergehend deaktiviert.');
            }

            if ('delete-question' === $action) {
                $this->surveyEditorService->deleteQuestion($survey, $itemId);
                $this->addFlash('success', 'Die Frage wurde gelöscht.');
            }

            if ('delete-condition' === $action) {
                $this->surveyEditorService->deleteCondition($survey, $itemId);
                $this->addFlash('success', 'Die Bedingung wurde gelöscht.');
            }
        } catch (\Throwable $exception) {
            $this->addFlash('error', $exception->getMessage());
        }

        return new RedirectResponse($this->buildEditUrl($model, $request, (int) $survey->id));
    }

    private function resolveActiveQuestion(Request $request, int $surveyId): mixed
    {
        $questionId = (int) $request->query->get('question', 0);

        return $questionId > 0 ? $this->surveyQuestionRepository->findByIdForSurvey($surveyId, $questionId) : null;
    }

    private function isCreateQuestionRequested(Request $request): bool
    {
        return 'new' === trim((string) $request->query->get('question', ''));
    }

    private function isEditorEntryAllowed(Request $request): bool
    {
        if ((int) $request->query->get('survey', 0) > 0) {
            return true;
        }

        return $request->query->getBoolean('create');
    }

    /**
     * @return array<int, string>
     */
    private function buildQuestionChoices(int $surveyId, int $excludeQuestionId = 0): array
    {
        $choices = [];

        foreach ($this->surveyQuestionRepository->findAllBySurvey($surveyId) as $question) {
            if ($excludeQuestionId > 0 && (int) $question->id === $excludeQuestionId) {
                continue;
            }

            $choices[(int) $question->id] = sprintf('#%d %s', (int) $question->id, (string) $question->question);
        }

        return $choices;
    }

    /**
     * @param array<int, mixed> $questions
     * @param list<array<string, mixed>> $conditionOverview
     *
     * @return list<array<string, mixed>>
     */
    private function buildJumpRuleOverview(array $questions, array $conditionOverview): array
    {
        $questionLabels = [];
        $questionSortings = [];
        $rules = [];

        foreach ($questions as $question) {
            $questionId = (int) ($question->id ?? 0);

            if ($questionId <= 0) {
                continue;
            }

            $questionLabels[$questionId] = (string) ($question->question ?? '');
            $questionSortings[$questionId] = (int) ($question->sorting ?? 0);
        }

        foreach ($questions as $question) {
            $questionId = (int) ($question->id ?? 0);

            if ($questionId <= 0) {
                continue;
            }

            if ('yes_no_maybe' !== (string) ($question->type ?? '')) {
                continue;
            }

            foreach (['Ja' => (int) ($question->jumpOnYes ?? 0), 'Nein' => (int) ($question->jumpOnNo ?? 0)] as $answerValue => $targetQuestionId) {
                if ($targetQuestionId <= 0 || !isset($questionLabels[$targetQuestionId])) {
                    continue;
                }

                $rules[] = [
                    'id' => 'question-'.$questionId.'-'.$targetQuestionId.'-'.$answerValue,
                    'answerValue' => $answerValue,
                    'sourceQuestion' => $questionId,
                    'targetQuestion' => $targetQuestionId,
                    'sourceQuestionLabel' => (string) ($question->question ?? ''),
                    'targetQuestionLabel' => $questionLabels[$targetQuestionId] ?? '',
                    'sourceSorting' => $questionSortings[$questionId] ?? 0,
                ];
            }
        }

        foreach ($conditionOverview as $condition) {
            $sourceQuestionId = (int) ($condition['sourceQuestion'] ?? 0);

            $rules[] = [
                'id' => $condition['id'] ?? 0,
                'answerValue' => (string) ($condition['answerValue'] ?? ''),
                'sourceQuestion' => $sourceQuestionId,
                'targetQuestion' => (int) ($condition['targetQuestion'] ?? 0),
                'sourceQuestionLabel' => (string) ($condition['sourceQuestionLabel'] ?? ''),
                'targetQuestionLabel' => (string) ($condition['targetQuestionLabel'] ?? ''),
                'sourceSorting' => $questionSortings[$sourceQuestionId] ?? 0,
            ];
        }

        usort($rules, static function (array $left, array $right): int {
            $sortingComparison = ((int) ($left['sourceSorting'] ?? 0)) <=> ((int) ($right['sourceSorting'] ?? 0));

            if (0 !== $sortingComparison) {
                return $sortingComparison;
            }

            return ((int) ($left['targetQuestion'] ?? 0)) <=> ((int) ($right['targetQuestion'] ?? 0));
        });

        return $rules;
    }

    private function resolveListUrl(ModuleModel $model): string
    {
        $page = $this->resolvePage((int) ($model->surveyListPage ?? 0)) ?? $this->getPageModel();

        return $page instanceof PageModel ? $this->generateContentUrl($page) : '/';
    }

    private function resolveReaderUrl(ModuleModel $model, string $publicAlias): ?string
    {
        $page = $this->resolvePage((int) $this->getContaoAdapter(Config::class)->get('surveyReaderPage'));

        if (!$page instanceof PageModel) {
            return null;
        }

        return $this->generateContentUrl($page, ['auto_item' => $publicAlias]);
    }

    private function buildEditUrl(ModuleModel $model, Request $request, int $surveyId): string
    {
        $parameters = ['survey' => $surveyId];

        if ($request->query->getBoolean('debugAccess') && $this->isDebugAccessAllowed($request)) {
            $parameters['debugAccess'] = '1';
        }

        $debugMemberId = (int) $request->query->get('debugMember', 0);

        if ($debugMemberId > 0) {
            $parameters['debugMember'] = (string) $debugMemberId;
        }

        $basePath = $request->getBaseUrl().$request->getPathInfo();

        if ('' !== $basePath) {
            $queryString = http_build_query($parameters);
            $url = $basePath.('' !== $queryString ? '?'.$queryString : '');
        } else {
            $page = $this->getPageModel();
            $url = $page instanceof PageModel ? $this->generateContentUrl($page, $parameters) : $this->resolveListUrl($model);
        }

        return $url;
    }

    private function describeFormErrors(FormInterface $form): string
    {
        $messages = [];

        foreach ($form->getErrors(true, true) as $error) {
            $origin = $error->getOrigin();
            $name = $origin instanceof FormInterface ? $origin->getName() : 'form';
            $messages[] = sprintf('%s: %s', $name, $error->getMessage());
        }

        return [] !== $messages ? implode(' | ', array_unique($messages)) : 'Unbekannter Formularfehler.';
    }

    private function resolvePage(int $pageId): ?PageModel
    {
        if ($pageId <= 0) {
            return null;
        }

        $page = $this->getContaoAdapter(PageModel::class)->findById($pageId);

        return $page instanceof PageModel ? $page : null;
    }
}