<?php
namespace JVBase\integrations;

use JVBase\managers\queue\executors\IntegrationExecutor;
use JVBase\managers\queue\mergers\DefaultMerger;
use JVBase\managers\queue\TypeConfig;
use JVBase\meta\Meta;
use WP_Query;

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

trait SyncHelpers {
	use _Base;
	/**
	 * Queue types
	 * These types match with IntegrationExecutor
	 */
	protected static string $syncTo;
	protected static string $deleteFrom;
	protected static string $syncFrom;
	protected static string $syncCustomer;
	protected static string $import;


	protected function setQueueTypes():void
	{
		self::$syncTo = $this->service_name.'_sync_to';
		self::$deleteFrom = $this->service_name.'_delete_from';
		self::$syncFrom = $this->service_name.'_sync_from';
		//TODO: What is the difference between sync_from and import?
		self::$import = $this->service_name.'import_from';
	}

	public function getServiceItemID(int $itemID, string $type = 'post'):string
	{
		return match($type) {
			'post'	=> Meta::forPost($itemID)->get("_{$this->service_name}_item_id"),
			'term','taxonomy'	=> Meta::forTerm($itemID)->get("_{$this->service_name}_item_id"),
			'user'	=> Meta::forUser($itemID)->get("_{$this->service_name}_item_id"),
			default => ''
		};
	}
	protected function updateItemStatus(int|array $items, string $status = 'pending', string $type = 'post'):void
	{
		if (!is_array($items)) {
			$items = [$items];
		}
		foreach ($items as $ID) {
			match ($type) {
				'post'	=> Meta::forPost($ID)->set('_'.$this->service_name.'_sync_status', $status),
				'term'	=> Meta::forTerm($ID)->set('_'.$this->service_name.'_sync_status', $status),
				'user'	=> Meta::forUser($ID)->set('_'.$this->service_name.'_sync_status', $status),
				default => false
			};
		}
	}


	public function findWPItem(string $integrationID, ?string $type = null):array|false
	{
		if (empty($integrationID)) {
			error_log('Integrations::findWPItem No Integration ID received.');
			return false;
		}
		$types = ['post', 'term', 'user'];
		if (!is_null($type) && !in_array($type, $types)) {
			error_log('Integrations::findWPItem invalid type sent: '.$type.'; defaulting to checking all');
			$type = null;
		}
		if (!is_null($type)) {
			return $this->queryWPType($integrationID, $type);
		} else {
			foreach ($types as $type) {
				$check = $this->queryWPType($integrationID, $type);
				if ($check) {
					return $check;
				}
			}
		}
		return false;
	}

	/**
	 * @param string $integrationID
	 * @param string|null $type
	 * @return array|false if success, an array of $ID and $type
	 */
	public function queryWPType(string $integrationID, ?string $type = null):array|false
	{
		if (!in_array($type, ['post', 'term', 'user'])) {
			return $this->findWPItem($integrationID);
		}
		return match($type) {
			'post'	=> $this->findWPPost($integrationID),
			'term'	=> $this->findWPTerm($integrationID),
			'user'	=> $this->findWPUser($integrationID),
			default => false
		};
	}
	public function findWPPost(string $integrationID):array|false
	{
		if (empty($integrationID)) {
			return false;
		}
		$get = new WP_Query([
			'meta_query'	=> [
				'key'	=> BASE."_{$this->service_name}_item_id",
				'value'	=> $integrationID,
			],
			'fields'	=> 'ids',
			'posts_per_page' => 1,
		]);
		return $get->have_posts() && !empty($get->posts) ? [$get->posts[0], 'post'] : false;
	}
	public function findWPTerm(string $integrationID):array|false
	{
		if (empty($integrationID)) {
			return false;
		}
		$get = get_terms([
			'meta_query'	=> [
				'key'	=> BASE."_{$this->service_name}_item_id",
				'value'	=> $integrationID,
			],
			'fields'	=> 'ids',
			'hide_empty'=> true,
			'number'	=> 1
		]);
		return is_wp_error($get) || empty($get) ? false : [$get[0], 'term'];
	}
	public function findWPUser(string $integrationID):array|false
	{
		if (empty($integrationID)) {
			return false;
		}
		$get = get_users([
			'meta_query'	=> [
				'key'	=> BASE."_{$this->service_name}_item_id",
				'value'	=> $integrationID,
			],
			'fields'	=> 'ids',
			'number'	=> 1,
		]);
		return is_wp_error($get) || empty($get) ? false : [$get[0], 'user'];
	}

	public function registerQueueTypes():void
	{
		if (empty($this->syncTaxonomies) && empty($this->syncPostTypes)) {
			return;
		}
		$queue = JVB()->queue();
		$executor = new IntegrationExecutor();

		$queue->registry()->register(self::$syncTo, new TypeConfig(
			mergeable: new DefaultMerger('items'),
			executor: $executor,
			chunkKey: 'items',
			chunkSize: 50,
			maxRetries: 3,
		));

		if ($this->canSync['delete']) {
			$queue->registry()->register(self::$deleteFrom, new TypeConfig(
				mergeable: new DefaultMerger('external_ids'),
				executor: $executor,
				chunkKey: 'external_ids',
				chunkSize: 200,
				maxRetries: 2
			));
		}

		$queue->registry()->register(self::$syncFrom, new TypeConfig(
			executor: $executor,
			maxRetries: 3
		));

		$this->registerAdditionalQueueTypes($executor);
	}

	/**
	 * Empty. Integration extensions can register additional operation types here
	 * @param IntegrationExecutor $executor
	 * @return void
	 */
	protected function registerAdditionalQueueTypes(IntegrationExecutor $executor):void	{}

	/**
	 * @return void Sets the $this->contentTypes, which is an array of TYPE => [$fields]
	 * Should probably set the endpoints here as well, which would be an array of [ TYPE => [ 'create' => '','update' =>'', 'delete'=>'', 'batchCreate'=>'','batchUpdate'=>'', 'batchDelete'=>''] endpoints
	 */
	abstract protected function setContentTypes():void;
}