<?php

namespace DaftPlug\Rankify\Admin;

use DaftPlug\Rankify\Helpers\Utils;

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

class Notices
{
  const INSTALL_TIME_OPTION = 'rankify_install_time';
  const REVIEW_DISMISS_OPTION = 'rankify_review_notice_dismissed';
  const UPGRADE_DISMISS_OPTION = 'rankify_upgrade_notice_dismissed';
  const STACK_DISMISS_OPTION = 'rankify_stack_notice_dismissed';

  const REVIEW_DELAY = 7 * DAY_IN_SECONDS;
  const REVIEW_DISMISS_PERIOD = 3 * MONTH_IN_SECONDS;

  const UPGRADE_DELAY = DAY_IN_SECONDS;
  const UPGRADE_DISMISS_PERIOD = MONTH_IN_SECONDS;

  const STACK_DELAY = 3 * DAY_IN_SECONDS;
  const STACK_DISMISS_PERIOD = 7 * DAY_IN_SECONDS;

  const REVIEW_URL = 'https://wordpress.org/support/plugin/crownify/reviews/';

  public function __construct()
  {
    add_action('admin_init', [$this, 'recordInstallTime']);
    add_action('admin_notices', [$this, 'renderNotices']);
    add_action('wp_ajax_rankify_dismiss_notice', [$this, 'handleDismiss']);
    add_action('wp_ajax_rankify_install_stack_plugin', [$this, 'handleStackInstall']);
  }

  /**
   * The DaftPlug plugin stack promoted by the cross-sell notice.
   * Keyed by the WordPress.org slug, which is also the install source.
   */
  private function getStackPlugins()
  {
    return [
      'lightify' => [
        'name' => __('Lightify', 'crownify'),
        'tagline' => __('Caching, asset & media optimization and Core Web Vitals monitoring.', 'crownify'),
        'constant' => 'LIGHTIFY_VERSION',
      ],
      'generatify' => [
        'name' => __('Generatify', 'crownify'),
        'tagline' => __('AI suite with chatbot, content generation, agents and automations.', 'crownify'),
        'constant' => 'GENERATIFY_VERSION',
      ],
      'progressify' => [
        'name' => __('Progressify', 'crownify'),
        'tagline' => __('PWA features: install prompts, offline access and push notifications.', 'crownify'),
        'constant' => 'PROGRESSIFY_VERSION',
      ],
      'snapshotify' => [
        'name' => __('Snapshotify', 'crownify'),
        'tagline' => __('Backup, restore and migration with scheduled snapshots and cloud storage.', 'crownify'),
        'constant' => 'SNAPSHOTIFY_VERSION',
      ],
    ];
  }

  public function recordInstallTime()
  {
    if (!get_option(self::INSTALL_TIME_OPTION)) {
      update_option(self::INSTALL_TIME_OPTION, time());
    }
  }

  public function renderNotices()
  {
    if (!current_user_can('manage_options')) {
      return;
    }

    if (Utils::hasActivePro()) {
      return;
    }

    $showReview = $this->shouldShow(self::REVIEW_DISMISS_OPTION, self::REVIEW_DELAY, self::REVIEW_DISMISS_PERIOD);
    $showUpgrade = $this->shouldShow(self::UPGRADE_DISMISS_OPTION, self::UPGRADE_DELAY, self::UPGRADE_DISMISS_PERIOD);

    $stackPlugins = [];
    $showStack = false;
    if ($this->canInstallPlugins() && $this->shouldShow(self::STACK_DISMISS_OPTION, self::STACK_DELAY, self::STACK_DISMISS_PERIOD)) {
      $stackPlugins = $this->getStackPluginsWithStatus();
      foreach ($stackPlugins as $plugin) {
        if ($plugin['state'] !== 'active') {
          $showStack = true;
          break;
        }
      }
    }

    if (!$showReview && !$showUpgrade && !$showStack) {
      return;
    }

    $this->renderStyles();
    $this->renderDismissScript();

    if ($showReview) {
      $this->renderReviewNotice();
    }

    if ($showUpgrade) {
      $this->renderUpgradeNotice();
    }

    if ($showStack) {
      $this->renderStackNotice($stackPlugins);
    }
  }

  private function canInstallPlugins()
  {
    if (Utils::hasActivePro()) {
      return false;
    }

    return current_user_can('install_plugins') && current_user_can('activate_plugins');
  }

  private function getStackPluginsWithStatus()
  {
    $plugins = $this->getStackPlugins();

    foreach ($plugins as $slug => $plugin) {
      $status = $this->getPluginStatus($slug, $plugin['constant']);
      $plugins[$slug]['state'] = $status['state'];
      $plugins[$slug]['file'] = $status['file'];
    }

    return $plugins;
  }

  /**
   * Detect whether a stack plugin is active, installed but inactive, or missing.
   * Matches both the free folder and the Freemius premium folder (slug-pro / slug-premium).
   */
  private function getPluginStatus($slug, $constant)
  {
    if (defined($constant)) {
      return ['state' => 'active', 'file' => ''];
    }

    if (!function_exists('get_plugins')) {
      require_once ABSPATH . 'wp-admin/includes/plugin.php';
    }

    $folders = [$slug, "{$slug}-pro", "{$slug}-premium"];

    foreach (get_plugins() as $file => $data) {
      if (!in_array(strtolower(dirname($file)), $folders, true)) {
        continue;
      }

      return [
        'state' => is_plugin_active($file) ? 'active' : 'inactive',
        'file' => $file,
      ];
    }

    return ['state' => 'missing', 'file' => ''];
  }

  private function shouldShow($dismissOption, $delay, $dismissPeriod)
  {
    $installedAt = (int) get_option(self::INSTALL_TIME_OPTION, 0);
    if (!$installedAt || time() - $installedAt < $delay) {
      return false;
    }

    $dismissedAt = (int) get_option($dismissOption, 0);
    if ($dismissedAt && time() - $dismissedAt < $dismissPeriod) {
      return false;
    }

    return true;
  }

  private function renderReviewNotice()
  {
    $nonce = wp_create_nonce('rankify_dismiss_notice');
    $logoUrl = plugins_url('assets/media/icons/icon-256x256.png', RANKIFY_FILE);
    ?>
<div class="notice notice-info is-dismissible rankify-notice" data-rankify-notice="review" data-nonce="<?php echo esc_attr($nonce); ?>">
  <div class="rankify-notice-inner">
    <img class="rankify-notice-logo" src="<?php echo esc_url($logoUrl); ?>" alt="Crownify" />
    <div class="rankify-notice-body">
      <h3 class="rankify-notice-title"><?php esc_html_e('Enjoying Crownify?', 'crownify'); ?></h3>
      <p><?php esc_html_e('If Crownify has been helpful, please take a moment to leave a 5-star review on WordPress.org. It takes less than a minute and helps a lot!', 'crownify'); ?></p>
      <p class="rankify-notice-actions">
        <a href="<?php echo esc_url(self::REVIEW_URL); ?>" target="_blank" rel="noopener" class="button button-primary rankify-notice-action"><?php esc_html_e('Leave a 5-star review ⭐', 'crownify'); ?></a>
        <button type="button" class="button button-secondary rankify-notice-dismiss"><?php esc_html_e('Maybe later', 'crownify'); ?></button>
      </p>
    </div>
  </div>
</div>
<?php
  }

  private function renderUpgradeNotice()
  {
    $nonce = wp_create_nonce('rankify_dismiss_notice');
    $logoUrl = plugins_url('assets/media/icons/icon-256x256.png', RANKIFY_FILE);
    ?>
<div class="notice notice-info is-dismissible rankify-notice" data-rankify-notice="upgrade" data-nonce="<?php echo esc_attr($nonce); ?>">
  <div class="rankify-notice-inner">
    <img class="rankify-notice-logo" src="<?php echo esc_url($logoUrl); ?>" alt="Crownify" />
    <div class="rankify-notice-body">
      <h3 class="rankify-notice-title"><?php esc_html_e('Unlock the full power of Crownify', 'crownify'); ?></h3>
      <p><?php esc_html_e('Enable Crownify Pro to unlock all advanced features and priority support.', 'crownify'); ?></p>
      <p class="rankify-notice-actions">
        <a href="<?php echo esc_url(Utils::getUpgradeUrl()); ?>" class="button button-primary rankify-notice-upgrade"><?php echo esc_html(Utils::getUpgradeLabel()); ?></a>
        <button type="button" class="button button-secondary rankify-notice-dismiss"><?php esc_html_e('Dismiss', 'crownify'); ?></button>
      </p>
    </div>
  </div>
</div>
<?php
  }

  private function renderStackNotice($plugins)
  {
    $nonce = wp_create_nonce('rankify_dismiss_notice');
    $installNonce = wp_create_nonce('rankify_install_stack');
    $logoUrl = plugins_url('assets/media/icons/icon-256x256.png', RANKIFY_FILE);

    $labels = [
      'missing' => __('Not installed', 'crownify'),
      'inactive' => __('Installed, inactive', 'crownify'),
      'active' => __('Active', 'crownify'),
    ];
    ?>
<div class="notice notice-info is-dismissible rankify-notice" data-rankify-notice="stack" data-nonce="<?php echo esc_attr($nonce); ?>" data-install-nonce="<?php echo esc_attr($installNonce); ?>">
  <div class="rankify-notice-inner">
    <img class="rankify-notice-logo" src="<?php echo esc_url($logoUrl); ?>" alt="Crownify" />
    <div class="rankify-notice-body">
      <h3 class="rankify-notice-title"><?php esc_html_e('Complete your DaftPlug stack', 'crownify'); ?></h3>
      <p><?php esc_html_e('Crownify works even better next to our other free plugins. Install and activate the missing ones in a single click.', 'crownify'); ?></p>
      <ul class="rankify-stack-list">
        <?php foreach ($plugins as $slug => $plugin): ?>
        <li class="rankify-stack-item" data-slug="<?php echo esc_attr($slug); ?>" data-state="<?php echo esc_attr($plugin['state']); ?>">
          <span class="rankify-stack-info">
            <strong><?php echo esc_html($plugin['name']); ?></strong>
            <span class="rankify-stack-tagline"><?php echo esc_html($plugin['tagline']); ?></span>
          </span>
          <span class="rankify-stack-badge <?php echo $plugin['state'] === 'active' ? 'is-done' : ''; ?>"><?php echo esc_html($labels[$plugin['state']]); ?></span>
        </li>
        <?php endforeach; ?>
      </ul>
      <p class="rankify-notice-actions">
        <button type="button" class="button button-primary rankify-stack-install"><?php esc_html_e('Install & activate for free', 'crownify'); ?></button>
        <button type="button" class="button button-secondary rankify-notice-dismiss"><?php esc_html_e('Not now', 'crownify'); ?></button>
      </p>
      <p class="rankify-stack-status" role="status" aria-live="polite"></p>
    </div>
  </div>
</div>
<?php $this->renderStackScript();
  }

  private function renderStackScript()
  {
    $strings = [
      'working' => __('Installing…', 'crownify'),
      /* translators: 1: plugin name, 2: current item number, 3: total number of items. */
      'progress' => __('Installing %1$s (%2$d of %3$d)…', 'crownify'),
      'done' => __('Active', 'crownify'),
      'failed' => __('Failed', 'crownify'),
      'allDone' => __('All done! Your DaftPlug stack is ready. Reloading…', 'crownify'),
      'someFailed' => __('Some plugins could not be installed. You can install them manually from Plugins → Add New.', 'crownify'),
      'genericError' => __('Something went wrong. Please try again.', 'crownify'),
      'buttonWorking' => __('Installing…', 'crownify'),
      'buttonRetry' => __('Retry', 'crownify'),
    ]; ?>
<script>
(function() {
  var notice = document.querySelector('.rankify-notice[data-rankify-notice="stack"]');
  if (!notice) return;

  var button = notice.querySelector('.rankify-stack-install');
  var statusEl = notice.querySelector('.rankify-stack-status');
  var ajaxUrl = <?php echo wp_json_encode(admin_url('admin-ajax.php')); ?>;
  var nonce = notice.getAttribute('data-install-nonce');
  var i18n = <?php echo wp_json_encode($strings); ?>;

  function format(template, values) {
    return template.replace(/%(\d)\$[sd]/g, function(match, index) {
      return values[index - 1];
    });
  }

  function installOne(slug) {
    var body = new URLSearchParams();
    body.append('action', 'rankify_install_stack_plugin');
    body.append('slug', slug);
    body.append('_wpnonce', nonce);

    return fetch(ajaxUrl, {
      method: 'POST',
      credentials: 'same-origin',
      body: body,
    })
      .then(function(response) {
        return response.json();
      })
      .then(function(json) {
        if (json && json.success) {
          return { ok: true };
        }
        return { ok: false, message: (json && json.data && json.data.message) || i18n.genericError };
      })
      .catch(function() {
        return { ok: false, message: i18n.genericError };
      });
  }

  button.addEventListener('click', function() {
    var items = Array.prototype.slice.call(notice.querySelectorAll('.rankify-stack-item')).filter(function(item) {
      return item.getAttribute('data-state') !== 'active';
    });

    if (!items.length) return;

    button.disabled = true;
    button.textContent = i18n.buttonWorking;
    statusEl.textContent = '';

    var failed = 0;

    var chain = items.reduce(function(promise, item, index) {
      return promise.then(function() {
        var slug = item.getAttribute('data-slug');
        var name = item.querySelector('strong').textContent;
        var badge = item.querySelector('.rankify-stack-badge');

        badge.className = 'rankify-stack-badge is-working';
        badge.textContent = i18n.working;
        statusEl.textContent = format(i18n.progress, [name, index + 1, items.length]);

        return installOne(slug).then(function(result) {
          if (result.ok) {
            item.setAttribute('data-state', 'active');
            badge.className = 'rankify-stack-badge is-done';
            badge.textContent = i18n.done;
          } else {
            failed++;
            badge.className = 'rankify-stack-badge is-error';
            badge.textContent = i18n.failed;
            badge.title = result.message;
          }
        });
      });
    }, Promise.resolve());

    chain.then(function() {
      if (failed) {
        statusEl.textContent = i18n.someFailed;
        button.disabled = false;
        button.textContent = i18n.buttonRetry;
        return;
      }

      statusEl.textContent = i18n.allDone;
      window.location.reload();
    });
  });
})();
</script>
<?php
  }

  private function renderStyles()
  {
    static $printed = false;
    if ($printed) {
      return;
    }
    $printed = true;?>
<style>
.rankify-notice {
  padding: 16px 38px 16px 16px;
}

.rankify-notice-inner {
  display: flex;
  align-items: flex-start;
  gap: 16px;
}

.rankify-notice-logo {
  width: 56px;
  height: 56px;
  flex: 0 0 56px;
  border-radius: 8px;
  object-fit: contain;
}

.rankify-notice-body {
  flex: 1;
  min-width: 0;
}

.rankify-notice-title {
  margin: 0 0 6px;
  font-size: 18px;
  line-height: 1.3;
  font-weight: 600;
}

.rankify-notice-body p {
  margin: 0 0 10px;
  font-size: 14px;
}

.rankify-notice-actions {
  display: flex;
  flex-wrap: wrap;
  gap: 8px;
  margin: 0 !important;
}

.rankify-notice .rankify-notice-upgrade.button-primary {
  background: linear-gradient(to right, #7c3aed, #4f46e5);
  border-color: #6d28d9;
  color: #fff;
}

.rankify-notice .rankify-notice-upgrade.button-primary:hover,
.rankify-notice .rankify-notice-upgrade.button-primary:focus {
  background: linear-gradient(to right, #6d28d9, #4338ca);
  border-color: #5b21b6;
  color: #fff;
}

.rankify-stack-list {
  margin: 0 0 12px;
  padding: 0;
  list-style: none;
  display: grid;
  gap: 6px;
  max-width: 720px;
}

.rankify-stack-item {
  display: flex;
  align-items: center;
  justify-content: space-between;
  gap: 12px;
  margin: 0;
  padding: 8px 12px;
  border: 1px solid #dcdcde;
  border-radius: 6px;
  background: #fff;
}

.rankify-stack-info {
  display: flex;
  flex-direction: column;
  min-width: 0;
}

.rankify-stack-tagline {
  color: #646970;
  font-size: 12px;
}

.rankify-stack-badge {
  flex: 0 0 auto;
  font-size: 12px;
  font-weight: 600;
  color: #646970;
  white-space: nowrap;
}

.rankify-stack-badge.is-done {
  color: #007017;
}

.rankify-stack-badge.is-working {
  color: #2271b1;
}

.rankify-stack-badge.is-error {
  color: #b32d2e;
  cursor: help;
}

.rankify-stack-status:empty {
  display: none;
}

.rankify-stack-status {
  margin: 10px 0 0 !important;
  font-size: 13px;
  color: #646970;
}
</style>
<?php
  }

  private function renderDismissScript()
  {
    static $printed = false;
    if ($printed) {
      return;
    }
    $printed = true;
    ?>
<script>
(function() {
  document.addEventListener('click', function(e) {
    const notice = e.target.closest('.rankify-notice');
    if (!notice) return;

    const isDismiss = e.target.matches('.notice-dismiss, .rankify-notice-dismiss');
    const isAction = e.target.closest('.rankify-notice-action');
    if (!isDismiss && !isAction) return;

    const key = notice.getAttribute('data-rankify-notice');
    const nonce = notice.getAttribute('data-nonce');
    if (!key || !nonce) return;

    const body = new URLSearchParams();
    body.append('action', 'rankify_dismiss_notice');
    body.append('notice', key);
    body.append('_wpnonce', nonce);

    fetch('<?php echo esc_url(admin_url('admin-ajax.php')); ?>', {
      method: 'POST',
      credentials: 'same-origin',
      body: body,
    });

    if (e.target.matches('.rankify-notice-dismiss')) {
      notice.style.display = 'none';
    }
  });
})();
</script>
<?php
  }

  public function handleDismiss()
  {
    check_ajax_referer('rankify_dismiss_notice');

    if (!current_user_can('manage_options')) {
      wp_send_json_error();
    }

    $notice = isset($_POST['notice']) ? sanitize_key(wp_unslash($_POST['notice'])) : '';
    $map = [
      'review' => self::REVIEW_DISMISS_OPTION,
      'upgrade' => self::UPGRADE_DISMISS_OPTION,
      'stack' => self::STACK_DISMISS_OPTION,
    ];

    if (!isset($map[$notice])) {
      wp_send_json_error();
    }

    update_option($map[$notice], time());
    wp_send_json_success();
  }

  /**
   * Installs (if needed) and activates a single plugin of the DaftPlug stack.
   * The JavaScript calls this once per missing plugin so each request stays short.
   */
  public function handleStackInstall()
  {
    if (Utils::hasActivePro()) {
      wp_send_json_error(['message' => __('Cross-promotion is only available in the free version.', 'crownify')]);
    }

    check_ajax_referer('rankify_install_stack');

    if (!$this->canInstallPlugins()) {
      wp_send_json_error(['message' => __('You do not have permission to install plugins on this site.', 'crownify')]);
    }

    $slug = isset($_POST['slug']) ? sanitize_key(wp_unslash($_POST['slug'])) : '';
    $plugins = $this->getStackPlugins();

    if (!isset($plugins[$slug])) {
      wp_send_json_error(['message' => __('Unknown plugin.', 'crownify')]);
    }

    require_once ABSPATH . 'wp-admin/includes/plugin.php';
    require_once ABSPATH . 'wp-admin/includes/file.php';
    require_once ABSPATH . 'wp-admin/includes/misc.php';
    require_once ABSPATH . 'wp-admin/includes/plugin-install.php';
    require_once ABSPATH . 'wp-admin/includes/class-wp-upgrader.php';

    $status = $this->getPluginStatus($slug, $plugins[$slug]['constant']);

    if ($status['state'] === 'active') {
      wp_send_json_success(['state' => 'active']);
    }

    $pluginFile = $status['file'];

    if ($status['state'] === 'missing') {
      $api = plugins_api('plugin_information', [
        'slug' => $slug,
        'fields' => ['sections' => false],
      ]);

      if (is_wp_error($api)) {
        wp_send_json_error(['message' => $api->get_error_message()]);
      }

      $skin = new \WP_Ajax_Upgrader_Skin();
      $upgrader = new \Plugin_Upgrader($skin);
      $result = $upgrader->install($api->download_link);

      if (is_wp_error($result)) {
        wp_send_json_error(['message' => $result->get_error_message()]);
      }

      if (is_wp_error($skin->result)) {
        wp_send_json_error(['message' => $skin->result->get_error_message()]);
      }

      if ($skin->get_errors()->has_errors()) {
        wp_send_json_error(['message' => $skin->get_error_messages()]);
      }

      if ($result === null) {
        // Usually means WordPress could not write to the filesystem without FTP credentials.
        wp_send_json_error(['message' => __('WordPress could not access the filesystem to install the plugin. Please install it manually from Plugins → Add New.', 'crownify')]);
      }

      $pluginFile = $upgrader->plugin_info();
    }

    if (empty($pluginFile)) {
      wp_send_json_error(['message' => __('The plugin was installed but its main file could not be found.', 'crownify')]);
    }

    $activated = activate_plugin($pluginFile);

    if (is_wp_error($activated)) {
      wp_send_json_error(['message' => $activated->get_error_message()]);
    }

    wp_send_json_success(['state' => 'active']);
  }
}