<?php
namespace JVBase\managers;

use JVBase\registrar\Registrar;

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

	protected CustomTable $favourites;
	protected CustomTable $lists;
	protected CustomTable $listItems;
	protected CustomTable $listShares;

	public function __construct()
	{
		$this->defineTables();
	}

	protected function defineTables():void
	{
		$this->defineFavouriteTable();
		$this->defineListTable();
		$this->defineListItemsTable();
		$this->defineListSharesTable();
	}
		private function defineFavouriteTable():void
		{
			$table = CustomTable::for('favourites');

			$table->setColumns([
				'id'		=> 'bigint(20) unsigned NOT NULL AUTO_INCREMENT',
				'user_id'	=> "{$table->getUserIDType()} NOT NULL",
				'type'		=> 'varchar(50) NOT NULL', 					//As in, post type/user/taxonomy
				'target_id'	=> 'bigint(20) unsigned NOT NULL',
				'notes'		=> 'text DEFAULT NULL',
				'created_at'	=> 'datetime DEFAULT CURRENT_TIMESTAMP',
				'updated_at'	=> 'datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP',
			]);

			$table->setKeys([
				['key' => 'PRIMARY', 'value' => '(`id`)'],
				['key' => 'UNIQUE', 'value' => '`unique_favourite` (`user_id`, `type`, `target_id`)'],
				'`user_type` (`user_id`, `type`)',
				'`target_type` (`target_id`, `type`)'
			]);
			$base = BASE;
			$table->setConstraints([
				"CONSTRAINT `{$base}favourites_user` FOREIGN KEY (`user_id`)
				REFERENCES `{$table->getUserTable()}` (`ID`) ON DELETE CASCADE"
			]);

			$table->defineTable();
			$this->favourites = $table;
		}
		private function defineListTable():void
		{
			$table = CustomTable::for('favourites_lists');

			$table->setColumns([
				'id'		=> 'bigint(20) unsigned NOT NULL AUTO_INCREMENT',
				'user_id'	=> "{$table->getUserIDType()} NOT NULL",
				'name'		=> 'varchar(255) NOT NULL',
				'description'=> 'text',
				'notes'		=> 'JSON DEFAULT (\'{}\')',
				'created_at'=> 'datetime NOT NULL DEFAULT CURRENT_TIMESTAMP',
				'updated_at'=> 'datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP',
			]);

			$table->setKeys([
				['key' => 'PRIMARY', 'value' => '(`id`)'],
				'`user_lists` (`user_id`)'
			]);
			$base = BASE;
			$table->setConstraints([
				"CONSTRAINT `{$base}favourites_list_user` FOREIGN KEY (`user_id`)
				REFERENCES `{$table->getUserTable()}` (`ID`) ON DELETE CASCADE"
			]);

			$table->defineTable();
			$this->lists = $table;
		}
		private function defineListItemsTable():void
		{
			$table = CustomTable::for('favourites_list_items');

			$table->setColumns([
				'id'		=> 'bigint(20) unsigned NOT NULL AUTO_INCREMENT',
				'user_id'	=> "{$table->getUserIDType()} NOT NULL",
				'list_id'	=> 'bigint(20) unsigned NOT NULL',
				'item_type'	=> 'varchar(50) NOT NULL',
				'target_id'	=> 'bigint(20) unsigned NOT NULL',
				'favourite_id'=> 'bigint(20) unsigned NOT NULL',
				'notes'		=> 'JSON DEFAULT (\'{}\')',
				'added_at'	=> 'datetime NOT NULL DEFAULT CURRENT_TIMESTAMP',
			]);

			$table->setKeys([
				['key' => 'PRIMARY', 'value' => '(`id`)'],
				['key' => 'UNIQUE', 'value' => '`unique_list_item` (`list_id`, `item_type`, `target_id`)'],
				'`list_items` (`list_id`)',
				'`favourite_id` (`favourite_id`)'
			]);
			$base = BASE;
			$table->setConstraints([
				"CONSTRAINT `{$base}favourites_list_items_user` FOREIGN KEY (`user_id`)
				REFERENCES `{$table->getUserTable()}` (`ID`) ON DELETE CASCADE",
				"CONSTRAINT `{$base}favourite_list_items` FOREIGN KEY (`list_id`)
				REFERENCES `{$this->lists->getFullTableName()}` (`id`) ON DELETE CASCADE",
				"CONSTRAINT `{$base}list_favourite` FOREIGN KEY (`favourite_id`)
				REFERENCES `{$this->favourites->getFullTableName()}` (`id`) ON DELETE CASCADE"
			]);

			$table->defineTable();
			$this->listItems = $table;
		}
		private function defineListSharesTable():void
		{
			$table = CustomTable::for('favourites_list_shares');

			$table->setColumns([
				'id'			=> 'bigint(20) unsigned NOT NULL AUTO_INCREMENT',
				'list_id'		=> 'bigint(20) unsigned NOT NULL',
				'user_id'		=> "{$table->getUserIDType()} NOT NULL",
				'email'			=> 'varchar(255) NOT NULL',
				'permission'	=> "ENUM('view', 'edit') NOT NULL DEFAULT 'view'",
				'status'		=> "ENUM('pending', 'accepted', 'rejected', 'revoked') NOT NULL DEFAULT 'pending'",
				'created_at'	=> 'datetime NOT NULL DEFAULT CURRENT_TIMESTAMP',
				'updated_at'	=> 'datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP',
			]);

			$table->setKeys([
				['key' => 'PRIMARY', 'value' => '(`id`)'],
				['key'	=> 'UNIQUE', 'value' => '`unique_share_user` (`list_id`, `user_id`)'],
				['key'=> 'UNIQUE', 'value' => '`unique_share_email` (`list_id`, `email`)'],
				'`list_shares` (`list_id`)',
				'`list_user` (`list_id`, `user_id`)',
				'`status_index` (`status`)'
			]);
			$base = BASE;
			$table->setConstraints([
				"CONSTRAINT `{$base}favourites_share_list` FOREIGN KEY (`list_id`)
				REFERENCES `{$this->lists->getFullTableName()}` (`id`) ON DELETE CASCADE",
				"CONSTRAINT `{$base}favourites_share_user` FOREIGN KEY (`user_id`)
				REFERENCES `{$table->getUserTable()}` (`ID`) ON DELETE CASCADE"
			]);

			$table->defineTable();
			$this->listShares = $table;
		}
	public function toggleFavourite(bool $favourite, int $user_id, int $target_id, string $type):bool
	{
		if (!get_userdata($user_id)) {
			error_log('[FAVOURITES]::toggleFavourite Invalid user '.$user_id);
			return false;
		}
		$registrar = Registrar::getInstance($type);
		if (!$registrar) {
			error_log('[FAVOURITES]::toggleFavourite Invalid type: '.print_r($type, true));
			return false;
		}
		$type = jvbCheckBase($type);
		$registerType = $registrar->getType();
		$test = false;
		switch ($registerType) {
			case 'post':
				$test = get_post($target_id);
				break;
			case 'term':
				$test = get_term($target_id, $type);
				break;
			case 'user':
				$test = get_userdata($target_id);
				break;
		}
		if (!$test || is_wp_error($test)) {
			error_log('[FAVOURITES]::toggleFavourite Could not find target: '.$target_id);
			return false;
		}

		$owner = null;
		if ($registrar->getType() === 'post') {
			$post =  get_post($target_id);
			$owner = $post->post_author;
		} elseif ($registrar->hasFeature('is_ownable')) {
			$term = get_term($target_id, jvbCheckBase($type));
			$owner = jvbGetTermOwners($target_id);
		}

		if ($favourite) {
			$result = $this->favourites->findOrCreate(
				[
					'user_id'	=> $user_id,
					'target_id'	=> $target_id,
					'type'		=> $type
				],
			);

			if ($owner) {
				JVB()->notification()->addNotification(
					$owner,
					'new_favourite',
					$user_id,
					'',
					$target_id,
					$type
				);
			}


		} else {
			$result = $this->favourites->delete([
				'user_id'	=> $user_id,
				'target_id'	=> $target_id,
				'type'		=> $type
			]);

			if (in_array($registerType, ['term', 'user'])) {
				JVB()->notification()->deleteUserPreference($user_id, $target_id, $type);
			}
			if ($owner) {
				JVB()->notification()->removeNotification(
					$owner,
					[
						'from_user' => $user_id,
						'target_id' => $target_id,
						'target_type' => $type
					]
				);
			}
		}
		return (bool)$result;
	}

		public function favourite(int $user_id, int $target_id, string $type):bool
		{
			return $this->toggleFavourite(true, $user_id, $target_id, $type);
		}
		public function unfavourite(int $user_id, int $target_id, string $type):bool
		{
			return $this->toggleFavourite(false, $user_id, $target_id, $type);
		}

		public function addNoteFromTarget(int $user_id, int $target_id, string $type, string $note):bool
		{
			$favourite = $this->favourites->get([
				'user_id'	=> $user_id,
				'target_id'	=> $target_id,
				'type'		=> $type
			]);
			if (!$favourite) {
				return false;
			}
			return $this->addNote($user_id, $favourite->id, $note);
		}
		public function addNote(int $user_id, int $favourite_id, string $note):bool
		{
			$favourite = $this->favourites->get(['id' => $favourite_id]);
			if (!$favourite) {
				return false;
			}
			if ($favourite->user_id !== $user_id) {
				return false;
			}
			return (bool) $this->favourites->update([
				'note'	=> sanitize_textarea_field($note)
			], [
				'favourite_id' => $favourite_id
			]);
		}
		public function deleteNote(int $user_id, int $favourite_id):bool
		{
			if (!$this->userCanEditFavourite($user_id, ['id' => $favourite_id])) {
				return false;
			}
			return (bool) $this->favourites->update([
				'note'	=> '',
			], [
				'favourite_id' => $favourite_id
			]);
		}


		public function addListItemNote(int $user_id, int $listItemId, string|array $note):bool
		{
			if (!$this->userCanEditListItem($user_id, $listItemId)) {
				return false;
			}
			$listItem = $this->listItems->get(['id' => $listItemId]);
			$notes = json_decode($listItem->notes, true);

			$notes = $this->addNoteToArray($notes, $user_id, $note);

			return $this->listItems->update(['id' => $listItemId], ['notes' => json_encode($notes)]);
		}
		public function removeListItemNote(int $user_id, int $listItemId, string $noteID):bool
		{
			if (!$this->userCanEditListItem($user_id, $listItemId)) {
				return false;
			}
			$listItem = $this->listItems->get(['id' => $listItemId]);
			$notes = json_decode($listItem->notes, true);
			$index = array_search($noteID, array_column($notes, 'id'));
			if ($index === false) {
				return false;
			}
			$note = $notes[$index];
			if ($user_id !== $note['user_id']) {
				return false;
			}

			$notes = $this->removeNoteFromArray($notes, $user_id, $noteID);

			return $this->listItems->update(['id' => $listItemId], ['notes' => json_encode($notes)]);
		}

		public function addListNote(int $user_id, int $listId, string $note):bool
		{
			if (!$this->userCanEditList($user_id, $listId)) {
				return false;
			}
			$list = $this->listItems->get(['id' => $listId]);
			$notes = json_decode($list->notes, true);

			$notes = $this->addNoteToArray($notes, $user_id, $note);

			return $this->listItems->update(['id' => $listId], ['notes' => json_encode($notes)]);
		}

		public function removeListNote(int $user_id, int $listId, string $noteID):bool
		{
			if (!$this->userCanEditList($user_id, $listId)) {
				return false;
			}
			$list = $this->lists->get(['id' => $listId]);
			$notes = json_decode($list->notes, true);
			$index = array_search($noteID, array_column($notes, 'id'));
			if ($index === false) {
				return false;
			}
			$note = $notes[$index];
			if ($user_id !== $note['user_id']) {
				return false;
			}

			$notes = $this->removeNoteFromArray($notes, $user_id, $noteID);

			return $this->lists->update(['id' => $listId], ['notes' => json_encode($notes)]);
		}

		public function shareList(int $user_id, int $listId, bool $viewOnly = true, ?int $shareWithUser = null, ?array $newUser = null):bool
		{
			$list = $this->lists->get(['id' => $listId]);
			if (!$list) {
				return false;
			}
			if ($list->user_id !== $user_id) {
				return false;
			}

			if (!$shareWithUser && (empty($newUser) || !array_key_exists('email', $newUser) || !array_key_exists('name', $newUser))) {
				return false;
			}

			$args = [];
			if ($shareWithUser) {
				$args['user_id'] = $shareWithUser;
				JVB()->notification()->addNotification($shareWithUser, 'list_shared', $user_id, '', $listId);
			} elseif ($newUser) {
				$email = sanitize_email($newUser['email']);
				$name = sanitize_text_field($newUser['name']);
				$args['email'] = $email;
				//TODO: Magic Link setup
			}
			if (empty($args)) {
				return false;
			}

			return (bool) $this->listShares->findOrCreate(array_merge($args, ['list_id' => $listId, 'permission' => $viewOnly ? 'view' : 'edit']));
		}
		public function unshareList(int $user_id, int $listId, int|string $userIDorEmail):bool
		{
			$list = $this->lists->get(['id' => $listId]);
			if (!$list) {
				return false;
			}
			if ($list->user_id !== $user_id) {
				return false;
			}

			$where = [
				'list_id'	=> $listId
			];
			if (is_int($userIDorEmail)) {
				$where['user_id'] = $userIDorEmail;

				$notification = JVB()->notification()->table();
				$n = $notification->get([
					'for_user' => $userIDorEmail,
					'from_user' => $user_id,
					'type' => 'list_shared',
					'target_id' => $listId,
				]);
				if ($n) {
					$notification->delete([
						'for_user' => $userIDorEmail,
						'from_user' => $user_id,
						'type' => 'list_shared',
						'target_id' => $listId,
					]);
				}
			} else if (is_email($userIDorEmail)) {
				$where['email'] = sanitize_email($userIDorEmail);
			} else {
				return false;
			}

			return $this->listShares->update($where, ['status' => 'revoked']);
		}

		public function acceptListShare(int $listId, int|string $userIDorEmail):bool
		{
			return $this->respondToShare(true, $listId, $userIDorEmail);
		}

		public function rejectListShare(int $listId, int|string $userIDorEmail):bool
		{
			return $this->respondToShare(false, $listId, $userIDorEmail);
		}
		public function respondToShare(bool $accept, int $listId, int|string $userIDorEmail):bool
		{
			$args =  [
				'listId' => $listId
			];
			if (is_int($userIDorEmail)) {
				$args['user_id'] = $userIDorEmail;

				$list = $this->lists->get(['id' => $listId]);
				if ($list) {
					$user = get_userdata($userIDorEmail);

					$message = $accept ? 'accepted' : 'rejected';
					$message = $user->first_name . ' ' . $message . ' your list share invitation.';
					JVB()->notification()->addNotification($list->user_id, 'list_share_status', $userIDorEmail, $message);
				}
			}else if (is_email($userIDorEmail)) {
				$args['email'] = sanitize_email($userIDorEmail);
			} else {
				return  false;
			}
			$share = $this->listShares->get($args);
			if (!$share) {
				return false;
			}


			return $this->listShares->update([
				'status'	=> $accept ? 'accepted' : 'rejected',
			], $args);
		}
	/***************************************************************
	 * UTILITY METHODS
	 **************************************************************/
	/**
	 * @param int $user_id
	 * @param array $args
	 * @return bool
	 */
	public function userCanEditFavourite(int $user_id, array $args):bool
	{
		if (array_key_exists('id', $args)) {
			$where = [
				'id'	=> $args['id']
			];
		} else {
			if (!array_key_exists('target_id', $args)
			|| !array_key_exists('type', $args)) {
				error_log('[Favourites]::userCanEditFavourite missing required target_id or type');
				return false;
			}
			$where = [
				'target_id'	=> absint($args['target_id']),
				'type'		=> $args['type']
			];
		}

		$get = $this->favourites->get($where);
		return !is_null($get) && $get->user_id === $user_id;
	}

	public function userCanViewList(int $user_id, int $list_id):bool
	{
		$list = $this->lists->get(['id' => $list_id]);
		if (!$list) {
			return false;
		}
		if ($list->user_id === $user_id) {
			return true;
		}
		$share = $this->listShares->get(['user_id' => $user_id, 'list_id' => $list_id]);
		return !is_null($share);
	}
	public function userCanEditList(int $user_id, int $list_id):bool
	{
		$list = $this->lists->get(['id' => $list_id]);
		if (!$list) {
			return false;
		}
		if ($list->user_id === $user_id) {
			return true;
		}
		$share = $this->listShares->get(['user_id' => $user_id, 'list_id' => $list_id]);
		if (!$share) return false;
		return $share->permission === 'edit';
	}

	public function userCanEditListItem(int $user_id, int $list_item_id):bool
	{
		$item = $this->listItems->get(['id' => $list_item_id]);
		if (!$item) {
			return false;
		}
		if ($item->user_id === $user_id) {
			return true;
		}
		return $this->userCanEditList($user_id, $item->list_id);
	}

	protected function addNoteToArray(array $notes, int $user_id, string|array $note):array
	{
		$updated = date('Y-m-d H:i:s');
		if (is_string($note)) {
			//It is a new note
			$notes[] = [
				'id'	=> uniqid(),
				'note' => sanitize_textarea_field($note),
				'user_id' => $user_id,
				'updated' => $updated
			];
		} else {
			$index = array_search($note['id'], array_column($notes, 'id'));
			if ($index === false) {
				//Shouldn't happen, but just in case: add it to the array
				$notes[] = [
					'id'	=> sanitize_text_field($note['id']),
					'note'	=> sanitize_textarea_field($note['note']),
					'user_id' => $user_id,
					'updated' => $updated
				];
			} else {
				$notes[$index]['note'] = sanitize_textarea_field($note['note']);
				$notes[$index]['updated'] = $updated;
			}
		}

		return $notes;
	}

	protected function removeNoteFromArray(array $notes, int $user_id, string $noteID):array
	{
		$index = array_search($noteID, array_column($notes, 'id'));
		if ($index === false) {
			return $notes;
		}
		$note = $notes[$index];
		if ($user_id !== $note['user_id']) {
			return $notes;
		}

		unset($notes[$index]);
		return array_values($notes); //reindexed array
	}
}