<?php
namespace JVBase\managers;

use JVBase\registrar\Registrar;
use WP_Post;
use WP_Error;
use Exception;
use WP_Query;

if (!defined('ABSPATH')) {
    exit; // Exit if accessed directly
}
class UserTermsManager
{
    private Cache $cache;

	protected CustomTable $index;

    public function __construct()
    {
		$this->defineTables();
		$this->cache = Cache::for('term_ids')->connect('user');

        // Register hooks
        add_action('set_object_terms', [$this, 'handleTermAssignment'], 10, 6);

        // Add filter for bulk operation handling
        add_filter(BASE . 'handle_bulk_operation', [ $this, 'processOperation' ], 10, 3);
    }

	public function defineTables():void
	{
		$userIndex = CustomTable::for('user_term_index');
		$userIndex->setColumns([
			'id'			=> 'bigint(20) unsigned NOT NULL AUTO_INCREMENT',
			'user_id'		=> "{$userIndex->getUserIDType()} NOT NULL",
			'term_id'		=> "{$userIndex->getTermIDType()} NOT NULL",
			'taxonomy'		=> 'varchar(32) NOT NULL',
			'post_count'	=> 'int(11) NOT NULL DEFAULT 1',
			'parent_id'		=> "{$userIndex->getTermIDType()} NOT NULL DEFAULT 0",
			'last_used'		=> 'timestamp DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP',
		]);
		$userIndex->setKeys([
			['key' => 'PRIMARY', 'value' => '(`id`)'],
			['key' => 'UNIQUE', 'value' => '`user_term` (`user_id`, `term_id`, `taxonomy`)'],
			'`user_taxonomy` (`user_id`, `taxonomy`)',
			'`taxonomy` (`taxonomy`)',
			'`user_id` (`user_id`)',
			'`term_id` (`term_id`)',
			'`parent_id` (`parent_id`)'
		]);
		$base = BASE;
		$userIndex->setConstraints([
			"CONSTRAINT `{$base}user_term_user_fk` FOREIGN KEY (`user_id`)
			REFERENCES `{$userIndex->getUserTable()}` (`ID`) ON DELETE CASCADE",
			"CONSTRAINT `{$base}user_term_term_fk` FOREIGN KEY (`term_id`)
			REFERENCES `{$userIndex->getTermTable()}` (`term_id`) ON DELETE CASCADE"
		]);
		$userIndex->defineTable();
		$this->index = $userIndex;
	}

    /**
     * @param int $user_id
     * @param string|null $taxonomy
     *
     * @return void
     */
    public function clearUserCache(int $user_id, string|null $taxonomy = null):void
    {
		$cache = Cache::for($user_id.'_term_relationships', DAY_IN_SECONDS)->connect('post', true)->connect('taxonomy', true);
		$cache->flush();
    }

    /**
	 * Handle term assignment changes
     * @param int $object_id
     * @param array $terms
     * @param array $tt_ids
     * @param string $taxonomy
     * @param bool $append
     * @param array $old_tt_ids
     *
     * @return void
     */
    public function handleTermAssignment(int $object_id, array $terms, array $tt_ids, string $taxonomy, bool $append, array $old_tt_ids):void
    {
        $post = get_post($object_id);

        // Skip if not a valid post
        if (!$post || !str_starts_with($post->post_type, BASE)) {
            return;
        }

        $user_id = $post->post_author;

		$termIDs = array_unique(array_merge($tt_ids, $old_tt_ids));
       if (!empty($termIDs)) {
		   foreach ($termIDs as $termID) {
			   $term_id = $this->getTermIDFromTTID($termID);
			   $this->updateUserTerm($user_id, $term_id, $taxonomy);
		   }
	   }
    }

    /**
	 * Updates the entry for the user's term relationship
     * @param int $user_id
     * @param int $term_id
     * @param string $taxonomy
     *
     * @return bool
     */
    public function updateUserTerm(int $user_id, int $term_id, string $taxonomy):bool
    {

		$taxonomy = jvbCheckBase($taxonomy);

        // Ensure the term exists
        $term = get_term($term_id, $taxonomy);
        if (is_wp_error($term) || empty($term)) {
            return false;
        }

		$posts = new WP_Query([
			'post_author' 	=> $user_id,
			'tax_query'		=> [
				[
					'taxonomy'	=> $taxonomy,
					'terms'		=> $term_id,
				]
			],
			'post_status'	=> 'publish',
			'posts_per_page'=> -1,
			'fields'		=> 'ids'
		]);
		$userPosts = count($posts->posts);

		$result = $this->index->findOrCreate([
			'user_id'	=> $user_id,
			'term_id'	=> $term_id,
			'taxonomy'	=> $taxonomy
		],[
			'parent_id'	=> $term->parent,
			'post_count'=> $userPosts
		]);

		if ($term->parent > 0) {
			$this->updateUserTerm($user_id, $term->parent, $taxonomy);
		}

        return (bool) $result;
    }

    /**
	 * Helper function to get term_id from term_taxonomy_id
     * @param int $tt_id
     *
     * @return int
     */
    private function getTermIDFromTTID(int $tt_id):int
    {
		global $wpdb;
		return $wpdb->get_var($wpdb->prepare(
			"SELECT term_id FROM {$wpdb->term_taxonomy} WHERE term_taxonomy_id = %d",
			$tt_id
		));
    }

    /**
	 * Rebuild the user terms index for all users
     * @return array
     */
    public function rebuildAllUserIndex():array
    {


        // Clear existing index
		global $wpdb;
        $wpdb->query("TRUNCATE TABLE {$this->index->getFullTableName()}");

        $users = get_users([
			'has_published_posts'	=> [array_map('jvbCheckBase', Registrar::getRegistered('post'))],
			'fields' => 'ID'
		]);
		if (empty($users)) {
			return [
				'success'	=> true,
				'message'	=> 'No users found to update'
			];
		}

        JVB()->queue()->queueOperation(
            'rebuild_user_term_index',
            0,
            [
                'users' => $users
            ],
            [
				'chunk_key' => 'users',
				'chunk_size' => 5,
                'operation_id'      => 'rebuild_user_terms_' . date('Y_m_d')
            ]
        );

        return [
            'success'   => true,
            'message'   => 'Operation Queued for Processing'
        ];
    }

    /**
	 * Rebuild the index for a specific user
     * @param int $user_id
     *
     * @return array
     */
    public function rebuildUserIndex(int $user_id):array
    {
		$user = get_userdata($user_id);
		if (!$user) {
			return  [
				'success'	=> false,
				'message'	=> 'User does not exist'
			];
		}

        JVB()->queue()->queueOperation(
            'rebuild_user_term_index',
            0,
            [
                'users' => [$user_id]
            ],
            [
                'count'   => 1,
                'operation_id'      => 'rebuild_user_'.$user_id.'_terms_' . date('Y_m_d')
            ]
        );

        return [
            'success'   => true,
            'message'   => 'Operation Queued for Processing'
        ];
    }

    /**
     * Handle bulk operations for notifications
     *
     * @param WP_Error|array $result Default result
     * @param object $operation Operation object
     * @param array $data Current item
     *
     * @return WP_Error|array|bool Operation result
     */
    public function processOperation(WP_Error|array $result, object $operation, array $data):WP_Error|array|bool
    {
        if ($operation->type !== 'rebuild_user_term_index') {
            return $result;
        }
        try {

			$results = [];
            foreach ($data['users'] as $user_id) {
				$this->index->delete(['user_id' => $user_id]);

                // Clear all caches for this user
                $this->clearUserCache($user_id);

                // Get all the user's published posts
				$posts = new WP_Query([
					'post_status'	=> 'publish',
					'post_type'		=> array_map('jvbCheckBase', Registrar::getRegistered('post')),
					'posts_per_page'=> -1,
					'fields'		=> 'ids'
				]);

				if (empty($posts->posts)) {
					return [
						'success'	=> true,
						'result'	=> [
							'user_id'	=> $user_id,
							'processed_posts'=> 0,
							'processed_terms'=> 0,
						]
					];
				}

				$terms = [];

				$taxonomies = [];
				$result=[
					'user_id'	=> $user_id,
					'posts'		=> count($posts->posts)
				];
				foreach ($posts->posts as $postID) {
					$postType = get_post_type($postID);
					if (!array_key_exists($postType, $taxonomies)) {
						$taxonomies[$postType] = get_object_taxonomies($postType);
					}
					$tax = $taxonomies[$postType];
					$terms = array_unique(array_merge($terms, wp_get_object_terms($postID, $tax, ['fields' => 'ids'])));
				}

				$result['terms'] = count($terms);

				foreach ($terms as $termID) {
					$taxonomy = get_term($termID)->taxonomy??false;
					if (!$taxonomy) {
						continue;
					}
					$this->updateUserTerm($user_id, $termID, $taxonomy);
				}

				$results[] = $result;
            }

            return [
                'success' => true,
				'result'	=> $results
            ];
        } catch (Exception $e) {
            JVB()->error()->log(
                '[UserTermsManager]:processOperation',
                "Exception during operation processing: " . $e->getMessage(),
                [
                    'operation' => $operation->id,
                ]
            );
            return [
				'success'	=> false,
				'result'	=> $e->getMessage()
			];
        }
    }

    /**
     * @param int $user_id
     * @param string $taxonomy
     * @param array $args
     *
     * @return array
     */
    public function fetchUserTerms(int $user_id, string $taxonomy, array $args = []):array
    {
		$taxonomy = jvbNoBase($taxonomy);
		if (!in_array($taxonomy, Registrar::getRegistered('term'))){
			return [];
		}
        $taxonomy = jvbCheckBase($taxonomy);

		$order = array_key_exists('order', $args) ? (!in_array(strtoupper($args['order']), ['ASC', 'DESC']) ? 'DESC' : $args['order']) : 'DESC';
		$orderby = array_key_exists('orderby', $args) ? (!in_array(strtolower($args['orderby']), ['post_count', 'last_used']) ? 'post_count' : $args['orderby']) : 'post_count';
		$limit = array_key_exists('limit', $args) ? absint($args['limit']) : 0;
		$limit = $limit === 0 ? null : $limit;

		return $this->index->pluck(
			'term_id',
			[
				'user_id'	=> $user_id,
				'taxonomy'	=> $taxonomy
			],
			$orderby,
			$order,
			$limit
		);
    }

}