<?php
namespace JVBase\registry;

use JVBase\meta\MetaManager;
use JVBase\meta\MetaRegistry;
if (!defined('ABSPATH')) {
	exit;
}
class TaxonomyRegistrar
{
	private string $slug;
	private array $config;
	private array $fields;
	private string $taxonomy;
	private FieldRegistry $fieldRegistry;

	public function __construct(string $slug, array $config)
	{
		$this->slug = $slug;
		$this->config = $config;
		$this->taxonomy = BASE . $slug;

		$this->fieldRegistry = FieldRegistry::getInstance();
		$this->fields = $this->fieldRegistry->getFields($slug, 'term');

		// Set up custom table hooks if this is a content taxonomy
		if ($this->config['is_content'] ?? false) {
			$this->setupContentTaxonomyHooks();
		}
	}

	public function register(): void
	{
		$singular = $this->config['singular'] ?? ucfirst($this->slug);
		$plural = $this->config['plural'] ?? $singular . 's';

		$args = [
			'labels' => $this->buildLabels($singular, $plural),
			'hierarchical' => $this->config['hierarchical'] ?? true,
			'public' => $this->config['public'] ?? true,
			'show_ui' => $this->config['show_ui'] ?? true,
			'show_admin_column' => $this->config['show_admin_column'] ?? true,
			'show_in_rest' => $this->config['show_in_rest'] ?? true,
			'rewrite' => $this->config['rewrite'] ?? [
					'slug' => $this->slug,
					'with_front' => false
				]
		];

		$post_types = array_map(fn($type) => BASE . $type, $this->config['for_content'] ?? []);
		register_taxonomy($this->taxonomy, $post_types, $args);

		$this->maybeAddRewriteRule($args['rewrite']);
		if (!empty($this->fields)) {
			$meta_registry = new MetaRegistry($this->fields, $this->slug, 'term');
			$meta_registry->registerMetaFields();
		}
	}

	/**
	 * Add custom rewrite rule for hierarchical taxonomy slugs (e.g., post-type/by/taxonomy-slug)
	 */
	protected function maybeAddRewriteRule(array $rewrite_config): void
	{
		$slug = $rewrite_config['slug'] ?? $this->slug;

		// Only add custom rule if slug contains slashes (hierarchical path)
		if (!str_contains($slug, '/')) {
			return;
		}

		add_rewrite_rule(
			"^{$slug}/([^/]+)/?$",
			'index.php?' . $this->taxonomy . '=$matches[1]',
			'top'
		);
	}

    private function buildLabels(string $singular, string $plural): array
    {
        return [
            'name' => $plural,
            'singular_name' => $singular,
            'search_items' => "Search {$plural}",
            'all_items' => "All {$plural}",
            'edit_item' => "Edit {$singular}",
            'update_item' => "Update {$singular}",
            'add_new_item' => "Add New {$singular}",
            'new_item_name' => "New {$singular} Name",
            'menu_name' => $singular
        ];
    }

    /**
     * Set up hooks for content taxonomies to maintain custom table data
     */
    protected function setupContentTaxonomyHooks(): void
    {
        // Hook into term creation/updates
        add_action('created_term', [$this, 'handleTermSave'], 10, 3);
        add_action('edited_term', [$this, 'handleTermSave'], 10, 3);

        // Hook into term meta changes
        add_action('added_term_meta', [$this, 'handleTermMetaChange'], 10, 4);
        add_action('updated_term_meta', [$this, 'handleTermMetaChange'], 10, 4);
        add_action('deleted_term_meta', [$this, 'handleTermMetaChange'], 10, 4);
        add_action('add_term_relationship', [$this, 'addUserToContentType'], 10, 3);
        add_action('delete_term_relationships', [$this, 'removeUserFromContentType'], 10, 3);
    }

    public function addUserToContentType($postID, $termIDs, $taxonomy):void
    {
        if ($taxonomy !== $this->taxonomy) {
            return;
        }

        if (empty(jvbGetUserContentTypes($postID))) {
            return;
        }

        $userID = get_post_meta($postID, BASE . 'link', true);
        if (!is_numeric($userID)) {
            return;
        }

        foreach ($termIDs as $termID) {
            $users = get_term_meta($termID, BASE.'users', true);
            $users = ($users === '') ? [] : explode(',', $users);
            $users[] = $userID;
            update_term_meta($termID, BASE.'users', implode(',', $users));
        }
    }


    public function removeUserFromContentType($postID, $termIDs, $taxonomy):void
    {
        if ($taxonomy !== $this->taxonomy) {
            return;
        }

        if (empty(jvbGetUserContentTypes($postID))) {
            return;
        }

        $userID = get_post_meta($postID, BASE . 'link', true);
        if (!is_numeric($userID)) {
            return;
        }

        foreach ($termIDs as $termID) {
            $users = get_term_meta($termID, BASE.'users', true);
            $users = ($users === '') ? [] : explode(',', $users);
            unset($users[array_search($userID, $users)]);
            update_term_meta($termID, BASE.'users', implode(',', $users));
        }
    }

    /**
     * Handle term save (creation and updates)
     * @param int $term_id The term ID
     * @param int $taxonomy_id The taxonomy term ID
     * @param string $taxonomy The taxonomy name
     */
    public function handleTermSave(int $term_id, int $taxonomy_id, string $taxonomy): void
    {
        if ($taxonomy !== $this->taxonomy) {
            return;
        }

        $this->syncTermToCustomTable($term_id);
    }

    /**
     * Handle term meta changes
     * @param int $meta_id The meta ID
     * @param int $term_id The term ID
     * @param string $meta_key The meta key
     * @param mixed $meta_value The meta value
     */
    public function handleTermMetaChange(int $meta_id, int $term_id, string $meta_key, $meta_value): void
    {
        // Only handle meta for our taxonomy
        $term = get_term($term_id);
        if (!$term || is_wp_error($term) || $term->taxonomy !== $this->taxonomy) {
            return;
        }

        $this->syncTermToCustomTable($term_id);
    }

    /**
     * Sync a single term to the custom table
     * @param int $term_id The term ID to sync
     */
    public function syncTermToCustomTable(int $term_id): void
    {
        global $wpdb;

        $table = $wpdb->prefix . BASE . 'content_' . $this->slug;
        $term = get_term($term_id, $this->taxonomy);

        if (!$term || is_wp_error($term)) {
            return;
        }

        // Get custom table fields
        $custom_fields = $this->getCustomTableFields();
        if (empty($custom_fields)) {
            return;
        }

        // Prepare data for insertion/update
        $data = [
            'term_id' => $term_id,
            'name' => html_entity_decode($term->name),
            'slug' => $term->slug,
            'updated_at' => current_time('mysql')
        ];

        // Get meta manager for this term
        $meta = new MetaManager($term_id, 'term');
		$values = $meta->getAll(array_keys($custom_fields));

        // Process each custom field
        foreach ($custom_fields as $field_name => $field_config) {
            $value = $values[$field_name];
            // Handle different field types
            $data = $this->processFieldForCustomTable($data, $field_name, $value, $field_config);
        }

        foreach ($data as $k => $v) {
            switch ($v) {
                case 0:
                case '':
                case false:
                    $data[$k] = null;
                    break;
            }
        }

        // Check if record exists
        $exists = $wpdb->get_var($wpdb->prepare(
            "SELECT COUNT(*) FROM {$table} WHERE term_id = %d",
            $term_id
        ));

        if ($exists) {
            // Update existing record
            $wpdb->update($table, $data, ['term_id' => $term_id]);
        } else {
            // Insert new record
            $wpdb->insert($table, $data);
        }
    }

    /**
     * Process a field value for storage in custom table
     * @param array $data Current data array
     * @param string $field_name Field name
     * @param mixed $value Field value
     * @param array $field_config Field configuration
     * @return array Updated data array
     */
    protected function processFieldForCustomTable(array $data, string $field_name, $value, array $field_config): array
    {
        $field_type = $field_config['type'] ?? 'text';

        switch ($field_type) {
            case 'location':
                // Handle location fields - they create multiple columns
                if (is_array($value)) {
                    $data["{$field_name}_address"] = $value['address'] ?? '';
                    $data["{$field_name}_lat"] = (float)($value['lat'] ?? 0);
                    $data["{$field_name}_lng"] = (float)($value['lng'] ?? 0);
                    $data["{$field_name}_street"] = $value['street'] ?? '';
                    $data["{$field_name}_city"] = $value['city'] ?? '';
                    $data["{$field_name}_province"] = $value['province'] ?? '';
                    $data["{$field_name}_postal_code"] = $value['postal_code'] ?? '';
                    $data["{$field_name}_country"] = $value['country'] ?? '';
                }
                break;

            case 'taxonomy':
                // Handle taxonomy references
                $limit = $field_config['limit'] ?? null;
                if ($limit === 1) {
                    // Single selection - store as integer
                    $data[$field_name] = is_array($value) ? (int)($value[0] ?? 0) : (int)$value;
                } else {
                    // Multiple selections - store as JSON
                    $data[$field_name] = is_array($value) ? json_encode(array_map('intval', $value)) : $value;
                }
                break;

            case 'user':
                // Handle user references
                $limit = $field_config['limit'] ?? null;
                if ($limit === 1) {
                    $data[$field_name] = is_array($value) ? (int)($value[0] ?? 0) : (int)$value;
                } else {
                    $data[$field_name] = is_array($value) ? json_encode(array_map('intval', $value)) : (int)$value;
                }
                break;

            case 'repeater':
            case 'gallery':
            case 'set':
            case 'checkbox':
                // Store complex data as JSON
                $data[$field_name] = is_array($value) ? json_encode($value) : $value;
                break;

            case 'image':
            case 'file':
                // Store attachment ID
                $data[$field_name] = (int)$value;
                break;

            case 'number':
                $data[$field_name] = (int)$value;
                break;

            case 'true_false':
                $data[$field_name] = (bool)$value;
                break;

            default:
                // Store as string for text, textarea, email, url, etc.
                $data[$field_name] = (string)$value;
                break;
        }

        return $data;
    }

    /**
     * Get custom table fields for this taxonomy
     * @return array Field definitions
     */
    protected function getCustomTableFields():array
    {
        return jvbContentTaxonomiesTableFields($this->slug)['fields'] ?? [];
    }
}