<?php


declare(strict_types=1);

namespace org\wplake\advanced_views\Dashboard;

use Exception;
use org\wplake\advanced_views\Cards\Cpt\CardsCpt;
use org\wplake\advanced_views\Cards\DataStorage\CardsDataStorage;
use org\wplake\advanced_views\Common\HooksInterface;
use org\wplake\advanced_views\CurrentScreen;
use org\wplake\advanced_views\Groups\CardData;
use org\wplake\advanced_views\Groups\ToolsData;
use org\wplake\advanced_views\Groups\ViewData;
use org\wplake\advanced_views\Plugin;
use org\wplake\advanced_views\Views\Cpt\ViewsCpt;
use org\wplake\advanced_views\Views\DataStorage\ViewsDataStorage;
use WP_Post;
use WP_Query;

defined('ABSPATH') || exit;

class Tools implements HooksInterface
{
    const SLUG = 'acf-views-tools';
    /**
     * @var array<string,mixed>
     */
    protected array $values;
    protected ToolsData $toolsData;
    protected CardsDataStorage $cardsDataStorage;
    protected ViewsDataStorage $viewsDataStorage;
    protected Plugin $plugin;
    protected ViewData $acfViewData;
    protected CardData $acfCardData;
    /**
     * @var array<string,array<string,mixed>>
     */
    protected array $exportData;
    protected bool $isImportSuccessfull;
    protected string $importResultMessage;

    public function __construct(
        ToolsData $toolsData,
        CardsDataStorage $cardsDataStorage,
        ViewsDataStorage $viewsDataStorage,
        Plugin $plugin,
        ViewData $acfViewData,
        CardData $acfCardData
    ) {
        $this->toolsData = $toolsData;
        $this->cardsDataStorage = $cardsDataStorage;
        $this->viewsDataStorage = $viewsDataStorage;
        $this->plugin = $plugin;
        $this->acfViewData = $acfViewData;
        $this->acfCardData = $acfCardData;
        $this->values = [];
        $this->exportData = [];
        $this->isImportSuccessfull = false;
        $this->importResultMessage = '';
    }

    /**
     * @param mixed $postId
     */
    protected function isMySource($postId): bool
    {
        $screen = get_current_screen();

        return null !== $screen &&
            'acf_views_page_acf-views-tools' === $screen->id &&
            'options' === $postId;
    }

    /**
     * @param string[] $slugs
     * @return WP_Post[]
     */
    protected function getPosts(string $postType, array $slugs): array
    {
        $queryArgs = [
            'post_type' => $postType,
            'post_status' => 'publish',
            'posts_per_page' => -1,
        ];

        if ([] !== $slugs) {
            $queryArgs['post_name__in'] = $slugs;
        }

        $query = new WP_Query($queryArgs);

        /**
         * @var WP_Post[]
         */
        return $query->get_posts();
    }

    protected function export(): void
    {
        $isViewsInExport = $this->toolsData->isExportAllViews ||
            [] !== $this->toolsData->exportViews;
        $isCardsInExport = $this->toolsData->isExportAllCards ||
            [] !== $this->toolsData->exportCards;

        $viewPosts = $isViewsInExport ?
            $this->getPosts(ViewsCpt::NAME, $this->toolsData->exportViews) :
            [];
        $cardPosts = $isCardsInExport ?
            $this->getPosts(CardsCpt::NAME, $this->toolsData->exportCards) :
            [];

        foreach ($viewPosts as $viewPost) {
            $acfViewData = $this->viewsDataStorage->get($viewPost->post_name);
            // we don't need to save defaults
            $this->exportData[$viewPost->post_name] = $acfViewData->getFieldValues('', true);
        }

        foreach ($cardPosts as $cardPost) {
            $acfCardData = $this->cardsDataStorage->get($cardPost->post_name);
            $cardUniqueId = $acfCardData->getUniqueId();
            // we don't need to save defaults
            $this->exportData[$cardUniqueId] = $acfCardData->getFieldValues('', true);
        }
    }

    /**
     * @param string[] $successViewIds
     * @param string[] $successCardIds
     * @param string[] $failViewUniqueIds
     * @param string[] $failCardUniqueIds
     * @return string
     */
    protected function getImportResultMessage(
        array $successViewIds,
        array $successCardIds,
        array $failViewUniqueIds,
        array $failCardUniqueIds
    ): string {
        $viewsInfo = [];
        $cardsInfo = [];
        $importResultMessage = '';

        foreach ($successViewIds as $successViewId) {
            $successViewId = (int)$successViewId;

            $viewsInfo[] = sprintf(
                '<a href="%s" target="_blank">%s</a>',
                get_edit_post_link($successViewId),
                get_the_title($successViewId)
            );
        }

        foreach ($successCardIds as $successCardId) {
            $successCardId = (int)$successCardId;

            $cardsInfo[] = sprintf(
                '<a href="%s" target="_blank">%s</a>',
                get_edit_post_link($successCardId),
                get_the_title($successCardId)
            );
        }


        if ([] === $failViewUniqueIds &&
            [] === $failCardUniqueIds) {
            $this->isImportSuccessfull = true;

            $importResultMessage .= sprintf(
                __('Successfully imported %d Views and %d Cards.', 'acf-views'),
                count($successViewIds),
                count($successCardIds)
            );
            $importResultMessage .= '<br>';
        } else {
            $importResultMessage .= sprintf(
                __('Something went wrong. Imported %d from %d Views and %d from %d Cards.', 'acf-views'),
                count($successViewIds),
                count($successViewIds) + count($failViewUniqueIds),
                count($successCardIds),
                count($successCardIds) + count($failCardUniqueIds)
            );
            $importResultMessage .= '<br>';
        }

        if ([] !== $viewsInfo) {
            $viewsLabel = __('Imported Views', 'acf-views');
            $importResultMessage .= sprintf(
                '%s: %s.',
                $viewsLabel,
                implode(', ', $viewsInfo)
            );
            $importResultMessage .= '<br>';
        }

        if ([] !== $cardsInfo) {
            $cardsLabel = __('Imported Cards', 'acf-views');
            $importResultMessage .= sprintf(
                '%s: %s.',
                $cardsLabel,
                implode(', ', $cardsInfo)
            );
            $importResultMessage .= '<br>';
        }

        if ([] !== $failViewUniqueIds) {
            $viewsLabel = __('Wrong Views', 'acf-views');
            $importResultMessage .= sprintf(
                '%s: %s.',
                $viewsLabel,
                implode(', ', $failViewUniqueIds)
            );
            $importResultMessage .= '<br>';
        }

        if ([] !== $failCardUniqueIds) {
            $cardsLabel = __('Wrong Cards', 'acf-views');
            $importResultMessage .= sprintf(
                '%s: %s.',
                $cardsLabel,
                implode(', ', $failCardUniqueIds)
            );
            $importResultMessage .= '<br>';
        }

        return $importResultMessage;
    }

    /**
     * @param array<string,mixed> $jsonData
     * @throws Exception
     */
    protected function importOrUpdateItems(array $jsonData): void
    {
        $successViewIds = [];
        $successCardIds = [];
        $failViewUniqueIds = [];
        $failCardUniqueIds = [];

        foreach ($jsonData as $uniqueId => $details) {
            if (!is_array($details)) {
                continue;
            }

            $postType = false !== strpos($uniqueId, ViewData::UNIQUE_ID_PREFIX) ?
                ViewsCpt::NAME :
                CardsCpt::NAME;
            $dataStorage = ViewsCpt::NAME === $postType ?
                $this->viewsDataStorage :
                $this->cardsDataStorage;
            $titleField = ViewsCpt::NAME === $postType ?
                ViewData::getAcfFieldName(ViewData::FIELD_TITLE) :
                CardData::getAcfFieldName(CardData::FIELD_TITLE);
            $title = $details[$titleField] ?? '';
            $title = is_string($title) ?
                $title :
                '';

            // get item, maybe it's already exists (then we'll override it)
            $cptData = $dataStorage->get($uniqueId);

            // insert if missing
            $cptData = false === $cptData->isLoaded() ?
                $dataStorage->createNew('publish', $title, null, $uniqueId) :
                $cptData;

            if (null === $cptData) {
                if (ViewsCpt::NAME === $postType) {
                    $failViewUniqueIds[] = $uniqueId;
                } else {
                    $failCardUniqueIds[] = $uniqueId;
                }

                continue;
            }

            // load all the old data. It'll also override the unique id if the instance is just made, that's right as id kept the same
            $cptData->load($cptData->getPostId(), '', $details);

            $dataStorage->save($cptData);

            // there is no sense to call the 'performSaveActions' method

            if (ViewsCpt::NAME === $postType) {
                $successViewIds[] = $cptData->getPostId();
            } else {
                $successCardIds[] = $cptData->getPostId();
            }
        }

        $resultMessage = [];

        $resultMessage[] = implode(',', $successViewIds);
        $resultMessage[] = implode(',', $successCardIds);
        $resultMessage[] = implode(',', $failViewUniqueIds);
        $resultMessage[] = implode(',', $failCardUniqueIds);

        $this->importResultMessage = implode(';', $resultMessage);
    }

    protected function import(): void
    {
        $pathToFile = (string)get_attached_file($this->toolsData->importFile);

        if ('' === $pathToFile ||
            !file_exists($pathToFile)) {
            $this->importResultMessage = __('Import file not found.', 'acf-views');
            return;
        }

        $fileContent = (string)file_get_contents($pathToFile);
        // remove the prefix, that was added to avoid WP Media library JSON detection
        $fileContent = str_replace('Advanced Views:', '', $fileContent);

        $jsonData = json_decode($fileContent, true);

        if (JSON_ERROR_NONE !== json_last_error()) {
            $this->importResultMessage = __('Import file is not a valid JSON.', 'acf-views');
            return;
        }

        $jsonData = is_array($jsonData) ?
            $jsonData :
            [];

        $this->importOrUpdateItems($jsonData);

        wp_delete_attachment($this->toolsData->importFile, true);

        $url = $this->plugin->getAdminUrl(self::SLUG) .
            sprintf(
                '&message=1&type=import&isSuccess=%s&resultMessage=%s',
                $this->isImportSuccessfull,
                $this->importResultMessage
            );
        wp_redirect($url);
        exit;
    }

    /**
     * @param mixed $postId
     */
    public function maybeEchoExportFile($postId): void
    {
        if (!$this->isMySource($postId) ||
            [] === $this->exportData) {
            return;
        }

        $ids = array_keys($this->exportData);
        $viewIds = array_filter($ids, function ($id) {
            return false !== strpos($id, ViewData::UNIQUE_ID_PREFIX);
        });
        $countOfViewIds = count($viewIds);
        $cardIds = array_filter($ids, function ($id) {
            return false !== strpos($id, CardData::UNIQUE_ID_PREFIX);
        });
        $countOfCardIds = count($cardIds);

        $redirectUrl = $this->plugin->getAdminUrl(self::SLUG) .
            sprintf('&message=1&type=export&_views=%s&_cards=%s', $countOfViewIds, $countOfCardIds);
        ?>
        <script>
            (function () {
                function save() {
                    const data = <?php echo json_encode($this->exportData); ?>;

                    let date = new Date().toISOString().slice(0, 10);
                    // .txt to pass WP Media library
                    let fileName = `advanced-views-export-${date}.txt`;
                    // add some text prefix to avoid WP Media library to think it's a JSON
                    let content = "Advanced Views:" + JSON.stringify(data);

                    const file = new File([content], fileName, {
                        type: 'application/json',
                    })

                    let toolsUrl = "<?php echo $redirectUrl?>";

                    const a = document.createElement('a');

                    a.href = URL.createObjectURL(file);
                    a.download = fileName;
                    a.click();

                    window.location.href = toolsUrl;
                }

                'loading' === document.readyState ?
                    window.document.addEventListener('DOMContentLoaded', save) :
                    save();
            }())
        </script>
        <?php
        exit;
    }

    public function addPage(): void
    {
        // do not use 'acf_add_options_page', as the global options-related functions may be unavailable
        // (in case of the manual include)
        if (!function_exists('acf_options_page')) {
            return;
        }

        $type = sanitize_text_field($_GET['type'] ?? '');
        $isExport = 'export' === $type;
        $isImport = 'import' === $type;

        $updatedMessage = '';

        if ($isExport) {
            $viewsCount = (int)($_GET['_views'] ?? 0);
            $cardsCount = (int)($_GET['_cards'] ?? 0);

            $updatedMessage = __('Success! There were %d Views and %d Cards exported.', 'acf-views');
            $updatedMessage = sprintf($updatedMessage, $viewsCount, $cardsCount);
        }

        if ($isImport) {
            $resultMessage = sanitize_text_field($_GET['resultMessage'] ?? '');
            $resultMessage = esc_html($resultMessage);

            $successViewIds = explode(';', $resultMessage)[0] ?? '';
            $successViewIds = '' !== $successViewIds ?
                explode(',', $successViewIds) :
                [];

            $successCardIds = explode(';', $resultMessage)[1] ?? '';
            $successCardIds = '' !== $successCardIds ?
                explode(',', $successCardIds) :
                [];

            $failViewUniqueIds = explode(';', $resultMessage)[2] ?? '';
            $failViewUniqueIds = '' !== $failViewUniqueIds ?
                explode(',', $failViewUniqueIds) :
                [];

            $failCardUniqueId = explode(';', $resultMessage)[3] ?? '';
            $failCardUniqueId = '' !== $failCardUniqueId ?
                explode(',', $failCardUniqueId) :
                [];

            $updatedMessage = $this->getImportResultMessage(
                $successViewIds,
                $successCardIds,
                $failViewUniqueIds,
                $failCardUniqueId
            );
        }

        acf_options_page()->add_page([
            'slug' => self::SLUG,
            'page_title' => __('Tools', 'acf-views'),
            'menu_title' => __('Tools', 'acf-views'),
            'parent_slug' => sprintf('edit.php?post_type=%s', ViewsCpt::NAME),
            'position' => 3,
            'update_button' => __('Process', 'acf-views'),
            'updated_message' => $updatedMessage,
        ]);
    }

    /**
     * @param mixed $postId
     */
    public function maybeCatchValues($postId): void
    {
        if (!$this->isMySource($postId)) {
            return;
        }

        add_filter('acf/pre_update_value', function ($isUpdated, $value, $postId, array $field): bool {
            // extra check, as probably it's about another post
            if (!$this->isMySource($postId)) {
                return $isUpdated;
            }

            $fieldName = (string)($field['name'] ?? '');

            $this->values[$fieldName] = $value;

            // avoid saving to the postmeta
            return true;
        }, 10, 4);
    }

    /**
     * @param mixed $postId
     * @throws Exception
     */
    public function maybeProcess($postId): void
    {
        if (!$this->isMySource($postId) ||
            [] === $this->values) {
            return;
        }

        $this->toolsData->load(false, '', $this->values);

        $isExport = $this->toolsData->isExportAllViews ||
            $this->toolsData->isExportAllCards ||
            [] !== $this->toolsData->exportViews ||
            [] !== $this->toolsData->exportCards;
        $isImport = 0 !== $this->toolsData->importFile;

        if ($isExport) {
            $this->export();
        }

        if ($isImport) {
            $this->import();
        }
    }

    public function setHooks(CurrentScreen $currentScreen): void
    {
        if (false === $currentScreen->isAdmin()) {
            return;
        }

        // init, not acf/init, as the method uses 'get_edit_post_link' which will be available only since this hook
        // (because we sign up the CPTs in this hook)
        add_action('init', [$this, 'addPage',]);
        add_action('acf/save_post', [$this, 'maybeCatchValues',]);
        // priority 20, as it's after the ACF's save_post hook
        add_action('acf/save_post', [$this, 'maybeProcess',], 20);
        // priority 30, after the process action
        add_action('acf/save_post', [$this, 'maybeEchoExportFile',], 30);
    }
}