/**
* Štúdia: Vylepšený formát slovenských rodných čísel pre roky 1900 - 2799
*         a dennou kapacitou 2 x 1420 novorodencov
*         (na účel dema použitá sada 25 pismen, dĺžka indexu 3 písmená)
*
* https://synet.sk/blog/php/485-studia-vylepsene-rodne-cislo
* (c) 2024-2025 Lubos Dzurik - lubosdz@gmail.com
*/
class RodneCislo2800
{
	const
		// pohlavie
		GENDER_MALE = 'M',
		GENDER_FEMALE = 'F';

	// Character map for converting daily birth sequencial index 1, 2, .. to proper numeric base
	// Allowed are only capital letters for better legibility.
	// 26 pismen zredukovane na 25, kde A=0, B=1, C=2, ... Z=24 (max. capacity 15624)
	// - kvoli citatelnosti vypustene: Q (Q vs. O / OTEC vs. 0 / nula)
	// - tiez na zvazenie vypustit:
	//	 L - male pismeno l (lano) vs. 1 (cislica jedna)
	//	 U - vizualna kolizia U/V v niektorych fontoch
	// - rozsirenie .. moznost pridat cislice 1-9 do mapy (nulu nie kvoli kolizii s "O"-OTEC)
	//              .. zvysi kapacitu indexu z 15624 -> 39303 (pre kazde pohlavie), cize celkovo 39303 females a 39303 males
	//              .. tiez moznost pouzit 4- resp. 5- miestny index, namiesto 3-miestneho
	const CHAR_MAP = 'ABCDEFGHIJKLMNOPRSTUVWXYZ';
	//const MAP = 'ABCDEFGHIJKLMNOPRSTUVWXYZ987654321'; // na pokusovanie .. napr. pridanie 1-9: index max = 39303, indexPerGenderPerDay = 3537

	/** @var int Division remainder must be zero - check birth ID validity, moznost pouzit ine modulo pre lepsiu eliminaciu chyb, avsak poklese dennej kapacity */
	const MODULO = 11;

	const
		/** @var int The year base - from which we calculate following +999 years */
		BASE_YEAR = 1800,

		/** @var int Maximum allowed year */
		MAX_YEAR = 2799;

	/** @var string User inputs */
	protected $rc = null;

	/** @var bool runtime variable */
	protected $isValid = null;

	// basic auxiliary info about birth ID
	protected
		$month,
		$day,
		$year,
		$gender,
		$timestamp,
		$age,
		$indexNumeric,
		$indexLetter;

	/** @var string The reason why failed generating birth ID in old (current/legacy) format */
	protected $reasonFailOldFormat = '';

	/**
	* Constructor
	* @param string $rc Birth ID in new format e.g. 2010104AOA
	*/
	public function __construct($rc = null)
	{
		$this->rc = $rc;
		if ($rc) {
			$this->validate();
		}
	}

	/**
	* Return TRUE when birth ID is valid
	*/
	public function isValid()
	{
		if (null === $this->isValid) {
			$this->validate();
		}
		return $this->isValid;
	}

	/**
	* Return TRUE if birth ID in new format is valid
	*/
	protected function validate()
	{
		$this->rc = trim(strtoupper($this->rc));

		if (!preg_match('/^[1-9][0-9]{6}[A-Z]{3}$/', $this->rc)) {
			throw new \Exception('Neplatné rodné číslo - musí mať tvar RRRMMDDAAA.');
		}

		// convert to old format
		$this->year = self::BASE_YEAR + (int) substr($this->rc, 0, 3);
		$this->month = (int) substr($this->rc, 3, 2);
		$this->day = (int) substr($this->rc, 5, 2);
		$this->timestamp = null;
		$this->age = null;

		if ($this->month >= 51 && $this->month <= 62) {
			// zeny maju pripocitane 50 ku mesiacom 1-12
			$this->month -= 50;
			$this->gender = self::GENDER_FEMALE;
		} else {
			$this->gender = self::GENDER_MALE;
		}

		$this->isValid = checkdate($this->month, $this->day, $this->year);

		if ($this->isValid) {
			// index ie. CMT -> 1568
			$this->indexLetter = substr($this->rc, -3);
			$this->indexNumeric = self::indexLetterToNumber($this->indexLetter);
			$rcDecrypted = substr($this->rc, 0, 7).str_pad($this->indexNumeric, $this->year < 1954 ? 3 : 4, "0", STR_PAD_LEFT); // eg. 18159142551
			$check = $rcDecrypted / self::MODULO;
			$check2 = floor($rcDecrypted / self::MODULO);

			if ($check != $check2) {
				$this->isValid = false;
			} else {
				$this->timestamp = strtotime("{$this->year}-{$this->month}-{$this->day}");
				if ($this->timestamp < time()) {
					$this->age = date_diff(date_create("{$this->year}-{$this->month}-{$this->day}"), date_create('now'))->y;
				}
			}
		}

		return $this->isValid;
	}

	/**
	* Return maximum daily index capacity
	*/
	public static function getIndexMax()
	{
		$base = strlen(self::CHAR_MAP);
		//$max = ($base - 1) * $base**2 + ($base - 1) * $base**1 + ($base - 1) * $base ** 0;
		$max = ($base - 1) * $base**2 + ($base - 1) * $base + ($base - 1); // same as above, optimized
		return $max;
	}

	/**
	* Prevedie denny poradovy index z N-ciselnej sustavy do desiatkovej sustavy, napr. LLA => 7150
	* @param string $new napr. LLA
	* @return int Old format e.g. 7150
	*/
	public static function indexLetterToNumber($indexLetters)
	{
		$len = strlen($indexLetters);
		if ($len != 3) {
			// na ucel demo - pouzivame striktne 3-ciferny konvertovany index
			throw new \Exception("Nesprávna dĺžka indexu [{$len}] - musí byť presne 3 znaky.");
		}

		$out = 0;
		$base = strlen(self::CHAR_MAP); // 25 - the number of used letters, may be reduced to avoid vizual ambiguities

		for ($i = 0; $i < $len; ++$i) {
			$chr = substr($indexLetters, -($i + 1), 1); // od posledneho pismena ku prvemu
			$pos = strpos(self::CHAR_MAP, $chr); // pozicia v mape, case sensitive
			if (false === $pos) { // neexistuje?
				throw new \Exception("Neplatný formát indexu - písmeno [{$chr}] nie je povolené.");
			}
			$out += $base**$i*$pos; // e.g. (25*25*12)+(25*3)+(17) => pismena v poradi 12-3-17 = MDS
		}

		return $out;
	}

	/**
	* Prevedie denny poradovy index z desiatkovej sustavy do cielovej podla poctu znakov v character map, napr. 7150 -> LLA
	* See also javascript sample implementation:
	*   - https://stackoverflow.com/questions/1337419/how-do-you-convert-numbers-between-different-bases-in-javascript
	*
	* @param int Numericky tradicny poradovy index napr. 7150
	* @return string Cislo v novej ciselnej sustave podla ciselneho zakladu - dlzky aktualnej CHAR_MAP napr. LLA
	*/
	public static function indexNumberToLetter($indexNum)
	{
		if (!is_numeric($indexNum)) {
			throw new \Exception("Index ({$indexNum}) musí pozostávať z číslic 0-9.");
		}

		// preverime dlzku indexu - nepovinne, len specificky pre demo, prip. sa moze automaticky doplnit zlava padding nulami
		$len = strlen("{$indexNum}");
		if ($len < 3 || $len > 5) {
			// overenie pre ucel dema:
			//  3 = stary/sucasny 0-999 format do 31.12.1953 (bez modulo 11)
			//  4 = stary/sucasny 0-9999 format od 01.01.1954 (s modulo 11)
			//  5 = vylepseny format 0-99999 po konverzii do desiatkovej sustavy (s modulo 11), mozno upravit ..
			throw new \Exception("Nesprávna dĺžka indexu [{$indexNum}] - musí byť 3 až 5 znakov, nájdené {$len} znakov.");
		}

		$base = strlen(self::CHAR_MAP);
		$tmp = $base ** 2;
		$one = intval($indexNum / $tmp);
		$rem = $indexNum - ($tmp * $one);
		$two = intval($rem / $base);
		$three = $indexNum - ($tmp * $one) - ($base * $two);
		$out = self::CHAR_MAP[$one].self::CHAR_MAP[$two].self::CHAR_MAP[$three];

		return $out;
	}

	/**
	* Podporna funkcia - zakladne informacie o rodnom cisle, napr. vek, dennu kapacitu indexu ..
	*/
	public function getInfo()
	{
		$max = self::getIndexMax();
		$oldFormat = $this->convertNewToOld($this->rc);
		return [
			'rc' => $this->rc,
			'isValid' => $this->isValid,
			'gender' => $this->gender,
			'year' => $this->year,
			'month' => $this->month,
			'day' => $this->day,
			'age' => $this->age ?? '',
			'indexNumeric' => $this->indexNumeric,
			'indexLetter' => $this->indexLetter,
			'indexNumericMax' => $max, // max. kapacita indexu, should be 15624 for 25 letters
			'indexLetterMax' => $this->indexNumberToLetter($max), // should be ie. ZZZ
			'mapCharsCount' => strlen(self::CHAR_MAP), // urcuje kapacitu denneho indexu, zaklad cielovej ciselnej sustavy
			'indexPerGenderPerDay' => intval($max / 11), // denna kapacita poradoveho indexu
			'indexPerGenderPerYear' => intval($max / 11) * 365, // rocna kapacita poradoveho indexu
			'baseYear' => self::BASE_YEAR,
			'maxYear' => self::MAX_YEAR,
			'timestamp' => $this->timestamp,
			'oldFormatRC' => $oldFormat ?? '',
			'oldFormatFailReason' => $oldFormat ? '' : $this->reasonFailOldFormat,
		];
	}

	/**
	* Prevedie novy format RC na stary - POZOR - heuristicky prevod indexu na ucel DEMO, nakolko modulo v starom a novom formate budu vzdy odlisne
	* Set also the reason why conversion failed, ie. index in old format out of range
	* @param string $newRc e.g. 2120807OKS
	* @param bool $validate Check if the day exists
	* @return string e.g. 1208079017
	*/
	public function convertNewToOld($newRc, $validate = true)
	{
		$newRc = trim(strtoupper($newRc));
		// note: pri rozsireni napr. o cislice upravit REGEX napr. na "/^[\d]{7}[A-Z1-9]{3}$/"
		if (!preg_match('/^[\d]{7}[A-Z]{3}$/', $newRc)) {
			throw new \Exception('Rodné číslo musí pozostávať zo 7x číslic 0-9 a 3x písmen A-Z.');
		}

		$this->reasonFailOldFormat = '';
		$year = (int) substr($newRc, 0, 3);
		$year += self::BASE_YEAR;
		$month = substr($newRc, 3, 2); // dont typecast to retain padding
		$day = substr($newRc, 5, 2); // dont typecast to retain padding
		$monthReal = $month > 12 ? $month - 50 : $month;

		if($validate && !checkdate(intval($monthReal), intval($day), $year)){
			throw new \Exception('Neplatné rodné číslo.');
		}

		$indexLetter = substr($newRc, -3);
		$indexNum = self::indexLetterToNumber($indexLetter);
		$rc = "";

		// check - can be converted to old format?
		if ($year > date('Y') || $year < 1900) {
			// year out of range - old format possible only for 1900 .. current year
			$this->reasonFailOldFormat = "Year out of range 1900-".date("Y")." (found {$year})";
			$rc = "";
		} elseif ($indexNum > 9999) {
			// index out of range 1954 - index v novom RC presahuje kapacity stareho formatu
			$this->reasonFailOldFormat = "Index out of range 1-9999 (found {$indexNum})";
			$indexNum = "????";
		} elseif ($indexNum > 999 && $year < 1954) {
			// index out of range 1953 - conversion not possible - v starom formate sa pouzivali 3-miestne indexy do 12/1953
			$this->reasonFailOldFormat = "Index out of range 1-999 (found {$indexNum})";
			$indexNum = "???";
		} else {
			// OK - valid RC might exist
			$rc = substr($year, -2)
				.str_pad($month, 2, "0", STR_PAD_LEFT)
				.str_pad($day, 2, "0", STR_PAD_LEFT)
				.str_pad($indexNum, $year < 1954 ? 3 : 4, "0", STR_PAD_LEFT);
		}

		if ($rc && is_numeric($indexNum)) {
			// try to find closest valid index in old format
			for ($i = 0; $i <= self::MODULO; ++$i) {
				// current / legacy birth number
				$verifyOld = new \RodneCislo($rc);
				if ($verifyOld->isValid()) {
					break; // OK, we have valid birth number
				}
				++$indexNum;
				if($year < 1954 && $indexNum > 999){
					$indexNum = 1;
				}elseif($year >= 1954 && $indexNum > 9999){
					$indexNum = 1;
				}
				$rc = substr($year, -2)
					.str_pad($month, 2, "0", STR_PAD_LEFT)
					.str_pad($day, 2, "0", STR_PAD_LEFT)
					.str_pad($indexNum, $year < 1954 ? 3 : 4, "0", STR_PAD_LEFT);
			}
		}

		return $rc;
	}

}