<?php
namespace JVBase\integrations;

use Exception;
use JVBase\meta\Meta;
use JVBase\meta\Sanitizer;
use JVBase\registrar\Registrar;
use WP_Error;
use WP_Post;
use WP_Term;
use WP_User;

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

/**
 * For Syncing to a service, the basic flow is:
 * 1) Queuing an operation
 * 		a) using the $syncTo as the operation type
 * 		b) the $data has:
 * 			i) key of 'posts', 'terms', 'users' depending on the source data
 * 			ii) key of 'user' to set user's specific integration connection, or the site-wide connection
 * 2) IntegrationExecutor then determines if it is a sync to operation
 * 	-> from there, it calls the integrations {action}BatchToService or {create}OneToService
 *
 * Most integrations will just need to set the $hasBatchUpdate, $hasBatchDelete, $hasBatchCreate flags to signal we can condense it into a single request,
 * 	set the formatForService() method if anything deviates from the defaults
 * 	and the endpoint for a particular action
 */
trait SyncTo {
	use SyncHelpers, UserConnection;
	/**
	 * Must be defined according to how each service needs it to be
	 * @param int $itemID
	 * @param string $type
	 * @return array
	 * @throws Exception
	 */
	abstract protected function formatForService(int $itemID, string $type = 'post'):array;

	/**
	 * Defaults to an array of formatted items. Can be overridden in child classes
	 * @param array $itemIDs
	 * @param string $type
	 * @return array Either an array of formatted items, or a single formatted item (if there is 1)
	 */
	protected function formatItems(array $itemIDs, string $type):array
	{
		$items = [];
		foreach ($itemIDs as $ID) {
			try {
				$items[] = $this->formatForService($ID, $type);
			} catch (Exception $e){
				$this->logError('formatItems', 'Could not format Item for service',[
					'itemID' => $ID,
					'type'	=> $type,
					'message'	=> $e->getMessage(),
				]);
			}
		}
		return count($items) === 1 ? $items[0] : $items;
	}

	protected function determineType(array $data):string|false
	{
		$type = false;
		if (array_key_exists('posts', $data)) {
			$type = 'post';
		} else if (array_key_exists('terms', $data)) {
			$type = 'term';
		} else if (array_key_exists('users', $data)) {
			$type = 'user';
		}
		return $type;
	}
	/***************************************************************
	 * Item creation
	***************************************************************/
	public function createBatchToService($data):array
	{
		$type = $this->determineType($data);

		if (!$type) {
			$this->logError('createBatchToService', 'No expected keys in data', ['data' => $data]);
			return $this->noCreatedItems([]);
		}

		//Check if any of the submitted ids are already created
		$created = array_filter($data['items'],
			function($ID) use ($type) {
				return !empty($this->getServiceItemID($ID, $type));
			});

		$updated = [];
		if (!empty($created)) {
			$updateData = $data;
			$updateData['items'] = $created;
			$updated = $this->updateBatchToService($data);

			//remove any updated items from the original items to process
			$data['items'] = array_filter($data['items'], function ($ID) use ($created) {
				return !in_array($ID, $created);
			});
		}

		$items = $this->formatItems($data['items'], $type);
		if (empty($items)) {
			return $this->noCreatedItems($updated);
		}

		if ($this->hasBatchCreate) {
			$response = $this->sendBatchCreate($items);
			if (!is_wp_error($response)) {
				$result = $this->processBatchCreateResponse($data, $response);
			} else {
				$this->logError('createBatchToService','Batch create failed',[
					'method'	=> 'createBatchToService',
					'item_ids'	=> $data['items'],
					'error'		=> $response
				]);
				$this->updateItemStatus($data['items'], 'error');

				$result = [
					'outcome'	=> 'failed_permanent',
					'result'	=> 'Could not update items'
				];
			}
		} else {
			$success = $errors = [];
			foreach ($items as $item) {
				$itemResult = $this->createOneToService($item);
				if (!is_wp_error($itemResult)) {
					$success[] = $itemResult;
				} else {
					$errors[] = $itemResult;
				}
			}
			$result = [
				'outcome'	=> empty($errors) ? 'success' : (empty($success) ? 'failed' : 'partial'),
				'result'	=> [
					'success'	=> $success,
					'errors'	=> $errors
				]
			];
		}

		return array_merge($result, $updated);
	}

	/**
	 * To be implemented by integration extension. Updates a single item
	 * @param array $item
	 * @return array|WP_Error
	 */
	protected function createOneToService(array $item):array|WP_Error
	{
		return new WP_Error('invalid', 'Integration '.$this->service_name.' must implement its own createOneToService');
	}

	/**
	 * Overridden by child classes
	 * @param array $items
	 * @return array|WP_Error
	 */
	protected function sendBatchCreate(array $items):array|WP_Error
	{
		return new WP_Error('invalid', 'Integration '.$this->service_name.' must implement its own sendBatchCreate');
	}

	/**
	 * To be implemented by extensions
	 * @param array $data
	 * @param array $response
	 * @return array
	 */
	protected function processBatchCreateResponse(array $data, array $response):array
	{
		return [
			'outcome'	=> 'failed',
			'result'	=> [
				'message'	=> $this->service_name.' should implement processBatchCreateResponse.'
			]
		];
	}

	/*****************************************************************
	 * ITEM UPDATING
	*****************************************************************/
	public function updateBatchToService(array $data):array
	{
		$type = $this->determineType($data);

		if (!$type) {
			$this->logError('createBatchToService', 'No expected keys in data', ['data' => $data]);
			return $this->noUpdatedItems([]);
		}

		$newlyCreated = [];
		if (!$this->canCreateOnUpdate) {
			$created = array_filter($data['items'], function($ID) use ($type) {
				return !empty($this->getServiceItemID($ID, $type));
			});

			//Test to see if we have any that haven't been created yet.
			//For some services, items may have to be created before they can be updated
			if (count($created) !== count($data['items'])) {
				$notCreated = array_filter($data['items'], function($ID) use ($type) {
					return empty($this->getServiceItemID($ID, $type));
				});
				$newData = $data;
				$newData['items'] = $notCreated;
				$newlyCreated = $this->createBatchToService($newData);
			}

			// If we don't have any that are created, just send the noUpdatedItems response, with any newly created items added
			if (empty($created)) {
				return $this->noUpdatedItems($newlyCreated);
			}
			$data['items'] = $created;
		}


		$items = $this->formatItems($data['items'], $type);

		if (empty($items)) {
			return $this->noUpdatedItems($newlyCreated);
		}

		if ($this->hasBatchUpdate) {
			$response = $this->sendBatchUpdate($items);
			if (!is_wp_error($response)) {
				$result = $this->processBatchUpdateResponse($data, $response);
			} else {
				$this->logError('updateBatchToService','Batch update failed',[
					'method'	=> 'updateBatchToService',
					'item_ids'	=> $data['items'],
					'error'		=> $response
				]);
				$this->updateItemStatus($data['items'], 'error');

				$result = [
					'outcome'	=> 'failed_permanent',
					'result'	=> 'Could not update items'
				];
			}
		} else {
			$success = $errors = [];
			//Does not have batch update, manually update each one
			foreach ($items as $item) {
				$itemResult = $this->updateOneToService($item);
				if (!is_wp_error($itemResult)) {
					$success[] = $itemResult;
				} else {
					$errors[] = $itemResult;
				}
			}

			$result = [
				'outcome'	=> empty($errors) ? 'success' : (empty($success) ? 'failed' : 'partial'),
				'result'	=> [
					'success'	=> $success,
					'errors'	=> $errors
				]
			];
		}

		return array_merge($result, $newlyCreated);
	}

	/**
	 * To be implemented by integration extension. Updates a single item
	 * @param array $item
	 * @return array|WP_Error
	 */
	protected function updateOneToService(array $item):array|WP_Error
	{
		return new WP_Error('invalid', 'Integration '.$this->service_name.' must implement its own updateOneToService method');
	}

	/**
	 * Overridden by child classes
	 * @param array $items
	 * @return array|WP_Error
	 */
	protected function sendBatchUpdate(array $items):array|WP_Error
	{
		return new WP_Error('invalid', 'Integration '.$this->service_name.' must implement its own sendBatchUpdate');
	}


	/**
	 * To be implemented by extensions
	 * @param array $data
	 * @param array $response
	 * @return array
	 */
	protected function processBatchUpdateResponse(array $data, array $response):array
	{
		return [
			'outcome'	=> 'failed',
			'result'	=> [
				'message'	=> $this->service_name.' should implement processBatchUpdateResponse.'
			]
		];
	}

	public function deleteOneToService(array $item):array|WP_Error
	{
		return new WP_Error('invalid', 'Integration '.$this->service_name.' must implement its own deleteOneToService');
	}
	public function sendBatchDelete(array $items):array|WP_Error
	{
		return new WP_Error('invalid', 'Integration '.$this->service_name.' must implement its own sendBatchDelete');
	}

	public function deleteBatchToService(array $data):array
	{
		$type = $this->determineType($data);

		if (!$type) {
			$this->logError('createBatchToService', 'No expected keys in data', ['data' => $data]);
			return $this->noCreatedItems([]);
		}

		//Check if any submitted ids do not have an integration item ID
		$notCreated = array_filter($data['items'],
		function($ID) use ($type) {
			return empty($this->getServiceItemID($ID, $type));
		});
		if (!empty($notCreated)) {
			$this->logError('deleteBatchToService','Could not delete items',['items' => $notCreated]);
		}

		$created = array_filter($data['items'],
		function($ID) use ($type) {
			return !empty($this->getServiceItemID($ID, $type));
		});

		if ($this->hasBatchDelete) {
			$result = $this->sendBatchDelete($created);
		} else {
			$errors = $success = [];
			foreach ($created as $item) {
				try {
					$success[] = $this->deleteOneToService($item);
				} catch (Exception $e) {
					$errors[] = $e->getMessage();
				}
			}

			$result = [
				'outcome'	=> empty($errors) ? 'success' : (empty($success) ? 'failed' : 'partial'),
				'result'	=> [
					'success'	=> $success,
					'errors'	=> $errors
				]
			];
		}
		return $result;
	}

	/*****************************************************************
	 * UTILITY
	*****************************************************************/
	protected function noUpdatedItems(array $created):array
	{
		$result =  [
			'outcome'	=> 'success',
			'result'	=> [
				'message'	=> 'No items to update',
				'updated'	=> [],
				'errors'	=> [],
			]
		];

		if (!empty($created)) {
			error_log('Result before: '.print_r($result, true));
			$result = array_merge($result, $created);
			error_log('Result after merge: '.print_r($result, true));
		}
		return $result;
	}

	protected function noCreatedItems(array $updated):array
	{
		$result = [
			'outcome'	=> 'success',
			'result'	=> [
				'message'	=> 'No items to create',
				'created'	=> [],
				'errors'	=> [],
			]
		];
		if (!empty($updated)) {
			$result = array_merge($result, $updated);
		}
		return $result;
	}

	/****************************************************************
	 * UTILITY
	****************************************************************/
	protected function getSyncFields(int $itemID, string $type, array $additionalFields = []):array
	{
		$meta = match ($type) {
			'post'	=> Meta::forPost($itemID),
			'term'	=> Meta::forTerm($itemID),
			'user'	=> Meta::forUser($itemID),
			default => false
		};
		if (!$meta) {
			return [];
		}

		$content = match ($type) {
			'post'	=> get_post_type($itemID),
			'term'	=> get_term($itemID)?->taxonomy,
			'user'	=> jvbUserRole($itemID)
		};
		$registrar = Registrar::getInstance($content);
		if ($registrar) {
			$additional = $this->getAdditionalFields($registrar->getIntegration($this->service_name)->getContentType());
			$additional = array_combine(
				array_map(fn($k) => str_starts_with($k, '_'.$this->service_name) ? $k : "_{$this->service_name}_{$k}", array_keys($additional)),
				$additional
			);
			$additionalFields = array_merge($additionalFields, $additional);
		}


		$fields =  [
			'share_to_' . $this->service_name,
			'_keep_synced_' . $this->service_name,
			"_{$this->service_name}_item_id",
			"_{$this->service_name}_last_sync",
			"_{$this->service_name}_shared_at",
			"_{$this->service_name}_sync_status",
			"_{$this->service_name}_scheduled_at",
			... $additionalFields
		];
		return $meta->getAll($fields);
	}
}