<?php

/*
 *
 *  ____            _        _   __  __ _                  __  __ ____
 * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
 * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
 * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
 * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * @author PocketMine Team
 * @link http://www.pocketmine.net/
 *
 *
 */

declare(strict_types=1);

namespace pocketmine\data\bedrock\block\upgrade;

use pocketmine\data\bedrock\block\upgrade\model\BlockStateUpgradeSchemaModel;
use pocketmine\data\bedrock\block\upgrade\model\BlockStateUpgradeSchemaModelBlockRemap;
use pocketmine\data\bedrock\block\upgrade\model\BlockStateUpgradeSchemaModelFlattenInfo;
use pocketmine\data\bedrock\block\upgrade\model\BlockStateUpgradeSchemaModelTag;
use pocketmine\data\bedrock\block\upgrade\model\BlockStateUpgradeSchemaModelValueRemap;
use pocketmine\nbt\tag\ByteTag;
use pocketmine\nbt\tag\IntTag;
use pocketmine\nbt\tag\StringTag;
use pocketmine\nbt\tag\Tag;
use pocketmine\utils\Filesystem;
use pocketmine\utils\Utils;
use Symfony\Component\Filesystem\Path;
use function array_key_last;
use function array_map;
use function assert;
use function count;
use function get_debug_type;
use function gettype;
use function implode;
use function is_object;
use function is_string;
use function json_decode;
use function json_encode;
use function ksort;
use function sort;
use function str_pad;
use function strval;
use function usort;
use const JSON_THROW_ON_ERROR;
use const SORT_NUMERIC;
use const STR_PAD_LEFT;

final class BlockStateUpgradeSchemaUtils{

	public static function describe(BlockStateUpgradeSchema $schema) : string{
		$lines = [];
		$lines[] = "Renames:";
		foreach($schema->renamedIds as $rename){
			$lines[] = "- $rename";
		}
		$lines[] = "Added properties:";
		foreach(Utils::stringifyKeys($schema->addedProperties) as $blockName => $tags){
			foreach(Utils::stringifyKeys($tags) as $k => $v){
				$lines[] = "- $blockName has $k added: $v";
			}
		}

		$lines[] = "Removed properties:";
		foreach(Utils::stringifyKeys($schema->removedProperties) as $blockName => $tagNames){
			foreach($tagNames as $tagName){
				$lines[] = "- $blockName has $tagName removed";
			}
		}
		$lines[] = "Renamed properties:";
		foreach(Utils::stringifyKeys($schema->renamedProperties) as $blockName => $tagNames){
			foreach(Utils::stringifyKeys($tagNames) as $oldTagName => $newTagName){
				$lines[] = "- $blockName has $oldTagName renamed to $newTagName";
			}
		}
		$lines[] = "Remapped property values:";
		foreach(Utils::stringifyKeys($schema->remappedPropertyValues) as $blockName => $remaps){
			foreach(Utils::stringifyKeys($remaps) as $tagName => $oldNewList){
				foreach($oldNewList as $oldNew){
					$lines[] = "- $blockName has $tagName value changed from $oldNew->old to $oldNew->new";
				}
			}
		}
		return implode("\n", $lines);
	}

	public static function tagToJsonModel(Tag $tag) : BlockStateUpgradeSchemaModelTag{
		$model = new BlockStateUpgradeSchemaModelTag();
		if($tag instanceof IntTag){
			$model->int = $tag->getValue();
		}elseif($tag instanceof StringTag){
			$model->string = $tag->getValue();
		}elseif($tag instanceof ByteTag){
			$model->byte = $tag->getValue();
		}else{
			throw new \UnexpectedValueException("Unexpected value type " . get_debug_type($tag));
		}

		return $model;
	}

	private static function jsonModelToTag(BlockStateUpgradeSchemaModelTag $model) : Tag{
		return match(true){
			isset($model->byte) && !isset($model->int) && !isset($model->string) => new ByteTag($model->byte),
			!isset($model->byte) && isset($model->int) && !isset($model->string) => new IntTag($model->int),
			!isset($model->byte) && !isset($model->int) && isset($model->string) => new StringTag($model->string),
			default => throw new \UnexpectedValueException("Malformed JSON model tag, expected exactly one of 'byte', 'int' or 'string' properties")
		};
	}

	public static function fromJsonModel(BlockStateUpgradeSchemaModel $model, int $schemaId) : BlockStateUpgradeSchema{
		$result = new BlockStateUpgradeSchema(
			$model->maxVersionMajor,
			$model->maxVersionMinor,
			$model->maxVersionPatch,
			$model->maxVersionRevision,
			$schemaId
		);
		$result->renamedIds = $model->renamedIds ?? [];
		$result->renamedProperties = $model->renamedProperties ?? [];
		$result->removedProperties = $model->removedProperties ?? [];

		foreach(Utils::stringifyKeys($model->addedProperties ?? []) as $blockName => $properties){
			foreach(Utils::stringifyKeys($properties) as $propertyName => $propertyValue){
				$result->addedProperties[$blockName][$propertyName] = self::jsonModelToTag($propertyValue);
			}
		}

		$convertedRemappedValuesIndex = [];
		foreach(Utils::stringifyKeys($model->remappedPropertyValuesIndex ?? []) as $mappingKey => $mappingValues){
			foreach($mappingValues as $oldNew){
				$convertedRemappedValuesIndex[$mappingKey][] = new BlockStateUpgradeSchemaValueRemap(
					self::jsonModelToTag($oldNew->old),
					self::jsonModelToTag($oldNew->new)
				);
			}
		}

		foreach(Utils::stringifyKeys($model->remappedPropertyValues ?? []) as $blockName => $properties){
			foreach(Utils::stringifyKeys($properties) as $property => $mappedValuesKey){
				if(!isset($convertedRemappedValuesIndex[$mappedValuesKey])){
					throw new \UnexpectedValueException("Missing key from schema values index $mappedValuesKey");
				}
				$result->remappedPropertyValues[$blockName][$property] = $convertedRemappedValuesIndex[$mappedValuesKey];
			}
		}

		foreach(Utils::stringifyKeys($model->flattenedProperties ?? []) as $blockName => $flattenRule){
			$result->flattenedProperties[$blockName] = self::jsonModelToFlattenRule($flattenRule);
		}

		foreach(Utils::stringifyKeys($model->remappedStates ?? []) as $oldBlockName => $remaps){
			foreach($remaps as $remap){
				if(isset($remap->newName)){
					$remapName = $remap->newName;
				}elseif(isset($remap->newFlattenedName)){
					$flattenRule = $remap->newFlattenedName;
					$remapName = self::jsonModelToFlattenRule($flattenRule);
				}else{
					throw new \UnexpectedValueException("Expected exactly one of 'newName' or 'newFlattenedName' properties to be set");
				}

				$result->remappedStates[$oldBlockName][] = new BlockStateUpgradeSchemaBlockRemap(
					array_map(fn(BlockStateUpgradeSchemaModelTag $tag) => self::jsonModelToTag($tag), $remap->oldState ?? []),
					$remapName,
					array_map(fn(BlockStateUpgradeSchemaModelTag $tag) => self::jsonModelToTag($tag), $remap->newState ?? []),
					$remap->copiedState ?? []
				);
			}
		}

		return $result;
	}

	private static function buildRemappedValuesIndex(BlockStateUpgradeSchema $schema, BlockStateUpgradeSchemaModel $model) : void{
		if(count($schema->remappedPropertyValues) === 0){
			return;
		}
		$dedupMapping = [];
		$dedupTableMap = [];

		$orderedRemappedValues = $schema->remappedPropertyValues;
		ksort($orderedRemappedValues);
		foreach(Utils::stringifyKeys($orderedRemappedValues) as $blockName => $remaps){
			ksort($remaps);
			foreach(Utils::stringifyKeys($remaps) as $propertyName => $remappedValues){
				$remappedValuesMap = [];
				foreach($remappedValues as $oldNew){
					$remappedValuesMap[$oldNew->old->toString()] = $oldNew;
				}
				ksort($remappedValuesMap);

				if(isset($dedupTableMap[$propertyName])){
					foreach($dedupTableMap[$propertyName] as $k => $dedupValuesMap){
						if(count($remappedValuesMap) !== count($dedupValuesMap)){
							continue;
						}

						foreach(Utils::stringifyKeys($remappedValuesMap) as $oldHash => $remappedOldNew){
							if(
								!isset($dedupValuesMap[$oldHash]) ||
								!$remappedOldNew->old->equals($dedupValuesMap[$oldHash]->old) ||
								!$remappedOldNew->new->equals($dedupValuesMap[$oldHash]->new)
							){
								continue 2;
							}
						}

						//we found a match
						$dedupMapping[$blockName][$propertyName] = $k;
						continue 2;
					}
				}

				//no match, add the values to the table
				$dedupTableMap[$propertyName][] = $remappedValuesMap;
				$dedupMapping[$blockName][$propertyName] = array_key_last($dedupTableMap[$propertyName]);
			}
		}

		$modelTable = [];
		foreach(Utils::stringifyKeys($dedupTableMap) as $propertyName => $mappingSet){
			foreach($mappingSet as $setId => $valuePairs){
				$newDedupName = $propertyName . "_" . str_pad(strval($setId), 2, "0", STR_PAD_LEFT);
				foreach($valuePairs as $pair){
					$modelTable[$newDedupName][] = new BlockStateUpgradeSchemaModelValueRemap(
						BlockStateUpgradeSchemaUtils::tagToJsonModel($pair->old),
						BlockStateUpgradeSchemaUtils::tagToJsonModel($pair->new),
					);
				}
			}
		}
		$modelDedupMapping = [];
		foreach(Utils::stringifyKeys($dedupMapping) as $blockName => $properties){
			foreach(Utils::stringifyKeys($properties) as $propertyName => $dedupTableIndex){
				$modelDedupMapping[$blockName][$propertyName] = $propertyName . "_" . str_pad(strval($dedupTableIndex), 2, "0", STR_PAD_LEFT);
			}
		}

		ksort($modelTable);
		ksort($modelDedupMapping);
		foreach(Utils::stringifyKeys($dedupMapping) as $blockName => $properties){
			ksort($properties);
			$dedupMapping[$blockName] = $properties;
		}

		$model->remappedPropertyValuesIndex = $modelTable;
		$model->remappedPropertyValues = $modelDedupMapping;
	}

	private static function flattenRuleToJsonModel(BlockStateUpgradeSchemaFlattenInfo $flattenRule) : BlockStateUpgradeSchemaModelFlattenInfo{
		return new BlockStateUpgradeSchemaModelFlattenInfo(
			$flattenRule->prefix,
			$flattenRule->flattenedProperty,
			$flattenRule->suffix,
			$flattenRule->flattenedValueRemaps,
			match($flattenRule->flattenedPropertyType){
				StringTag::class => null, //omit for TAG_String, as this is the common case
				ByteTag::class => "byte",
				IntTag::class => "int",
				default => throw new \LogicException("Unexpected tag type " . $flattenRule->flattenedPropertyType . " in flattened property type")
			}
		);
	}

	private static function jsonModelToFlattenRule(BlockStateUpgradeSchemaModelFlattenInfo $flattenRule) : BlockStateUpgradeSchemaFlattenInfo{
		return new BlockStateUpgradeSchemaFlattenInfo(
			$flattenRule->prefix,
			$flattenRule->flattenedProperty,
			$flattenRule->suffix,
			$flattenRule->flattenedValueRemaps ?? [],
			match ($flattenRule->flattenedPropertyType) {
				"string", null => StringTag::class,
				"int" => IntTag::class,
				"byte" => ByteTag::class,
				default => throw new \UnexpectedValueException("Unexpected flattened property type $flattenRule->flattenedPropertyType, expected 'string', 'int' or 'byte'")
			}
		);
	}

	public static function toJsonModel(BlockStateUpgradeSchema $schema) : BlockStateUpgradeSchemaModel{
		$result = new BlockStateUpgradeSchemaModel();
		$result->maxVersionMajor = $schema->maxVersionMajor;
		$result->maxVersionMinor = $schema->maxVersionMinor;
		$result->maxVersionPatch = $schema->maxVersionPatch;
		$result->maxVersionRevision = $schema->maxVersionRevision;

		$result->renamedIds = $schema->renamedIds;
		ksort($result->renamedIds);

		$result->renamedProperties = $schema->renamedProperties;
		ksort($result->renamedProperties);
		foreach(Utils::stringifyKeys($result->renamedProperties) as $blockName => $properties){
			ksort($properties);
			$result->renamedProperties[$blockName] = $properties;
		}

		$result->removedProperties = $schema->removedProperties;
		ksort($result->removedProperties);
		foreach(Utils::stringifyKeys($result->removedProperties) as $blockName => $properties){
			sort($properties); //yes, this is intended to sort(), not ksort()
			$result->removedProperties[$blockName] = $properties;
		}

		foreach(Utils::stringifyKeys($schema->addedProperties) as $blockName => $properties){
			$addedProperties = [];
			foreach(Utils::stringifyKeys($properties) as $propertyName => $propertyValue){
				$addedProperties[$propertyName] = self::tagToJsonModel($propertyValue);
			}
			ksort($addedProperties);
			$result->addedProperties[$blockName] = $addedProperties;
		}
		if(isset($result->addedProperties)){
			ksort($result->addedProperties);
		}

		self::buildRemappedValuesIndex($schema, $result);

		foreach(Utils::stringifyKeys($schema->flattenedProperties) as $blockName => $flattenRule){
			$result->flattenedProperties[$blockName] = self::flattenRuleToJsonModel($flattenRule);
		}
		if(isset($result->flattenedProperties)){
			ksort($result->flattenedProperties);
		}

		foreach(Utils::stringifyKeys($schema->remappedStates) as $oldBlockName => $remaps){
			$keyedRemaps = [];
			foreach($remaps as $remap){
				$modelRemap = new BlockStateUpgradeSchemaModelBlockRemap(
					array_map(fn(Tag $tag) => self::tagToJsonModel($tag), $remap->oldState),
					is_string($remap->newName) ? $remap->newName : self::flattenRuleToJsonModel($remap->newName),
					array_map(fn(Tag $tag) => self::tagToJsonModel($tag), $remap->newState),
					$remap->copiedState
				);
				if(count($modelRemap->copiedState) === 0){
					unset($modelRemap->copiedState); //avoid polluting the JSON
				}
				$key = json_encode($modelRemap);
				assert(!isset($keyedRemaps[$key]));
				if(isset($keyedRemaps[$key])){
					continue;
				}
				$keyedRemaps[$key] = $modelRemap;
			}
			usort($keyedRemaps, function(BlockStateUpgradeSchemaModelBlockRemap $a, BlockStateUpgradeSchemaModelBlockRemap $b) : int{
				//remaps with more specific criteria must come first
				$filterSizeCompare = count($b->oldState ?? []) <=> count($a->oldState ?? []);
				if($filterSizeCompare !== 0){
					return $filterSizeCompare;
				}
				//remaps with the same number of criteria should be sorted alphabetically, but this is not strictly necessary
				return json_encode($a->oldState ?? []) <=> json_encode($b->oldState ?? []);
			});
			$result->remappedStates[$oldBlockName] = $keyedRemaps; //usort strips keys, so this is already a list
		}
		if(isset($result->remappedStates)){
			ksort($result->remappedStates);
		}

		return $result;
	}

	/**
	 * Returns a list of schemas ordered by schema ID. Oldest schemas appear first.
	 *
	 * @return BlockStateUpgradeSchema[]
	 */
	public static function loadSchemas(string $path, int $maxSchemaId) : array{
		$iterator = new \RegexIterator(
			new \FilesystemIterator(
				$path,
				\FilesystemIterator::KEY_AS_FILENAME | \FilesystemIterator::SKIP_DOTS
			),
			'/^(\d{4}).*\.json$/',
			\RegexIterator::GET_MATCH,
			\RegexIterator::USE_KEY
		);

		$result = [];

		/** @var string[] $matches */
		foreach($iterator as $matches){
			$filename = $matches[0];
			$schemaId = (int) $matches[1];

			if($schemaId > $maxSchemaId){
				continue;
			}

			$fullPath = Path::join($path, $filename);

			$raw = Filesystem::fileGetContents($fullPath);

			try{
				$schema = self::loadSchemaFromString($raw, $schemaId);
			}catch(\RuntimeException $e){
				throw new \RuntimeException("Loading schema file $fullPath: " . $e->getMessage(), 0, $e);
			}

			$result[$schemaId] = $schema;
		}

		ksort($result, SORT_NUMERIC);
		return $result;
	}

	public static function loadSchemaFromString(string $raw, int $schemaId) : BlockStateUpgradeSchema{
		try{
			$json = json_decode($raw, false, flags: JSON_THROW_ON_ERROR);
		}catch(\JsonException $e){
			throw new \RuntimeException($e->getMessage(), 0, $e);
		}
		if(!is_object($json)){
			throw new \RuntimeException("Unexpected root type of schema file " . gettype($json) . ", expected object");
		}

		$jsonMapper = new \JsonMapper();
		$jsonMapper->bExceptionOnMissingData = true;
		$jsonMapper->bExceptionOnUndefinedProperty = true;
		$jsonMapper->bStrictObjectTypeChecking = true;
		try{
			$model = $jsonMapper->map($json, new BlockStateUpgradeSchemaModel());
		}catch(\JsonMapper_Exception $e){
			throw new \RuntimeException($e->getMessage(), 0, $e);
		}

		return self::fromJsonModel($model, $schemaId);
	}
}