HummingBirdAnimeClient/src/Command/SyncKitsuWithMal.php

<?php declare(strict_types=1);
/**
 * Hummingbird Anime List Client
 *
 * An API client for Kitsu and MyAnimeList to manage anime and manga watch lists
 *
 * PHP version 7
 *
 * @package     HummingbirdAnimeClient
 * @author      Timothy J. Warren <tim@timshomepage.net>
 * @copyright   2015 - 2017  Timothy J. Warren
 * @license     http://www.opensource.org/licenses/mit-license.html  MIT License
 * @version     4.0
 * @link        https://git.timshomepage.net/timw4mail/HummingBirdAnimeClient
 */

namespace Aviat\AnimeClient\Command;

use function Amp\{all, wait};

use Amp\Artax\Client;
use Aviat\AnimeClient\API\{
	JsonAPI,
	ParallelAPIRequest,
	Mapping\AnimeWatchingStatus,
	Mapping\MangaReadingStatus
};
use Aviat\AnimeClient\API\MAL\Transformer\{
	AnimeListTransformer as ALT,
	MangaListTransformer as MLT
};
use Aviat\Ion\Json;

/**
 * Clears the API Cache
 */
class SyncKitsuWithMal extends BaseCommand {

	/**
	 * Model for making requests to Kitsu API
	 * @var \Aviat\AnimeClient\API\Kitsu\Model
	 */
	protected $kitsuModel;

	/**
	 * Model for making requests to MAL API
	 * @var \Aviat\AnimeClient\API\MAL\Model
	 */
	protected $malModel;

	/**
	 * Run the image conversion script
	 *
	 * @param array $args
	 * @param array $options
	 * @return void
	 * @throws \ConsoleKit\ConsoleException
	 */
	public function execute(array $args, array $options = [])
	{
		$this->setContainer($this->setupContainer());
		$this->setCache($this->container->get('cache'));
		$this->kitsuModel = $this->container->get('kitsu-model');
		$this->malModel = $this->container->get('mal-model');

		$this->sync('anime');
		$this->sync('manga');
	}

	public function sync(string $type)
	{
		$uType = ucfirst($type);

		// Do a little check to make sure you don't have immediate issues
		// if you have 0 or 1 items in a list on MAL.
		$malList = $this->malModel->getList($type);
		$malCount = 0;
		if ( ! empty($malList))
		{
			$malCount = (array_key_exists(0, $malList))
				? count($malList)
				: count([$malList]);
		}

		$kitsuCount = $this->kitsuModel->{"get{$uType}ListCount"}();

		$this->echoBox("Number of MAL {$type} list items: {$malCount}");
		$this->echoBox("Number of Kitsu {$type} list items: {$kitsuCount}");

		$data = $this->diffLists($type);

		if ( ! empty($data['addToMAL']))
		{
			$count = count($data['addToMAL']);
			$this->echoBox("Adding {$count} missing {$type} list items to MAL");
			$this->createMALListItems($data['addToMAL'], $type);
		}

		if ( ! empty($data['addToKitsu']))
		{
			$count = count($data['addToKitsu']);
			$this->echoBox("Adding {$count} missing {$type} list items to Kitsu");
			$this->createKitsuListItems($data['addToKitsu'], $type);
		}

		if ( ! empty($data['updateMAL']))
		{
			$count = count($data['updateMAL']);
			$this->echoBox("Updating {$count} outdated MAL {$type} list items");
			$this->updateMALListItems($data['updateMAL'], $type);
		}

		if ( ! empty($data['updateKitsu']))
		{
			print_r($data['updateKitsu']);
			$count = count($data['updateKitsu']);
			$this->echoBox("Updating {$count} outdated Kitsu {$type} list items");
			$this->updateKitsuListItems($data['updateKitsu'], $type);
		}
	}

	public function filterMappings(array $includes, string $type = 'anime'): array
	{
		$output = [];

		foreach($includes as $id => $mapping)
		{
			if ($mapping['externalSite'] === "myanimelist/{$type}")
			{
				$output[$id] = $mapping;
			}
		}

		return $output;
	}

	public function formatMALList(string $type): array
	{
		if ($type === 'anime')
		{
			return $this->formatMALAnimeList();
		}

		if ($type === 'manga')
		{
			return $this->formatMALMangaList();
		}
	}

	public function formatMALAnimeList()
	{
		$orig = $this->malModel->getList('anime');
		$output = [];

		// Bail early on empty list
		if (empty($orig))
		{
			return [];
		}

		// Due to xml parsing differences,
		// 1 item has no wrapping array.
		// In this case, just re-create the
		// wrapper array
		if ( ! array_key_exists(0, $orig))
		{
			$orig = [$orig];
		}

		foreach($orig as $item)
		{
			$output[$item['series_animedb_id']] = [
				'id' => $item['series_animedb_id'],
				'data' => [
					'status' => AnimeWatchingStatus::MAL_TO_KITSU[$item['my_status']],
					'progress' => $item['my_watched_episodes'],
					'reconsuming' => (bool) $item['my_rewatching'],
					'rating' => $item['my_score'] / 2,
					'updatedAt' => (new \DateTime())
						->setTimestamp((int)$item['my_last_updated'])
						->format(\DateTime::W3C),
				]
			];
		}

		return $output;
	}

	public function formatMALMangaList()
	{
		$orig = $this->malModel->getList('manga');
		$output = [];

		// Bail early on empty list
		if (empty($orig))
		{
			return [];
		}

		// Due to xml parsing differences,
		// 1 item has no wrapping array.
		// In this case, just re-create the
		// wrapper array
		if ( ! array_key_exists(0, $orig))
		{
			$orig = [$orig];
		}

		foreach($orig as $item)
		{
			$output[$item['series_mangadb_id']] = [
				'id' => $item['series_mangadb_id'],
				'data' => [
					'my_status' => $item['my_status'],
					'status' => MangaReadingStatus::MAL_TO_KITSU[$item['my_status']],
					'progress' => $item['my_read_chapters'],
					'volumes' => $item['my_read_volumes'],
					'reconsuming' => (bool) $item['my_rereadingg'],
					'rating' => $item['my_score'] / 2,
					'updatedAt' => (new \DateTime())
						->setTimestamp((int)$item['my_last_updated'])
						->format(\DateTime::W3C),
				]
			];
		}

		return $output;
	}

	public function formatKitsuList(string $type = 'anime'): array
	{
		$data = $this->kitsuModel->{'getFull' . ucfirst($type) . 'List'}();

		if (empty($data))
		{
			return [];
		}

		$includes = JsonAPI::organizeIncludes($data['included']);
		$includes['mappings'] = $this->filterMappings($includes['mappings'], $type);

		$output = [];

		foreach($data['data'] as $listItem)
		{
			$id = $listItem['relationships'][$type]['data']['id'];
			$potentialMappings = $includes[$type][$id]['relationships']['mappings'];
			$malId = NULL;

			foreach ($potentialMappings as $mappingId)
			{
				if (array_key_exists($mappingId, $includes['mappings']))
				{
					$malId = $includes['mappings'][$mappingId]['externalId'];
				}
			}

			// Skip to the next item if there isn't a MAL ID
			if (is_null($malId))
			{
				continue;
			}

			$output[$listItem['id']] = [
				'id' => $listItem['id'],
				'malId' => $malId,
				'data' => $listItem['attributes'],
			];
		}

		return $output;
	}

	public function diffLists(string $type = 'anime'): array
	{
		// Get libraryEntries with media.mappings from Kitsu
		// Organize mappings, and ignore entries without mappings
		$kitsuList = $this->formatKitsuList($type);

		// Get MAL list data
		$malList = $this->formatMALList($type);

		$itemsToAddToMAL = [];
		$itemsToAddToKitsu = [];
		$malUpdateItems = [];
		$kitsuUpdateItems = [];

		$malIds = array_column($malList, 'id');
		$kitsuMalIds = array_column($kitsuList, 'malId');
		$missingMalIds = array_diff($malIds, $kitsuMalIds);

		foreach($missingMalIds as $mid)
		{
			// print_r($malList[$mid]);
			$itemsToAddToKitsu[] = array_merge($malList[$mid]['data'], [
				'id' => $this->kitsuModel->getKitsuIdFromMALId($mid, $type),
				'type' => $type
			]);
		}

		foreach($kitsuList as $kitsuItem)
		{
			if (in_array($kitsuItem['malId'], $malIds))
			{
				$item = $this->compareListItems($kitsuItem, $malList[$kitsuItem['malId']]);

				if (is_null($item))
				{
					continue;
				}

				if (in_array('kitsu', $item['updateType']))
				{
					$kitsuUpdateItems[] = $item['data'];
				}

				if (in_array('mal', $item['updateType']))
				{
					$malUpdateItems[] = $item['data'];
				}

				continue;
			}

			// Looks like this item only exists on Kitsu
			$itemsToAddToMAL[] = [
				'mal_id' => $kitsuItem['malId'],
				'data' => $kitsuItem['data']
			];

		}

		return [
			'addToMAL' => $itemsToAddToMAL,
			'updateMAL' => $malUpdateItems,
			'addToKitsu' => $itemsToAddToKitsu,
			'updateKitsu' => $kitsuUpdateItems
		];
	}

	public function compareListItems(array $kitsuItem, array $malItem)
	{
		$compareKeys = ['status', 'progress', 'rating', 'reconsuming'];
		$diff = [];
		$dateDiff = (new \DateTime($kitsuItem['data']['updatedAt'])) <=> (new \DateTime($malItem['data']['updatedAt']));

		foreach($compareKeys as $key)
		{
			$diff[$key] = $kitsuItem['data'][$key] <=> $malItem['data'][$key];
		}

		// No difference? Bail out early
		$diffValues = array_values($diff);
		$diffValues = array_unique($diffValues);
		if (count($diffValues) === 1 && $diffValues[0] === 0)
		{
			return;
		}

		$update = [
			'id' => $kitsuItem['id'],
			'mal_id' => $kitsuItem['malId'],
			'data' => []
		];
		$return = [
			'updateType' => []
		];

		$sameStatus = $diff['status'] === 0;
		$sameProgress = $diff['progress'] === 0;
		$sameRating = $diff['rating'] === 0;


		// If status is the same, and progress count is different, use greater progress
		if ($sameStatus && ( ! $sameProgress))
		{
			if ($diff['progress'] === 1)
			{
				$update['data']['progress'] = $kitsuItem['data']['progress'];
				$return['updateType'][] = 'mal';
			}
			else if($diff['progress'] === -1)
			{
				$update['data']['progress'] = $malItem['data']['progress'];
				$return['updateType'][] = 'kitsu';
			}
		}

		// If status and progress are different, it's a bit more complicated...
		// But, at least for now, assume newer record is correct
		if ( ! ($sameStatus || $sameProgress))
		{
			if ($dateDiff === 1)
			{
				$update['data']['status'] = $kitsuItem['data']['status'];

				if ((int)$kitsuItem['data']['progress'] !== 0)
				{
					$update['data']['progress'] = $kitsuItem['data']['progress'];
				}

				$return['updateType'][] = 'mal';
			}
			else if($dateDiff === -1)
			{
				$update['data']['status'] = $malItem['data']['status'];

				if ((int)$malItem['data']['progress'] !== 0)
				{
					$update['data']['progress'] = $kitsuItem['data']['progress'];
				}

				$return['updateType'][] = 'kitsu';
			}
		}

		// If rating is different, use the rating from the item most recently updated
		if ( ! $sameRating)
		{
			if ($dateDiff === 1)
			{
				$update['data']['rating'] = $kitsuItem['data']['rating'];
				$return['updateType'][] = 'mal';
			}
			else if ($dateDiff === -1)
			{
				$update['data']['rating'] = $malItem['data']['rating'];
				$return['updateType'][] = 'kitsu';
			}
		}

		// If status is different, use the status of the more recently updated item
		if ( ! $sameStatus)
		{
			if ($dateDiff === 1)
			{
				$update['data']['status'] = $kitsuItem['data']['status'];
				$return['updateType'][] = 'mal';
			}
			else if ($dateDiff === -1)
			{
				$update['data']['status'] = $malItem['data']['status'];
				$return['updateType'][] = 'kitsu';
			}
		}

		$return['meta'] = [
			'kitsu' => $kitsuItem['data'],
			'mal' => $malItem['data'],
			'dateDiff' => $dateDiff,
			'diff' => $diff,
		];
		$return['data'] = $update;
		$return['updateType'] = array_unique($return['updateType']);
		return $return;
	}

	public function updateKitsuListItems($itemsToUpdate, $type = 'anime')
	{
		$requester = new ParallelAPIRequest();
		foreach($itemsToUpdate as $item)
		{
			$requester->addRequest($this->kitsuModel->updateListItem($item));
		}

		$responses = $requester->makeRequests();

		foreach($responses as $key => $response)
		{
			$id = $itemsToUpdate[$key]['id'];
			if ($response->getStatus() === 200)
			{
				$this->echoBox("Successfully updated Kitsu {$type} list item with id: {$id}");
			}
			else
			{
				echo $response->getBody();
				$this->echoBox("Failed to update Kitsu {$type} list item with id: {$id}");
			}
		}
	}

	public function updateMALListItems($itemsToUpdate, $type = 'anime')
	{
		$transformer = new ALT();
		$requester = new ParallelAPIRequest();

		foreach($itemsToUpdate as $item)
		{
			$requester->addRequest($this->malModel->updateListItem($item, $type));
		}

		$responses = $requester->makeRequests();

		foreach($responses as $key => $response)
		{
			$id = $itemsToUpdate[$key]['mal_id'];
			if ($response->getBody() === 'Updated')
			{
				$this->echoBox("Successfully updated MAL {$type} list item with id: {$id}");
			}
			else
			{
				$this->echoBox("Failed to update MAL {$type} list item with id: {$id}");
			}
		}
	}

	public function createKitsuListItems($itemsToAdd, $type = 'anime')
	{
		$requester = new ParallelAPIRequest();
		foreach($itemsToAdd as $item)
		{
			$requester->addRequest($this->kitsuModel->createListItem($item));
		}

		$responses = $requester->makeRequests();

		foreach($responses as $key => $response)
		{
			$id = $itemsToAdd[$key]['id'];
			if ($response->getStatus() === 201)
			{
				$this->echoBox("Successfully created Kitsu {$type} list item with id: {$id}");
			}
			else
			{
				echo $response->getBody();
				$this->echoBox("Failed to create Kitsu {$type} list item with id: {$id}");
			}
		}
	}

	public function createMALListItems($itemsToAdd, $type = 'anime')
	{
		$transformer = new ALT();
		$requester = new ParallelAPIRequest();

		foreach($itemsToAdd as $item)
		{
			$data = $transformer->untransform($item);
			$requester->addRequest($this->malModel->createFullListItem($data, $type));
		}

		$responses = $requester->makeRequests();

		foreach($responses as $key => $response)
		{
			$id = $itemsToAdd[$key]['mal_id'];
			if ($response->getBody() === 'Created')
			{
				$this->echoBox("Successfully created MAL {$type} list item with id: {$id}");
			}
			else
			{
				$this->echoBox("Failed to create MAL {$type} list item with id: {$id}");
			}
		}
	}
}