<?php

namespace JVBase\rest\routes;

use JVBase\managers\queue\executors\ContentExecutor;
use JVBase\managers\queue\TypeConfig;
use JVBase\meta\Meta;
use JVBase\registrar\Registrar;
use JVBase\rest\PermissionHandler;
use JVBase\rest\Response;
use JVBase\rest\Rest;
use JVBase\rest\Route;
use WP_Post;
use WP_Query;
use WP_REST_Request;
use WP_REST_Response;
use WP_Term;
use WP_Term_Query;

if (!defined('ABSPATH')) {
	exit; // Exit if accessed directly
}

class ContentRoutes extends Rest
{
	protected array $fields = [];
	protected array $taxonomies = [];
	protected string $post_type = '';
	protected string $user_id = '';

	//For Timeline-specific posts
	protected array $timelineSharedFields = [];
	protected array $timelineUniqueFields = [];
	protected static ?string $action = 'dash-';
	protected Meta $meta;

	public function __construct()
	{
		$this->cacheName = 'user_content_' . get_current_user_id();
		parent::__construct();
		if (JVB_TESTING) {
			$this->cache->flush();
		}
		$this->cache->connect('post', true);
		$this->cache->connect('term', true);
		add_action('init', [$this, 'registerContentExecutors'], 5);
	}

	/**
	 * Register content operation types with the queue's TypeRegistry
	 */
	public function registerContentExecutors(): void
	{
		$registry = JVB()->queue()->registry();
		$executor = new ContentExecutor();

		// Content updates - chunked at 10 posts
		$registry->register('content_update', new TypeConfig(
			executor: $executor,
			chunkKey: 'posts',
			chunkSize: 10
		));

		// Batch creation (from uploads) TODO: I believe this is all handled by UploadExecutor
//		$registry->register('batch_creation', new TypeConfig(
//			executor: $executor
//		));
	}

	/**
	 * Registers content routes
	 * @return void
	 */
	public function registerRoutes(): void
	{
		Route::for('content')
			->get([$this, 'getContent'])
			->auth(PermissionHandler::combine(['user', 'nonce', ['actionNonce'=>'dash-']]))
			->args([
				'content' => 'string|required',
				'status' => 'string|default:all',
				'page' => 'integer|default:1|min:1',
				'per_page' => 'integer|default:30|min:1|max:100',
				'orderby' => 'string|enum:date,alphabetical|default:date',
				'order' => 'string|enum:asc,desc|default:desc',
				'search' => 'string',
				'date-filter' => 'string',
				'dateFrom' => 'string',
				'dateTo' => 'string',
			])
			->rateLimit(20)
			->post([$this, 'postContent'])
			->auth(PermissionHandler::combine(['user', 'nonce', ['actionNonce'=>'dash-']]))
			->rateLimit(30)
			->args([
				'user'	=> 'int|required',
				'posts' => 'required',
				'content' => 'string',
			])
			->register();
	}

	protected function initTimelineFields(string $content): void
	{
		$content = jvbNoBase($content);

		$config = Registrar::getInstance($content);
		if (!$config || !$config->hasFeature('is_timeline')) {
			return;
		}
		$this->fields = $config->getFields();

		$this->timelineSharedFields = $this->getTimelineSharedFields($content);
		array_unshift($this->timelineSharedFields, 'post_thumbnail');
		array_unshift($this->timelineSharedFields, 'post_title');
		array_unshift($this->timelineSharedFields, 'post_status');

		$this->timelineUniqueFields = $this->getTimelineUniqueFields($content);
	}

	public function getTimelineUniqueFields(string $content): array
	{
		$content = jvbNoBase($content);
		$registrar = Registrar::getInstance($content);
		if (!$registrar || !$registrar->hasFeature('is_timeline')) {
			return [];
		}

		$allFields = $registrar->getFields();

		return array_keys(array_filter($allFields, function ($field) {
			if (array_key_exists('for_all', $field) && $field['for_all'] === true) {
				return true;
			}
			return false;
		}));
	}

	public function getTimelineSharedFields(string $content): array
	{
		$content = jvbNoBase($content);
		$registrar = Registrar::getInstance($content);
		if (!$registrar || !$registrar->hasFeature('is_timeline')) {
			return [];
		}

		$allFields = $registrar->getFields()??[];

		return array_keys(array_filter($allFields, function ($field) {
			if (!array_key_exists('for_all', $field) || $field['for_all'] === false) {
				return true;
			}
			return false;
		}));
	}

	/**
	 * Handle content update/creation
	 * @param WP_REST_Request $request
	 *
	 * @return WP_REST_Response
	 */
	public function postContent(WP_REST_Request $request): WP_REST_Response
	{
		$data = $request->get_params();
		$user_id = $data['user'];

		if (!array_key_exists('posts', $data) || !is_array($data['posts'])) {
			return Response::success(['message'=>'No posts found in request']);
		}


		$count = count($data['posts']);
		$operationId = $data['id'];
		unset($data['user']);
		unset($data['id']);

		error_log('[CONTENT]:'.print_r($data, true));
		$queue = JVB()->queue();
		$queue->queueOperation(
			'content_update',
			$user_id,
			$data,
			[
				'operation_id' => $operationId
			]
		);

		return Response::queued($operationId);
	}


	/**
	 * Handle request
	 * @param WP_REST_Request $request
	 *
	 * @return WP_REST_Response
	 */
	public function getContent(WP_REST_Request $request): WP_REST_Response
	{
		$params = $request->get_params();
		error_log('getContent::params '.print_r($params, true));

		$registrar = Registrar::getInstance($params['content']);
		switch ($registrar->getType()) {
			case 'term':
				return $this->getTerms($request, $params, $registrar);
			case 'user':
				//TODO maybe do something?
				break;
			case 'post':
				return $this->getPosts($request, $params, $registrar);
		}

		return $this->error('Something went wrong, this does not appear to have a proper content type');
	}

	public function getPosts(WP_REST_Request $request, array $params, Registrar $registrar):WP_REST_Response
	{
		$user_id = $params['user'];

		$post_status = $params['status'];
		if ($post_status === 'all') {
			$post_status = ['publish', 'draft'];
		} else {
			$post_status = explode(',', $post_status);
		}
		$post_type = str_replace('-', '_', jvbCheckBase($params['content']));

		// Build query args
		$args = [
			'post_type' => $post_type,
			'posts_per_page' => $params['per_page'] ?? 30,
			'paged' => $params['page'],
			'orderby' => 'date',
			'order' => 'DESC',
			'author' => $user_id,
			'post_status' => $post_status
		];


		//Only top level posts for timeline types
		if ($registrar?->hasFeature('is_timeline')) {
			$args['post_parent'] = 0;
		}

		//Calendar filters
		if ($registrar?->hasFeature('is_calendar')) {
			$args = $this->applyCalendarFilters($args, $params);
		}
		$taxonomies = array_filter($params, function ($param) {
			return str_starts_with($param, 'tax_');
		}, ARRAY_FILTER_USE_KEY);
		if (!empty($taxonomies)) {
			$params['taxonomies'] = [];
			foreach ($taxonomies as $taxonomy => $terms) {
				$taxonomy = str_replace('tax_', '', $taxonomy);
				$params['taxonomies'][$taxonomy] = $terms;
			}
		}
		if (array_key_exists('taxonomies', $params)) {
			$args = $this->applyTaxonomyFilters($args, $params);
		}
		if (array_key_exists('date-filter', $params) || array_key_exists('dateFrom', $params)) {
			$args = $this->applyDateFilters($args, $params);
		}
		if (array_key_exists('orderby', $params) || array_key_exists('order', $params)) {
			$args = $this->applyOrderFilters($args, $params);
		}

		if (array_key_exists('search', $params)) {
			$args['s'] = sanitize_text_field($params['search']);
		}

		$key = $this->cache->generateKey($args);
		$cached = $this->checkCache($key, $request);
		if ($cached) {
			return $cached;
		}

		$this->post_type = jvbCheckBase($params['content'] ?? $params['type']);

		if (array_key_exists('s', $args)) {
			$args = $this->applySearchFilters($args, $params);
		}

		// Run query
		$query = new WP_Query($args);

		$registrar = Registrar::getInstance($this->post_type);
		$this->fields = $registrar->getFields()??[];
		$this->taxonomies = $this->getTaxonomies($this->post_type);

		$posts = array_map([$this, 'preparePost'], $query->posts);

		$data = [
			'items' => $posts,
			'total' => $query->found_posts,
			'total_pages' => $query->max_num_pages,
			'has_more'	=> $args['paged']??1 < $query->max_num_pages,
		];


		$this->cache->set($key, $data);

		$response = Response::success($data);
		return $this->addCacheHeaders($response);
	}
	public function getTerms(WP_REST_Request $request, array $params, Registrar $registrar):WP_REST_Response
	{
		// Build query args
		$args = [
			'taxonomy' 		=> jvbCheckBase($params['content']),
			'number'		=> $params['per_page'] ?? 30,
			'orderby' 		=> 'name',
			'order' 		=> 'DESC',
			'hide_empty'	=> false,
		];
		$paged = $params['page']??1;
		$args['page'] = $paged;
		if ($paged > 1) {
			$args['offset'] = ($paged-1) * $args['number'];
		}

		//TODO
//		if (array_key_exists('taxonomies', $params)) {
//			$args = $this->applyTaxonomyFilters($args, $params);
//		}
//		if (array_key_exists('date-filter', $params) || array_key_exists('dateFrom', $params)) {
//			$args = $this->applyDateFilters($args, $params);
//		}
		if (array_key_exists('orderby', $params) || array_key_exists('order', $params)) {
			$args = $this->applyOrderFilters($args, $params);
		}

		if (array_key_exists('search', $params)) {
			$args['s'] = sanitize_text_field($params['search']);
		}

		$key = $this->cache->generateKey($args);
		// Check HTTP cache headers with the specific content type
		$cache_check = $this->checkHeaders($request, $key);
		if ($cache_check) {
			return $cache_check;
		}

		$cache = $this->cache->get($key);
		if ($cache) {
			$response = Response::success($cache);
			return $this->addCacheHeaders($response);
		}
		$this->post_type = jvbCheckBase($params['content'] ?? $params['type']);
		// Only expand search to taxonomies if we're actually going to query
		if (array_key_exists('s', $args)) {
			$args = $this->applySearchFilters($args, $params);
		}

		// Run query
		$query = new WP_Term_Query($args);

		$terms = $query->get_terms();
		$data = [
			'total'			=> 0,
			'total_pages' 	=> 0,
			'has_more' 		=> false
		];

		if (!is_wp_error($terms) && !empty($terms))
		{
			$total = get_terms([
				'taxonomy'		=> $args['taxonomy'],
				'hide_empty'	=> false,
				'fields'		=> 'count'
			]);
			$data['total'] = $total;
			$data['total_pages'] = max($total/$args['number'], 1);
			$data['has_more'] = ($args['page'] * $args['number']) < $total;
		} else {
			$terms = [];
		}

		$this->fields = $registrar->getFields()??[];

		$this->taxonomies = [];
		$data['items'] =array_map([$this, 'prepareTerm'], $terms);

		$this->cache->set($key, $data);

		$response = Response::success($data);
		return $this->addCacheHeaders($response);
	}

	protected function applySearchFilters(array $args, array $params): array
	{
		$search_term = sanitize_text_field($params['search']);

		// Search term is already in $args['s'] from earlier

		// Get all taxonomies registered to this post type
		$taxonomies = get_object_taxonomies($this->post_type, 'names');

		if (empty($taxonomies)) {
			return $args;
		}

		// Cache the taxonomy term lookup per search term + post type
		$term_cache_key = 'search_terms_' . md5($search_term . $this->post_type);
		$matching_term_ids = $this->cache->get($term_cache_key);

		if ($matching_term_ids === false) {
			$matching_term_ids = [];

			foreach ($taxonomies as $taxonomy) {
				$terms = get_terms([
					'taxonomy' => $taxonomy,
					'search' => $search_term,
					'hide_empty' => false,
					'fields' => 'ids'
				]);

				if (!is_wp_error($terms) && !empty($terms)) {
					$matching_term_ids = array_merge($matching_term_ids, $terms);
				}
			}

			// Cache term IDs for 1 hour
			$this->cache->set($term_cache_key, $matching_term_ids, 3600);
		}

		if (empty($matching_term_ids)) {
			return $args;
		}

		// Build tax_query for matching terms
		$term_queries = [];

		foreach ($taxonomies as $taxonomy) {
			$taxonomy_term_ids = array_filter($matching_term_ids, function ($term_id) use ($taxonomy) {
				$term = get_term($term_id);
				return !is_wp_error($term) && $term->taxonomy === $taxonomy;
			});

			if (!empty($taxonomy_term_ids)) {
				$term_queries[] = [
					'taxonomy' => $taxonomy,
					'field' => 'term_id',
					'terms' => array_values($taxonomy_term_ids),
					'operator' => 'IN'
				];
			}
		}

		if (!empty($term_queries)) {
			if (isset($args['tax_query'])) {
				$args['tax_query'] = [
					'relation' => 'OR',
					$args['tax_query'],
					[
						'relation' => 'OR',
						...$term_queries
					]
				];
			} else {
				$args['tax_query'] = [
					'relation' => 'OR',
					...$term_queries
				];
			}
		}

		return $args;
	}

	/**
	 * Gets allowed taxonomies for a particular content
	 * @param string $content
	 *
	 * @return array
	 */
	protected function getTaxonomies(string $content): array
	{
		$registrar = Registrar::getInstance($content);
		if (!$registrar || $registrar->getType()!== 'post') {
			return [];
		}
		$out = [];
		foreach ($registrar->registrar->taxonomies as $tax) {
			$taxReg = Registrar::getInstance($tax);
			$out[jvbCheckBase($tax)] = [
				'label'	=> $taxReg->getPlural(),
				'icon'	=> $taxReg->getIcon()??jvbDefaultIcon()
			];
		}

		return $out;
	}


	/**
	 * Generates a post title, based on content type
	 * @param string $content the post type
	 *
	 * @return string
	 */
	protected function generatePostTitle(string $content): string
	{
		$username = get_user_meta($this->user_id, 'first_name', true);
		$link = get_user_meta($this->user_id, BASE . 'link', true);
		$city = jvbArtistCity($link);
		return ucfirst($content) . ' by ' . $city . ' artist ' . $username;
	}

	/**
	 * @param WP_Post $post the post object
	 *
	 * @return array
	 */
	protected function preparePost(WP_Post $post, bool $skip = false, bool $fields = true): array
	{
		$registrar = Registrar::getInstance($post->post_type);
		if (!$skip && $registrar && $registrar->hasFeature('is_timeline')) {
			$this->initTimelineFields($post->post_type);
			return $this->formatTimeline($post);
		}
		$this->meta = Meta::forPost($post->ID);
		$fields = ($fields) ? $this->meta->getAll() : [];
		$data = [
			'id' => $post->ID,
			'title' => $post->post_title,
			'status' => $post->post_status,
			'date' => $post->post_date,
			'modified' => $post->post_modified,
			'thumbnail' => get_the_post_thumbnail_url($post->ID),
			'alt' => get_post_meta(get_post_thumbnail_id(), '_wp_attachment_image_alt', true),
			'icon' => $this->post_type,
			'taxonomies' => [],
			'fields' => $fields,
			'images' => [],
		];

		$images = $this->extractImages($fields, $this->meta);
		if (!empty($images)) {
			$data['images'] = $images;
		}


		$taxonomies = $this->extractTerms($fields, $this->meta);
		if (!empty($taxonomies)) {
			$data['taxonomies'] = $taxonomies;
		}
		return $data;
	}

	/**
	 * @param WP_Term $post the post object
	 *
	 * @return array
	 */
	protected function prepareTerm(WP_Term $post, bool $fields = true): array
	{
		$registrar = Registrar::getInstance($post->taxonomy);

		$this->meta = Meta::forTerm($post->term_id);
		$fields = ($fields) ? $this->meta->getAll() : [];
		$data = [
			'id' => $post->term_id,
			'title' => $post->name,
			'date' => $fields['created_date']??'',
			'modified' => $fields['modified_date']??'',
			'thumbnail' => '',
			'icon' => $registrar->getIcon(),
			'taxonomies' => [],
			'fields' => $fields,
			'images' => [],
		];

		$images = $this->extractImages($fields, $this->meta);
		if (!empty($images)) {
			$data['images'] = $images;
		}

		$taxonomies = $this->extractTerms($fields, $this->meta);
		if (!empty($taxonomies)) {
			$data['taxonomies'] = $taxonomies;
		}

		error_log('Term data: '.print_r($data, true));
		return $data;
	}


	public function formatTimeline(WP_Post $post): array
	{
		$item = $this->preparePost($post, true, false);
		//Step 1: Get the fields that apply to all posts
		$mainMeta = Meta::forPost($post->ID);
		$item['fields'] = $mainMeta->getAll($this->timelineSharedFields);

		//Step 2: Get the fields for each individual posts
		$children = get_children(['post_parent' => $post->ID, 'orderby' => 'date', 'order' => 'ASC', 'post_status' => ['publish', 'draft'], 'fields' => 'ids']);
		array_unshift($children, $post->ID);

		$subFields = [];
		$images = [];
		foreach ($children as $child) {
			$meta = Meta::forPost($child);
			$f = $meta->getAll($this->timelineUniqueFields);
			$f = ['id' => $child] + $f;
			$subFields[] = $f;

			$images[$f['post_thumbnail']] = jvbImageData((int)$f['post_thumbnail']);
		}
		$item['fields']['timeline'] = $subFields;
		$item['images'] = $item['images'] + $images;
		$item['number'] = $mainMeta->get('number');

		return $item;
	}
}