<?php // phpcs:ignore SlevomatCodingStandard.TypeHints.DeclareStrictTypes.DeclareStrictTypesMissing

namespace MailPoet\Subscribers;

if (!defined('ABSPATH')) exit;


use MailPoet\Captcha\BehavioralSignals;
use MailPoet\Captcha\CaptchaConstants;
use MailPoet\Captcha\CaptchaSession;
use MailPoet\Captcha\Validator\CaptchaValidator;
use MailPoet\Captcha\Validator\RecaptchaValidator;
use MailPoet\Captcha\Validator\TurnstileValidator;
use MailPoet\Captcha\Validator\ValidationError;
use MailPoet\Entities\FormEntity;
use MailPoet\Entities\SubscriberEntity;
use MailPoet\Entities\SubscriberTagEntity;
use MailPoet\Form\FormsRepository;
use MailPoet\Form\Util\FieldNameObfuscator;
use MailPoet\NotFoundException;
use MailPoet\Segments\SubscribersFinder;
use MailPoet\Settings\SettingsController;
use MailPoet\Statistics\StatisticsFormsRepository;
use MailPoet\Subscription\Throttling as SubscriptionThrottling;
use MailPoet\Tags\TagRepository;
use MailPoet\UnexpectedValueException;
use MailPoet\WP\Functions as WPFunctions;

class SubscriberSubscribeController {
  /** @var FormsRepository */
  private $formsRepository;

  /** @var CaptchaSession */
  private $captchaSession;

  /** @var FieldNameObfuscator */
  private $fieldNameObfuscator;

  /** @var SettingsController */
  private $settings;

  /** @var RequiredCustomFieldValidator */
  private $requiredCustomFieldValidator;

  /** @var SubscriberActions */
  private $subscriberActions;

  /** @var WPFunctions */
  private $wp;

  /** @var SubscriptionThrottling */
  private $throttling;

  /** @var StatisticsFormsRepository */
  private $statisticsFormsRepository;

  /** @var SubscribersFinder */
  private $subscribersFinder;

  /** @var TagRepository */
  private $tagRepository;

  /** @var SubscriberTagRepository */
  private $subscriberTagRepository;
  /** @var CaptchaValidator  */
  private $builtInCaptchaValidator;

  /** @var RecaptchaValidator  */
  private $recaptchaValidator;

  /** @var TurnstileValidator  */
  private $turnstileValidator;

  /** @var BehavioralSignals */
  private $behavioralSignals;

  public function __construct(
    CaptchaSession $captchaSession,
    SubscriberActions $subscriberActions,
    SubscribersFinder $subscribersFinder,
    SubscriptionThrottling $throttling,
    FieldNameObfuscator $fieldNameObfuscator,
    RequiredCustomFieldValidator $requiredCustomFieldValidator,
    SettingsController $settings,
    FormsRepository $formsRepository,
    StatisticsFormsRepository $statisticsFormsRepository,
    TagRepository $tagRepository,
    SubscriberTagRepository $subscriberTagRepository,
    WPFunctions $wp,
    CaptchaValidator $builtInCaptchaValidator,
    RecaptchaValidator $recaptchaValidator,
    TurnstileValidator $turnstileValidator,
    BehavioralSignals $behavioralSignals
  ) {
    $this->formsRepository = $formsRepository;
    $this->captchaSession = $captchaSession;
    $this->requiredCustomFieldValidator = $requiredCustomFieldValidator;
    $this->fieldNameObfuscator = $fieldNameObfuscator;
    $this->settings = $settings;
    $this->subscriberActions = $subscriberActions;
    $this->subscribersFinder = $subscribersFinder;
    $this->wp = $wp;
    $this->throttling = $throttling;
    $this->statisticsFormsRepository = $statisticsFormsRepository;
    $this->tagRepository = $tagRepository;
    $this->subscriberTagRepository = $subscriberTagRepository;
    $this->builtInCaptchaValidator = $builtInCaptchaValidator;
    $this->recaptchaValidator = $recaptchaValidator;
    $this->turnstileValidator = $turnstileValidator;
    $this->behavioralSignals = $behavioralSignals;
  }

  public function subscribe(array $data): array {
    $form = $this->getForm($data);

    if (!empty($data['email'])) {
      throw new UnexpectedValueException(__('Please leave the first field empty.', 'mailpoet'));
    }

    $captchaSettings = $this->settings->get('captcha');
    $data = $this->initCaptcha($captchaSettings, $form, $data);
    $data = $this->deobfuscateFormPayload($data);

    try {
      $this->requiredCustomFieldValidator->validate($data, $form);
    } catch (\Exception $e) {
      throw new UnexpectedValueException($e->getMessage());
    }

    $segmentIds = $this->getSegmentIds($form, $data['segments'] ?? []);

    // Keep `segments` in $data until after CAPTCHA validation so that, if the
    // behavioral-baseline path stashes the submission for a deferred challenge,
    // the stash still carries the selected segments for the resubmit.
    $meta = $this->validateCaptcha($captchaSettings, $data, $form);
    if (isset($meta['error'])) {
      return $meta;
    }
    unset($data['segments']);

    $submittedTimeZone = SubscriberEntity::sanitizeTimeZone($data[SubscriberEntity::TIME_ZONE_FIELD_NAME] ?? null);

    // only accept fields defined in the form
    $formFieldIds = array_filter(array_map(function (array $formField): ?string {
      if (!isset($formField['id'])) {
        return null;
      }
      return is_numeric($formField['id']) ? "cf_{$formField['id']}" : $formField['id'];
    }, $form->getBlocksByTypes(FormEntity::FORM_FIELD_TYPES)));
    $data = array_intersect_key($data, array_flip($formFieldIds));
    if ($submittedTimeZone !== null) {
      $data[SubscriberEntity::TIME_ZONE_FIELD_NAME] = $submittedTimeZone;
    }

    // make sure we don't allow too many subscriptions with the same ip address
    $timeout = $this->throttling->throttle();

    if ($timeout > 0) {
      $timeToWait = $this->throttling->secondsToTimeString($timeout);
      $meta['refresh_captcha'] = true;
      // translators: %s is the amount of time the user has to wait.
      $meta['error'] = sprintf(__('You need to wait %s before subscribing again.', 'mailpoet'), $timeToWait);
      return $meta;
    }

    /**
     * Fires before a subscription gets created.
     * To interrupt the subscription process, you can throw an MailPoet\Exception.
     * The error message will then be displayed to the user.
     *
     * @param array      $data       The subscription data.
     * @param array      $segmentIds The segment IDs the user gets subscribed to.
     * @param FormEntity $form       The form the user used to subscribe.
     */
    $this->wp->doAction('mailpoet_subscription_before_subscribe', $data, $segmentIds, $form);

    [$subscriber, $subscriptionMeta] = $this->subscriberActions->subscribe($data, $segmentIds);

    if (
      isset($data['captcha_session_id']) && (
      ($captchaSettings['type'] ?? null) === CaptchaConstants::TYPE_BUILTIN
      || CaptchaConstants::isDisabled($captchaSettings['type'] ?? null)
      )
    ) {
      // Captcha has been verified, invalidate the session vars
      $this->captchaSession->reset($data['captcha_session_id']);
    }

    // record form statistics
    $this->statisticsFormsRepository->record($form, $subscriber);

    // add tags to subscriber if they are filled
    $formSettings = $form->getSettings();
    $this->addTagsToSubscriber($formSettings['tags'] ?? [], $subscriber);

    // Confirmation email failed. We want to show the error message
    if ($subscriptionMeta['confirmationEmailResult'] instanceof \Exception) {
      $meta['error'] = $subscriptionMeta['confirmationEmailResult']->getMessage();
      return $meta;
    }
    if (!empty($subscriptionMeta['error'])) {
      $meta['error'] = $subscriptionMeta['error'];
      return $meta;
    }

    if (!empty($formSettings['on_success'])) {
      if ($formSettings['on_success'] === 'page') {
        // redirect to a page on a success, pass the page url in the meta
        $meta['redirect_url'] = $this->wp->getPermalink($formSettings['success_page']);
      } else if ($formSettings['on_success'] === 'url') {
        $meta['redirect_url'] = $formSettings['success_url'];
      }
    }

    return $meta;
  }

  /**
   * Checks if the subscriber is subscribed to any segments in the form
   *
   * @param  FormEntity       $form       The form entity
   * @param  SubscriberEntity $subscriber The subscriber entity
   * @return bool True if the subscriber is subscribed to any of the segments in the form
   */
  public function isSubscribedToAnyFormSegments(FormEntity $form, SubscriberEntity $subscriber): bool {
    $formSegments = array_merge($form->getSegmentBlocksSegmentIds(), $form->getSettingsSegmentIds());

    $subscribersFound = $this->subscribersFinder->findSubscribersInSegments([$subscriber->getId()], $formSegments);
    if (!empty($subscribersFound)) return true;

    return false;
  }

  private function deobfuscateFormPayload($data): array {
    return $this->fieldNameObfuscator->deobfuscateFormPayload($data);
  }

  private function initCaptcha(?array $captchaSettings, FormEntity $form, array $data): array {
    $type = $captchaSettings['type'] ?? null;

    if ($type === CaptchaConstants::TYPE_BUILTIN) {
      // When serving the built-in CAPTCHA for the first time, generate a new session ID.
      if (!isset($data['captcha_session_id'])) {
        $data['captcha_session_id'] = $this->captchaSession->generateSessionId();
      }
      $sessionId = $data['captcha_session_id'];

      if (!isset($data['captcha'])) {
        // Save form data to session
        $this->captchaSession->setFormData($sessionId, array_merge($data, ['form_id' => $form->getId()]));
      } elseif ($this->captchaSession->getFormData($sessionId)) {
        // Restore form data from session, but keep the current request's captcha
        // and behavioral signals so the resubmit reflects accumulated interaction
        // rather than the (possibly bot-like) snapshot from the first submit.
        $preserve = ['captcha' => $data['captcha']];
        if (isset($data[BehavioralSignals::FIELD_NAME])) {
          $preserve[BehavioralSignals::FIELD_NAME] = $data[BehavioralSignals::FIELD_NAME];
        }
        $data = array_merge($this->captchaSession->getFormData($sessionId), $preserve);
      }
      return $data;
    }

    // Disabled with behavioral baseline: restore stashed form data on resubmit
    // (after a previous behavioral escalation). The first submit stashes inside
    // the escalation path; here we only handle the restore side.
    if (
      CaptchaConstants::isDisabled($type)
      && isset($data['captcha_session_id'], $data['captcha'])
    ) {
      $stashed = $this->captchaSession->getFormData($data['captcha_session_id']);
      if (is_array($stashed)) {
        // Keep the current request's behavioral signals over the stash so the
        // resubmit's signal check reflects accumulated interaction, not the
        // (possibly bot-like) snapshot that triggered the original challenge.
        $preserve = [
          'captcha' => $data['captcha'],
          'captcha_session_id' => $data['captcha_session_id'],
        ];
        if (isset($data[BehavioralSignals::FIELD_NAME])) {
          $preserve[BehavioralSignals::FIELD_NAME] = $data[BehavioralSignals::FIELD_NAME];
        }
        $data = array_merge($stashed, $preserve);
      }
    }

    return $data;
  }

  private function validateCaptcha($captchaSettings, $data, FormEntity $form): array {
    $type = $captchaSettings['type'] ?? null;
    try {
      if (CaptchaConstants::isDisabled($type)) {
        $this->enforceBehavioralBaseline($data, $form);
        return [];
      }
      if ($type === CaptchaConstants::TYPE_BUILTIN) {
        $this->builtInCaptchaValidator->validate($data);
        $this->requireHumanSignals($data, $form);
      }
      if (CaptchaConstants::isReCaptcha($type)) {
        $this->recaptchaValidator->validate($data);
      }
      if (CaptchaConstants::isTurnstile($type)) {
        $this->turnstileValidator->validate($data);
      }
    } catch (ValidationError $error) {
      return $error->getMeta();
    }
    return [];
  }

  /**
   * Baseline protection when no CAPTCHA is configured: behavioral signals must
   * look human, otherwise escalate to the built-in CAPTCHA inline challenge.
   * isRequired()'s IP-history heuristic is intentionally bypassed here — the
   * decision is made on per-submission signals, not on the IP's CAPTCHA history.
   * On resubmit (after a previous escalation), signals are re-checked so that
   * solving the CAPTCHA alone isn't enough to bypass the baseline.
   */
  private function enforceBehavioralBaseline(array $data, FormEntity $form): void {
    if (!empty($data['captcha_session_id'])) {
      $this->builtInCaptchaValidator->validateChallenge($data);
    }
    $this->requireHumanSignals($data, $form);
  }

  /**
   * Throws a fresh CAPTCHA challenge unless behavioral signals look human.
   * Admin/editor exempt. The suspect signals are dropped from the stash so the
   * resubmit is evaluated on the current request's freshest counters (via
   * initCaptcha's preserve step).
   */
  private function requireHumanSignals(array $data, FormEntity $form): void {
    if ($this->builtInCaptchaValidator->isUserExemptFromCaptcha()) {
      return;
    }
    if ($this->behavioralSignals->looksHuman($data)) {
      return;
    }
    $stash = array_merge($data, ['form_id' => $form->getId()]);
    unset($stash[BehavioralSignals::FIELD_NAME]);
    $challenge = $this->builtInCaptchaValidator->getInlineCaptchaChallenge($stash);
    throw new ValidationError(__('Please fill in the CAPTCHA.', 'mailpoet'), $challenge);
  }

  private function getSegmentIds(FormEntity $form, array $segmentIds): array {

    // If form contains segment selection blocks allow only segments ids configured in those blocks
    $segmentBlocksSegmentIds = $form->getSegmentBlocksSegmentIds();
    if (!empty($segmentBlocksSegmentIds)) {
      $segmentIds = array_intersect($segmentIds, $segmentBlocksSegmentIds);
    } else {
      $segmentIds = $form->getSettingsSegmentIds();
    }

    if (empty($segmentIds)) {
      throw new UnexpectedValueException(__('Please select a list.', 'mailpoet'));
    }

    return $segmentIds;
  }

  private function getForm(array $data): FormEntity {
    $formId = (isset($data['form_id']) ? (int)$data['form_id'] : false);
    $form = $this->formsRepository->findOneById($formId);

    if (!$form) {
      throw new NotFoundException(__('Please specify a valid form ID.', 'mailpoet'));
    }

    return $form;
  }

  /**
   * @param string[] $tagNames
   */
  private function addTagsToSubscriber(array $tagNames, SubscriberEntity $subscriber): void {
    foreach ($tagNames as $tagName) {
      $tag = $this->tagRepository->createOrUpdate(['name' => $tagName]);

      $subscriberTag = $subscriber->getSubscriberTag($tag);
      if (!$subscriberTag) {
        $subscriberTag = new SubscriberTagEntity($tag, $subscriber);
        $subscriber->getSubscriberTags()->add($subscriberTag);
        $this->subscriberTagRepository->persist($subscriberTag);
        $this->subscriberTagRepository->flush();
        $this->wp->doAction('mailpoet_subscriber_tag_added', $subscriberTag);
      }
    }
  }
}
