<?php
/**
 * Plugin Name: AK OpenSearch
 * Description: Индексация постов WordPress в OpenSearch с поддержкой пакетной обработки и WP-CLI.
 * Version: 0.1.0
 * Author: Andrey Delfin
 */

/**
 * wp opensearch status - проверяем статус 
 * wp opensearch test_index - тест
 * wp opensearch delete_index - удаляем индекс
 * wp opensearch create_index --force - создаем индекс
 * wp opensearch test_index - тестируем индекс (10 штук отправляем)
 * wp opensearch test_search тестируем поиск
 * 
 * wp opensearch index --post-type=anew --batch-size=50 --offset=0
 * 
 * # Полный маппинг в JSON
 * wp opensearch get_mapping
 *
 * # Маппинг в виде таблицы
 * wp opensearch get_mapping --format=table
 *
 * # Информация о конкретном поле
 * wp opensearch get_mapping --field=title

 * # Pretty JSON вывод
 * wp opensearch get_mapping --pretty

 * # Маппинг в CSV формате
 * wp opensearch get_mapping --format=csv
 */

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

/**
 * ----------------------------
 *   БАЗОВЫЙ КЛАСС КЛИЕНТА OPENSEARCH
 * ----------------------------
 */
class AK_OpenSearch_Base_Client {
    protected $host;
    protected $user;
    protected $pass;
    public  $index;

    public function __construct($host, $user, $pass, $index = 'wordpress') {
        $this->host  = rtrim($host, '/');
        $this->user  = $user;
        $this->pass  = $pass;
        $this->index = $index;
    }

    /**
     * Отправка запроса к OpenSearch
     */
    protected function send_request($method, $endpoint, $body = null, $is_raw_body = false) {
        $url = $this->host . '/' . $this->index . '/' . ltrim($endpoint, '/');

        $args = [
            'method'  => $method,
            'headers' => [
                'Authorization' => 'Basic ' . base64_encode($this->user . ':' . $this->pass),
                'Content-Type'  => 'application/json',
            ],
            'sslverify' => apply_filters('wp_opensearch_sslverify', false),
            'timeout'   => 30,
        ];

        // Для GET-запросов параметры передаются в URL, а не в теле
        if ($method === 'GET' && !is_null($body) && is_array($body)) {
            $url .= '?' . http_build_query($body);
            $body = null;
        }

        // Добавляем тело для не-GET запросов
        if (!is_null($body) && $method !== 'GET') {
            if ($is_raw_body && is_string($body)) {
                $args['body'] = $body;
            } else {
                $args['body'] = wp_json_encode($body);
            }
        }

        $response = wp_remote_request($url, $args);

        if (is_wp_error($response)) {
            return new WP_Error(
                'opensearch_network_error',
                $response->get_error_message(),
                ['method' => $method, 'endpoint' => $endpoint]
            );
        }

        $response_code = wp_remote_retrieve_response_code($response);
        $response_body = json_decode(wp_remote_retrieve_body($response), true);

        if ($response_code >= 400) {
            $error_message = isset($response_body['error'])
                ? (is_array($response_body['error']) ? json_encode($response_body['error']) : $response_body['error'])
                : (isset($response_body['message']) ? $response_body['message'] : 'Unknown OpenSearch error');

            return new WP_Error(
                'opensearch_api_error',
                $error_message,
                [
                    'status'   => $response_code,
                    'request'  => ['method' => $method, 'endpoint' => $endpoint, 'body' => $body],
                    'response' => $response_body
                ]
            );
        }

        // Обработка ошибок bulk операций
        if (strpos($endpoint, '_bulk') !== false && isset($response_body['items'])) {
            $failed_items = array_filter($response_body['items'], function($item) {
                return isset($item['index']['error']);
            });

            if (!empty($failed_items)) {
                return new WP_Error(
                    'opensearch_bulk_partial_failure',
                    'Bulk operation completed with some failures',
                    [
                        'failed_count'    => count($failed_items),
                        'successful_count'=> count($response_body['items']) - count($failed_items),
                        'failures'        => array_values($failed_items)
                    ]
                );
            }
        }

        return $response_body;
    }

    /**
     * Проверка существования индекса
     */
    public function index_exists() {
        $response = wp_remote_request($this->host . '/' . $this->index, [
            'method' => 'HEAD',
            'headers' => [
                'Authorization' => 'Basic ' . base64_encode($this->user . ':' . $this->pass),
            ],
            'sslverify' => apply_filters('wp_opensearch_sslverify', false),
        ]);

        return !is_wp_error($response) && wp_remote_retrieve_response_code($response) === 200;
    }

    /**
     * Удаление индекса
     */
    public function delete_index() {
        return $this->send_request('DELETE', '');
    }

    /**
     * Получение статистики индекса
     */
    public function get_stats() {
        return $this->send_request('GET', '_stats');
    }

    /**
     * Получение маппинга индекса
    */
    public function get_mapping() {
        return $this->send_request('GET', '_mapping');
    }

    /**
     * Проверка существующих документов
     */
    public function check_existing_posts($post_ids) {
        if (empty($post_ids)) {
            return [];
        }

        $body = [
            'query' => [
                'terms' => [
                    '_id' => $post_ids
                ]
            ],
            'size' => count($post_ids),
            '_source' => false
        ];

        $response = $this->send_request('POST', '_search', $body);
        
        if (is_wp_error($response)) {
            return [];
        }

        return array_map(function($hit) {
            return $hit['_id'];
        }, $response['hits']['hits'] ?? []);
    }
}

/**
 * ----------------------------
 *   КЛАСС ДЛЯ ИНДЕКСАЦИИ ДАННЫХ
 * ----------------------------
 */
class AK_OpenSearch_Indexer extends AK_OpenSearch_Base_Client {
    
    /**
     * Создание индекса
     */
    public function create_index() {
        $settings = [
            'settings' => [
                'analysis' => [
                    'filter' => [
                        'russian_stop' => ['type' => 'stop','stopwords' => '_russian_'],
                        'russian_stemmer' => ['type' => 'stemmer','language' => 'russian'],
                        'russian_keywords' => ['type' => 'keyword_marker','keywords' => ['пример']]
                    ],
                    'analyzer' => [
                        'russian_analyzer' => [
                            'tokenizer' => 'standard',
                            'filter'    => ['lowercase','russian_stop','russian_keywords','russian_stemmer']
                        ]
                    ]
                ],
                'index' => ['number_of_shards' => 1,'number_of_replicas' => 1]
            ],
            'mappings' => [
                'properties' => [
                    'id' => ['type' => 'integer'],
                    'post_type' => ['type' => 'keyword'],
                    'title' => ['type' => 'text','analyzer' => 'russian_analyzer'],
                    'excerpt' => ['type' => 'text','analyzer' => 'russian_analyzer','fielddata' => true],
                    'content' => ['type' => 'text','analyzer' => 'russian_analyzer'],
                    'meta' => ['type' => 'object'],
                    'author' => [
                        'properties' => [
                            'id' => ['type' => 'integer'],
                            'name' => ['type' => 'text'],
                            'slug' => ['type' => 'keyword']
                        ]
                    ],
                    'date' => [
                        'type' => 'date',
                        'format' => 'yyyy-MM-dd HH:mm:ss||strict_date_optional_time||epoch_millis'
                    ],
                    'modified' => [
                        'type' => 'date',
                        'format' => 'yyyy-MM-dd HH:mm:ss||strict_date_optional_time||epoch_millis'
                    ],
                    'url' => ['type' => 'keyword']
                ]
            ]
        ];
        
        return $this->send_request('PUT', '', $settings);
    }

    /**
     * Получение мета-данных поста
     */
    private function get_post_meta($post_id) {
        $meta = get_post_meta($post_id);
        $result = [];
        foreach ($meta as $key => $values) {
            if (strpos($key, '_') === 0) continue;
            $result[$key] = count($values) === 1 ? maybe_unserialize($values[0]) : array_map('maybe_unserialize', $values);
        }
        return $result;
    }

    /**
     * Индексация документов пачками
     */
    public function bulk_index_documents($post_type = 'post', $limit = 100, $offset = 0) {
        global $wpdb;
        
        $posts = $wpdb->get_results($wpdb->prepare(
            "SELECT ID, post_title, post_content, post_excerpt, post_type, 
                    post_author, post_date_gmt, post_modified_gmt 
             FROM {$wpdb->posts} 
             WHERE post_status = 'publish' AND post_type = %s 
             ORDER BY post_date DESC 
             LIMIT %d OFFSET %d",
            $post_type,
            $limit,
            $offset
        ));

        if (empty($posts)) {
            return new WP_Error('empty_posts', 'No posts found for indexing');
        }

        $bulk_body = '';
        $post_ids = [];

        foreach ($posts as $post) {
            $meta = $this->get_post_meta($post->ID);
            
            // Очищаем мета-данные от несериализуемых значений
            $meta = array_filter($meta, function($item) {
                return !is_resource($item);
            });

            $document = [
                'id'        => $post->ID,
                'title'     => $post->post_title,
                'post_type' => $post->post_type,
                'excerpt'   => wp_strip_all_tags($post->post_excerpt),
                'content'   => wp_strip_all_tags($post->post_content),
                'meta'      => $meta,
                'author'    => [
                    'id'   => $post->post_author,
                    'name' => get_the_author_meta('display_name', $post->post_author),
                    'slug' => get_the_author_meta('user_nicename', $post->post_author),
                ],
                'date'     => $post->post_date_gmt,
                'modified' => $post->post_modified_gmt,
            ];

            $bulk_body .= wp_json_encode(['index' => ['_index' => $this->index, '_id' => $post->ID]]) . "\n";
            $bulk_body .= wp_json_encode($document, JSON_UNESCAPED_UNICODE) . "\n";
            $post_ids[] = $post->ID;
        }

        $response = $this->send_request('POST', '_bulk', $bulk_body, true);
        
        if (is_wp_error($response)) {
            return $response;
        }

        // Проверка ошибок в bulk операции
        if (isset($response['items'])) {
            $errors = [];
            foreach ($response['items'] as $item) {
                if (isset($item['index']['error'])) {
                    $errors[] = [
                        'post_id' => $item['index']['_id'],
                        'reason' => $item['index']['error']['reason'] ?? 'Unknown error',
                        'type' => $item['index']['error']['type'] ?? 'unknown'
                    ];
                }
            }
            
            if (!empty($errors)) {
                $error_message = sprintf(
                    "Bulk operation completed with %d failures out of %d items.",
                    count($errors),
                    count($response['items'])
                );
                
                return new WP_Error('bulk_partial_failure', $error_message, [
                    'total_items' => count($response['items']),
                    'failed_items' => count($errors),
                    'errors' => $errors
                ]);
            }
        }

        return $response;
    }

    /**
     * Индексация конкретных постов
     */
    public function bulk_index($post_ids) {
        if (empty($post_ids)) {
            return new WP_Error('empty_posts', 'No post IDs provided');
        }

        $bulk_body = '';
        
        foreach ($post_ids as $post_id) {
            $post = get_post($post_id);
            if (!$post || $post->post_status !== 'publish') {
                continue;
            }

            $meta = $this->get_post_meta($post_id);
            $meta = array_filter($meta, function($item) {
                return !is_resource($item);
            });

            $document = [
                'id'        => $post->ID,
                'title'     => $post->post_title,
                'post_type' => $post->post_type,
                'excerpt'   => wp_strip_all_tags($post->post_excerpt),
                'content'   => wp_strip_all_tags($post->post_content),
                'meta'      => $meta,
                'author'    => [
                    'id'   => $post->post_author,
                    'name' => get_the_author_meta('display_name', $post->post_author),
                    'slug' => get_the_author_meta('user_nicename', $post->post_author),
                ],
                'date'     => $post->post_date_gmt,
                'modified' => $post->post_modified_gmt,
            ];

            $bulk_body .= wp_json_encode(['index' => ['_index' => $this->index, '_id' => $post->ID]]) . "\n";
            $bulk_body .= wp_json_encode($document, JSON_UNESCAPED_UNICODE) . "\n";
        }

        return $this->send_request('POST', '_bulk', $bulk_body, true);
    }

    /**
     * Индексация одного поста
     */
    public function index_post($post_id) {
        $post = get_post($post_id);
        if (!$post || $post->post_status !== 'publish') {
            return new WP_Error('invalid_post', 'Post not found or not published');
        }

        $meta = $this->get_post_meta($post_id);
        $meta = array_filter($meta, function($item) {
            return !is_resource($item);
        });

        $document = [
            'id'        => $post->ID,
            'title'     => $post->post_title,
            'post_type' => $post->post_type,
            'excerpt'   => wp_strip_all_tags($post->post_excerpt),
            'content'   => wp_strip_all_tags($post->post_content),
            'meta'      => $meta,
            'author'    => [
                'id'   => $post->post_author,
                'name' => get_the_author_meta('display_name', $post->post_author),
                'slug' => get_the_author_meta('user_nicename', $post->post_author),
            ],
            'date'     => $post->post_date_gmt,
            'modified' => $post->post_modified_gmt,
        ];

        return $this->send_request('PUT', '_doc/' . $post_id, $document);
    }

    /**
     * Удаление поста из индекса
     */
    public function delete_post($post_id) {
        return $this->send_request('DELETE', '_doc/' . $post_id);
    }
}

/**
 * ----------------------------
 *   КЛАСС ДЛЯ ПОИСКА
 * ----------------------------
 */
class AK_OpenSearch_Searcher extends AK_OpenSearch_Base_Client {
    
    /**
     * Поиск документов
     */
    public function search($query, $page = 1, $per_page = 10, $params = []) {
        $from = ($page - 1) * $per_page;
        
        $defaults = [
            'from' => $from,
            'size' => $per_page,
            '_source' => ['id', 'title', 'excerpt', 'date', 'url', 'author'],
            'sort' => [['date' => 'desc']]
        ];

        $params = wp_parse_args($params, $defaults);

        $search_body = [
            'query' => [
                'multi_match' => [
                    'query' => $query,
                    'fields' => ['title^3', 'content^2', 'excerpt'],
                    'fuzziness' => 'AUTO'
                ]
            ],
            'highlight' => [
                'fields' => [
                    'content' => new stdClass(),
                    'title' => new stdClass()
                ]
            ]
        ];

        // Удаляем из параметров то, что уже есть в search_body
        unset($params['query'], $params['highlight']);

        // Объединяем параметры
        $search_body = array_merge($search_body, $params);

        return $this->send_request('POST', '_search', $search_body);
    }

    /**
     * Полнотекстовый поиск с дополнительными параметрами
     */
    public function advanced_search($args = []) {
        $defaults = [
            'query' => '',
            'page' => 1,
            'per_page' => 10,
            'post_type' => [],
            'date_range' => [],
            'sort' => [['date' => 'desc']]
        ];

        $args = wp_parse_args($args, $defaults);

        $from = ($args['page'] - 1) * $args['per_page'];
        $query = [];

        // Базовый запрос
        if (!empty($args['query'])) {
            $query['bool']['must'][] = [
                'multi_match' => [
                    'query' => $args['query'],
                    'fields' => ['title^3', 'content^2', 'excerpt'],
                    'fuzziness' => 'AUTO'
                ]
            ];
        }

        // Фильтр по типу поста
        if (!empty($args['post_type'])) {
            $query['bool']['filter'][] = [
                'terms' => ['post_type' => (array)$args['post_type']]
            ];
        }

        // Фильтр по дате
        if (!empty($args['date_range'])) {
            $date_filter = [];
            if (!empty($args['date_range']['from'])) {
                $date_filter['gte'] = $args['date_range']['from'];
            }
            if (!empty($args['date_range']['to'])) {
                $date_filter['lte'] = $args['date_range']['to'];
            }
            
            if (!empty($date_filter)) {
                $query['bool']['filter'][] = [
                    'range' => ['date' => $date_filter]
                ];
            }
        }

        // Если нет условий запроса, ищем все документы
        if (empty($query)) {
            $query = ['match_all' => new stdClass()];
        }

        $search_body = [
            'query' => $query,
            'from' => $from,
            'size' => $args['per_page'],
            'sort' => $args['sort'],
            '_source' => ['id', 'title', 'excerpt', 'date', 'url', 'author'],
            'highlight' => [
                'fields' => [
                    'content' => new stdClass(),
                    'title' => new stdClass()
                ]
            ]
        ];

        return $this->send_request('POST', '_search', $search_body);
    }

    /**
     * Получение документа по ID
     */
    public function get_document($post_id) {
        return $this->send_request('GET', '_doc/' . $post_id);
    }
}

/**
 * ----------------------------
 *       WP-CLI КОМАНДЫ
 * ----------------------------
 */
if (defined('WP_CLI') && WP_CLI) {
    class WP_OpenSearch_CLI_Command extends WP_CLI_Command {
        private $indexer;
        private $searcher;
        
        public function __construct() {
            $host  = defined('OPENSEARCH_HOST')  ? OPENSEARCH_HOST  : 'https://localhost:9200';
            $user  = defined('OPENSEARCH_USER')  ? OPENSEARCH_USER  : 'admin';
            $pass  = defined('OPENSEARCH_PASS')  ? OPENSEARCH_PASS  : 'password';
            $index = defined('OPENSEARCH_INDEX') ? OPENSEARCH_INDEX : 'wordpress';
            
            $this->indexer = new AK_OpenSearch_Indexer($host, $user, $pass, $index);
            $this->searcher = new AK_OpenSearch_Searcher($host, $user, $pass, $index);
        }

        /** wp opensearch create_index */
        public function create_index($args, $assoc_args) {
            $force = isset($assoc_args['force']);
            if ($this->indexer->index_exists()) {
                if ($force) {
                    WP_CLI::log("Deleting existing index...");
                    $res = $this->indexer->delete_index();
                    if (is_wp_error($res)) WP_CLI::error("Failed: ".$res->get_error_message());
                    WP_CLI::success("Index deleted");
                } else {
                    WP_CLI::error("Index exists. Use --force to recreate.");
                }
            }
            WP_CLI::log("Creating index...");
            $res = $this->indexer->create_index();
            if (is_wp_error($res)) WP_CLI::error("Failed: ".$res->get_error_message());
            WP_CLI::success("Index created");
        }

        /** wp opensearch delete_index */
        public function delete_index($args, $assoc_args) {
            if (!$this->indexer->index_exists()) WP_CLI::error("Index does not exist");
            WP_CLI::confirm("Delete index?", $assoc_args);
            $res = $this->indexer->delete_index();
            if (is_wp_error($res)) WP_CLI::error("Failed: ".$res->get_error_message());
            WP_CLI::success("Index deleted");
        }

        /** wp opensearch status */
        public function status($args, $assoc_args) {
            if (!$this->indexer->index_exists()) WP_CLI::error("Index does not exist");
            $stats = $this->indexer->get_stats();
            if (is_wp_error($stats)) WP_CLI::error("Failed: ".$stats->get_error_message());
            $s = $stats['indices'][$this->indexer->index];
            WP_CLI::line("Index: ".$this->indexer->index);
            WP_CLI::line("Docs: ".$s['total']['docs']['count']);
            WP_CLI::line("Size: ".size_format($s['total']['store']['size_in_bytes']));
        }

        /** wp opensearch index_posts */
        public function index_posts($args, $assoc_args) {
            $batch_size   = isset($assoc_args['batch']) ? (int)$assoc_args['batch'] : 100;
            $post_types   = isset($assoc_args['post-types']) ? explode(',', $assoc_args['post-types']) : ['post','page'];
            $skip_existing= isset($assoc_args['skip-existing']);

            if (!$this->indexer->index_exists()) {
                WP_CLI::error("Index does not exist. Run: wp opensearch create_index");
            }

            $total = 0; 
            foreach ($post_types as $type) { 
                $total += wp_count_posts($type)->publish; 
            }
            
            if ($total === 0) WP_CLI::error("No posts found");

            $progress = \WP_CLI\Utils\make_progress_bar("Indexing", $total);
            $indexed = $skipped = $failed = 0;

            foreach ($post_types as $post_type) {
                $paged = 1;
                while ($posts = get_posts([
                    'post_type'      => $post_type,
                    'post_status'    => 'publish',
                    'posts_per_page' => $batch_size,
                    'paged'          => $paged++,
                    'fields'         => 'ids',
                    'orderby'        => 'ID',
                    'order'          => 'ASC',
                    'no_found_rows'  => true,
                ])) {
                    $posts_to_index = $posts;
                    if ($skip_existing) {
                        $existing = $this->indexer->check_existing_posts($posts);
                        $posts_to_index = array_diff($posts, $existing);
                        $skipped += count($existing);
                    }

                    if (!empty($posts_to_index)) {
                        $res = $this->indexer->bulk_index($posts_to_index);
                        if (is_wp_error($res)) {
                            $failed += count($posts_to_index);
                            WP_CLI::warning("Batch failed: ".$res->get_error_message());
                        } else {
                            $indexed += count($posts_to_index);
                        }
                    }
                    $progress->tick(count($posts));
                    usleep(300000); // 0.3s пауза
                }
            }
            $progress->finish();
            WP_CLI::success("Done. Total: $total, Indexed: $indexed, Skipped: $skipped, Failed: $failed");
        }

        /**
         * Index posts to OpenSearch
         */
        public function index($args, $assoc_args) {
            $post_type = $assoc_args['post-type'] ?? 'post';
            $batch_size = (int) ($assoc_args['batch-size'] ?? 100);
            $offset = (int) ($assoc_args['offset'] ?? 0);
            $all = isset($assoc_args['all']);
            
            if ($all) {
                WP_CLI::log("Starting full index of '$post_type' posts...");
                $this->index_all_posts($post_type, $batch_size);
            } else {
                WP_CLI::log("Indexing batch of $batch_size '$post_type' posts starting from offset $offset...");
                $result = $this->indexer->bulk_index_documents($post_type, $batch_size, $offset);
                
                if (is_wp_error($result)) {
                    WP_CLI::error($result->get_error_message());
                } else {
                    WP_CLI::success(sprintf(
                        "Successfully indexed %d posts (offset: %d)",
                        $batch_size,
                        $offset
                    ));
                }
            }
        }
        
        /**
         * Index all posts of a given type in batches
         */
        private function index_all_posts($post_type, $batch_size) {
            global $wpdb;
            
            $total = (int) $wpdb->get_var($wpdb->prepare(
                "SELECT COUNT(ID) FROM {$wpdb->posts} 
                 WHERE post_status = 'publish' AND post_type = %s",
                $post_type
            ));
            
            if ($total === 0) {
                WP_CLI::warning("No published posts of type '$post_type' found.");
                return;
            }
            
            $progress = WP_CLI\Utils\make_progress_bar("Indexing $total posts", $total);
            $processed = 0;
            
            while ($processed < $total) {
                $result = $this->indexer->bulk_index_documents($post_type, $batch_size, $processed);
                
                if (is_wp_error($result)) {
                    $progress->finish();
                    WP_CLI::error($result->get_error_message());
                    return;
                }
                
                $processed += $batch_size;
                $progress->tick($batch_size);
                
                usleep(500000); // 0.5 second
            }
            
            $progress->finish();
            WP_CLI::success("Successfully indexed all $total posts of type '$post_type'");
        }

        /**
         * Get index mapping information
         */
        public function get_mapping($args, $assoc_args) {
            
            // Получаем параметры из командной строки
            $field = !empty($assoc_args['field']) ? $assoc_args['field'] : '';
            $format = !empty($assoc_args['format']) ? $assoc_args['format'] : 'json';
            $pretty = isset($assoc_args['pretty']);
    
            // Используем публичный метод для получения маппинга
            $result = $this->indexer->get_mapping();
    
            if (is_wp_error($result)) {
                WP_CLI::error("Failed to get mapping: " . $result->get_error_message());
                return;
            }
            
            // Если указано конкретное поле
            if (!empty($field)) {
                if (!empty($result) && is_array($result)) {
                    $index_name = array_key_first($result);
                    if ($index_name && isset($result[$index_name]['mappings']['properties'][$field])) {
                        $field_data = $result[$index_name]['mappings']['properties'][$field];
                        
                        // Вывод в запрошенном формате
                        switch ($format) {
                            case 'table':
                                $table_data = [
                                    ['Field' => $field, 'Type' => $field_data['type'] ?? 'unknown']
                                ];
                                
                                // Добавляем дополнительные свойства поля
                                if (isset($field_data['analyzer'])) {
                                    $table_data[0]['Analyzer'] = $field_data['analyzer'];
                                }
                                if (isset($field_data['search_analyzer'])) {
                                    $table_data[0]['Search Analyzer'] = $field_data['search_analyzer'];
                                }
                                if (isset($field_data['index'])) {
                                    $table_data[0]['Index'] = $field_data['index'] ? 'yes' : 'no';
                                }
                                
                                WP_CLI\Utils\format_items('table', $table_data, array_keys($table_data[0]));
                                break;
                                
                            case 'csv':
                                $csv_data = [
                                    ['Field', 'Type', 'Analyzer', 'Search Analyzer', 'Index']
                                ];
                                
                                $row = [
                                    $field,
                                    $field_data['type'] ?? 'unknown',
                                    $field_data['analyzer'] ?? '',
                                    $field_data['search_analyzer'] ?? '',
                                    isset($field_data['index']) ? ($field_data['index'] ? 'yes' : 'no') : ''
                                ];
                                
                                $csv_data[] = $row;
                                WP_CLI\Utils\format_items('csv', $csv_data, array_keys($csv_data[0]));
                                break;
                                
                            case 'yaml':
                                WP_CLI::line(yaml_emit($field_data));
                                break;
                                
                            default: // json
                                if ($pretty) {
                                    WP_CLI::line(json_encode($field_data, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE));
                                } else {
                                    WP_CLI::line(json_encode($field_data));
                                }
                                break;
                        }
                    } else {
                        WP_CLI::warning("Field '$field' not found in mapping");
                        
                        // Показываем доступные поля
                        $available_fields = [];
                        if (!empty($result) && is_array($result)) {
                            $index_name = array_key_first($result);
                            if ($index_name && isset($result[$index_name]['mappings']['properties'])) {
                                $available_fields = array_keys($result[$index_name]['mappings']['properties']);
                            }
                        }
                        
                        if (!empty($available_fields)) {
                            WP_CLI::line("\nAvailable fields: " . implode(', ', $available_fields));
                        }
                    }
                }
            } else {
                // Полный маппинг или список всех полей
                switch ($format) {
                    case 'table':
                        $table_data = [];
                        
                        if (!empty($result) && is_array($result)) {
                            $index_name = array_key_first($result);
                            if ($index_name && isset($result[$index_name]['mappings']['properties'])) {
                                $properties = $result[$index_name]['mappings']['properties'];
                                
                                foreach ($properties as $field_name => $field_config) {
                                    $row = [
                                        'Field' => $field_name,
                                        'Type' => $field_config['type'] ?? 'unknown',
                                        'Analyzer' => $field_config['analyzer'] ?? '-',
                                        'Search Analyzer' => $field_config['search_analyzer'] ?? '-',
                                        'Index' => isset($field_config['index']) ? ($field_config['index'] ? 'yes' : 'no') : 'yes'
                                    ];
                                    $table_data[] = $row;
                                }
                            }
                        }
                        
                        WP_CLI\Utils\format_items('table', $table_data, ['Field', 'Type', 'Analyzer', 'Search Analyzer', 'Index']);
                        break;
                        
                    case 'csv':
                        $csv_data = [['Field', 'Type', 'Analyzer', 'Search Analyzer', 'Index']];
                        
                        if (!empty($result) && is_array($result)) {
                            $index_name = array_key_first($result);
                            if ($index_name && isset($result[$index_name]['mappings']['properties'])) {
                                $properties = $result[$index_name]['mappings']['properties'];
                                
                                foreach ($properties as $field_name => $field_config) {
                                    $row = [
                                        $field_name,
                                        $field_config['type'] ?? 'unknown',
                                        $field_config['analyzer'] ?? '',
                                        $field_config['search_analyzer'] ?? '',
                                        isset($field_config['index']) ? ($field_config['index'] ? 'yes' : 'no') : 'yes'
                                    ];
                                    $csv_data[] = $row;
                                }
                            }
                        }
                        
                        WP_CLI\Utils\format_items('csv', $csv_data, array_keys($csv_data[0]));
                        break;
                        
                    case 'yaml':
                        WP_CLI::line(yaml_emit($result));
                        break;
                        
                    default: // json
                        if ($pretty) {
                            WP_CLI::line(json_encode($result, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES));
                        } else {
                            WP_CLI::line(json_encode($result));
                        }
                        break;
                }
            }
        }

        /**
         * Test command to index 10 latest 'anew' posts
         */
        public function test_index($args, $assoc_args) {
            WP_CLI::log("Starting test index of 10 latest 'anew' posts...");
            
            $result = $this->indexer->bulk_index_documents('anew', 10, 0);
            
            if (is_wp_error($result)) {
                WP_CLI::error("Error during indexing: " . $result->get_error_message());
                return;
            }
            
            if (is_array($result) && isset($result['errors'])) {
                if ($result['errors']) {
                    $error_count = 0;
                    foreach ($result['items'] as $item) {
                        if (isset($item['index']['error'])) {
                            $error_count++;
                            WP_CLI::warning(sprintf(
                                "Failed to index post ID %d: %s",
                                $item['index']['_id'],
                                $item['index']['error']['reason'] ?? 'Unknown error'
                            ));
                        }
                    }
                    WP_CLI::warning(sprintf(
                        "Test index completed with %d errors out of %d items",
                        $error_count,
                        count($result['items'])
                    ));
                } else {
                    WP_CLI::success("Successfully indexed 10 'anew' posts without errors");
                }
                
                if (WP_CLI::get_config('verbose')) {
                    WP_CLI::log("\nIndexing stats:");
                    WP_CLI::log("Took: " . ($result['took'] ?? 'N/A') . "ms");
                    WP_CLI::log("Errors: " . ($result['errors'] ? 'Yes' : 'No'));
                }
            } else {
                WP_CLI::success("Test index request completed. Response: " . json_encode($result));
            }
        }

        public function test_search($args, $assoc_args) {
            $result = $this->searcher->search('Набиуллина');

            if (is_wp_error($result)) {
                WP_CLI::error("Error during search: " . $result->get_error_message());
                return;
            }

            var_dump( $result );
        }    

    }

    WP_CLI::add_command('opensearch', 'WP_OpenSearch_CLI_Command');
}