<?php

use LAM\PDF\PDFTable;
use LAM\PDF\PDFTableCell;
use LAM\PDF\PDFTableRow;
use LAM\TYPES\ConfiguredType;
use LAM\TYPES\TypeManager;

/*

  This code is part of LDAP Account Manager (http://www.ldap-account-manager.org/)
  Copyright (C) 2013 - 2026  Roland Gruber

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

/**
 * Manages PyKota user accounts.
 *
 * @package modules
 * @author Roland Gruber
 */

/**
 * Manages PyKota user accounts.
 *
 * @package modules
 */
class pykotaUser extends baseModule {

	/**
	 * These attributes will be ignored by default if a new account is copied from an existing one.
	 */
	private const ATTRIBUTES_TO_IGNORE_ON_COPY = ['pykotaUserName', 'pykotaBalance', 'pykotaLifeTimePaid',
		'pykotaPayments'];

	/** @var string[]|null $uidCache cache for uid attribute */
	private ?array $uidCache = null;
	/** @var string[]|null $pykotaUserNameCache cache for pykotaUserName attribute */
	private ?array $pykotaUserNameCache = null;
	/** @var array<string, string> $limitOptions list of limit options label => value */
	private array $limitOptions;

	/**
	 * Returns if this module also manages the structural object class pykotaObject.
	 * This is overridden by a submodule that must provide the structural object class.
	 *
	 * @return bool structural usage
	 */
	public function isStructural(): bool {
		return false;
	}

	/**
	 * Creates a new pykotaUser object.
	 *
	 * @param string $scope account type (user, group, host)
	 */
	function __construct($scope) {
		$this->limitOptions = [
			_('Quota') => 'quota',
			_('Balance') => 'balance',
			_('No quota') => 'noquota',
			_('Free printing') => 'nochange',
			_('Deny printing') => 'noprint',
		];
		// call parent constructor
		parent::__construct($scope);
		$this->autoAddObjectClasses = $this->isStructural();
	}

	/**
	 * {@inheritDoc}
	 */
	public function can_manage(): bool {
		return $this->get_scope() === 'user';
	}

	/**
	 * {@inheritDoc}
	 */
	public function get_metaData(): array {
		$return = [];
		// icon
		$return['icon'] = 'printer.svg';
		// alias name
		$return["alias"] = _("PyKota");
		// this is a base module
		$return["is_base"] = $this->isStructural();
		// LDAP filter
		$return["ldap_filter"] = ['or' => "(objectClass=pykotaAccount)"];
		// module dependencies
		$return['dependencies'] = ['depends' => [], 'conflicts' => []];
		// managed object classes
		$return['objectClasses'] = ['pykotaAccount', 'pykotaAccountBalance'];
		// managed attributes
		$return['attributes'] = ['uid', 'mail', 'description', 'pykotaLimitBy', 'pykotaUserName', 'pykotaBalance', 'pykotaLifeTimePaid',
			'pykotaOverCharge', 'pykotaPayments'];
		// help Entries
		$return['help'] = [
			'cn' => [
				"Headline" => _("Common name"), 'attr' => 'cn',
				"Text" => _("This is the natural name of the user.")
			],
			'uid' => [
				"Headline" => _("User name"), 'attr' => 'uid',
				"Text" => _("User name of the user who should be created. Valid characters are: a-z,A-Z,0-9, @.-_.")
			],
			'mail' => [
				"Headline" => _("Email address"), 'attr' => 'mail',
				"Text" => _("The user's email address.")
			],
			'description' => [
				"Headline" => _("Description"), 'attr' => 'description',
				"Text" => _("User description.")
			],
			'pykotaUserName' => [
				"Headline" => _("PyKota user name"), 'attr' => 'pykotaUserName',
				"Text" => _("User name that is used for PyKota.")
			],
			'pykotaLimitBy' => [
				"Headline" => _("Limit type"), 'attr' => 'pykotaLimitBy',
				"Text" => _("Specifies the type of limit for printing if any. Please note that in contrast to \"Free printing\" the option \"No quota\" includes accounting.")
			],
			'pykotaBalance' => [
				"Headline" => _('Balance'), 'attr' => 'pykotaBalance',
				"Text" => _('Current account balance for the user.')
			],
			'pykotaBalanceComment' => [
				"Headline" => _('Balance comment'), 'attr' => 'pykotaPayments',
				"Text" => _('Comment for initial balance.')
			],
			'pykotaLifeTimePaid' => [
				"Headline" => _('Total paid'), 'attr' => 'pykotaLifeTimePaid',
				"Text" => _('Total money paid by the user.')
			],
			'pykotaOverCharge' => [
				"Headline" => _('Overcharge factor'), 'attr' => 'pykotaOverCharge',
				"Text" => _('Overcharge factor that is applied when computing the cost of a print job. The number of pages is not changed.')
			],
			'pykotaPayments' => [
				"Headline" => _('Payment and job history'), 'attr' => 'pykotaPayments',
				"Text" => _('Payment and job history for this user.')
			],
			'pykotaPaymentsAdd' => [
				"Headline" => _('Payment'), 'attr' => 'pykotaBalance, pykotaPayments',
				"Text" => _('Adds the amount to the user\'s balance. You can also specify a comment.')
			],
			'jobSuffix' => [
				"Headline" => _('Job suffix'),
				"Text" => _('Please enter the LDAP suffix where the PyKota job entries are stored (configuration option "jobbase").')
			],
			'autoAdd' => [
				"Headline" => _("Automatically add this extension"),
				"Text" => _("This will enable the extension automatically if this profile is loaded.")
			],
		];
		// profile options
		$profileContainer = new htmlResponsiveRow();
		if (!$this->isStructural()) {
			$profileContainer->add(new htmlResponsiveInputCheckbox('pykotaUser_addExt', false, _('Automatically add this extension'), 'autoAdd'));
		}
		$pykotaLimitByProfileOption = new htmlResponsiveSelect('pykotaUser_pykotaLimitBy', $this->limitOptions, [], _('Limit type'), 'pykotaLimitBy');
		$pykotaLimitByProfileOption->setHasDescriptiveElements(true);
		$pykotaLimitByProfileOption->setSortElements(false);
		$profileContainer->add($pykotaLimitByProfileOption);
		$profileContainer->add(new htmlResponsiveInputField(_('Balance'), 'pykotaUser_pykotaBalance', '', 'pykotaBalance'));
		$profileContainer->add(new htmlResponsiveInputField(_('Overcharge factor'), 'pykotaUser_pykotaOverCharge', '', 'pykotaOverCharge'));
		$return['profile_options'] = $profileContainer;
		$return['profile_mappings']['pykotaUser_pykotaLimitBy'] = 'pykotaLimitBy';
		$return['profile_mappings']['pykotaUser_pykotaOverCharge'] = 'pykotaOverCharge';
		$return['profile_checks']['pykotaUser_pykotaBalance'] = [
			'type' => 'ext_preg',
			'regex' => 'float',
			'error_message' => $this->messages['pykotaBalance'][0]];
		$return['profile_checks']['pykotaUser_pykotaOverCharge'] = [
			'type' => 'ext_preg',
			'regex' => 'float',
			'error_message' => $this->messages['pykotaOverCharge'][0]];
		// upload fields
		$return['upload_columns'] = [
			[
				'name' => 'pykotaUser_pykotaUserName',
				'description' => _('PyKota user name'),
				'help' => 'pykotaUserName',
				'example' => _('smiller'),
				'unique' => true,
			]
		];
		if ($this->isStructural()) {
			$return['upload_columns'][] = [
				'name' => 'pykotaUser_cn',
				'description' => _('Common name'),
				'help' => 'cn',
				'example' => _('Steve Miller'),
				'required' => true,
			];
		}
		$return['upload_columns'][] = [
			'name' => 'pykotaUser_pykotaLimitBy',
			'description' => _('Limit type'),
			'help' => 'pykotaLimitBy',
			'example' => _('Quota'),
			'default' => _('Quota'),
			'values' => implode(', ', array_keys($this->limitOptions))
		];
		$return['upload_columns'][] = [
			'name' => 'pykotaUser_pykotaBalance',
			'description' => _('Balance'),
			'help' => 'pykotaBalance',
			'example' => '10.0',
		];
		$return['upload_columns'][] = [
			'name' => 'pykotaUser_pykotaBalanceComment',
			'description' => _('Balance comment'),
			'help' => 'pykotaBalanceComment',
			'example' => _('Initial payment'),
		];
		$return['upload_columns'][] = [
			'name' => 'pykotaUser_pykotaOverCharge',
			'description' => _('Overcharge factor'),
			'help' => 'pykotaOverCharge',
			'example' => '1.0',
			'default' => '1.0'
		];
		// available PDF fields
		$return['PDF_fields'] = [
			'pykotaUserName' => _('PyKota user name'),
			'pykotaLimitBy' => _('Limit type'),
			'pykotaBalance' => _('Balance'),
			'pykotaOverCharge' => _('Overcharge factor'),
			'pykotaLifeTimePaid' => _('Total paid'),
			'pykotaPayments' => _('Payment history'),
		];
		if ($this->isStructural()) {
			$return['PDF_fields']['cn'] = _('Common name');
		}
		// self-service
		$return['selfServiceFieldSettings'] = [
			'pykotaBalance' => _('Balance (read-only)'),
			'pykotaLifeTimePaid' => _('Total paid (read-only)'),
			'pykotaPayments' => _('Payment history'),
			'pykotaJobHistory' => _('Job history'),
		];
		// self-service settings
		if (static::class === 'pykotaUser') {
			$selfServiceContainer = new htmlResponsiveRow();
			$selfServiceContainer->add(new htmlResponsiveInputField(_('Job suffix'), 'pykotaUser_jobSuffix', null, ['jobSuffix', static::class]));
			$return['selfServiceSettings'] = $selfServiceContainer;
		}
		// configuration checks
		$return['config_checks']['all']['pykotaUser_jobSuffix'] = [
			'type' => 'ext_preg',
			'regex' => 'dn',
			'required' => false,
			'required_message' => $this->messages['jobSuffix'][0],
			'error_message' => $this->messages['jobSuffix'][0]];
		return $return;
	}

	/**
	 * {@inheritDoc}
	 */
	protected function load_Messages(): void {
		$this->messages['uid'][0] = ['ERROR', _('User name'), _('User name contains invalid characters. Valid characters are: a-z, A-Z, 0-9 and .-_ !')];
		$this->messages['uid'][1] = ['ERROR', _('Account %s:') . ' pykotaUser_uid', _('User name contains invalid characters. Valid characters are: a-z, A-Z, 0-9 and .-_ !')];
		$this->messages['uid'][2] = ['ERROR', _('User name'), _('User name already exists!')];
		$this->messages['uid'][3] = ['ERROR', _('Account %s:') . ' pykotaUser_uid', _('User name already exists!')];
		$this->messages['pykotaUserName'][0] = ['ERROR', _('PyKota user name'), _('User name contains invalid characters. Valid characters are: a-z, A-Z, 0-9 and .-_ !')];
		$this->messages['pykotaUserName'][1] = ['ERROR', _('Account %s:') . ' pykotaUser_pykotaUserName', _('User name contains invalid characters. Valid characters are: a-z, A-Z, 0-9 and .-_ !')];
		$this->messages['pykotaUserName'][2] = ['ERROR', _('PyKota user name'), _('User name already exists!')];
		$this->messages['pykotaUserName'][3] = ['ERROR', _('Account %s:') . ' pykotaUser_pykotaUserName', _('User name already exists!')];
		$this->messages['mail'][0] = ['ERROR', _('Email address'), _('Please enter a valid email address!')];
		$this->messages['mail'][1] = ['ERROR', _('Account %s:') . ' pykotaUser_mail', _('Please enter a valid email address!')];
		$this->messages['pykotaLimitBy'][0] = ['ERROR', _('Account %s:') . ' pykotaUser_pykotaLimitBy', _('Please enter a valid limit type.')];
		$this->messages['pykotaBalance'][0] = ['ERROR', _('Balance'), _('Please enter a valid number (e.g. "1.5").')];
		$this->messages['pykotaBalance'][1] = ['ERROR', _('Account %s:') . ' pykotaUser_pykotaBalance', _('Please enter a valid number (e.g. "1.5").')];
		$this->messages['pykotaOverCharge'][0] = ['ERROR', _('Overcharge factor'), _('Please enter a valid number (e.g. "1.5").')];
		$this->messages['pykotaOverCharge'][1] = ['ERROR', _('Account %s:') . ' pykotaUser_pykotaOverCharge', _('Please enter a valid number (e.g. "1.5").')];
		$this->messages['pykotaPayments'][0] = ['ERROR', _('Payment'), _('Please enter a valid number (e.g. "1.5").')];
		$this->messages['jobSuffix'][0] = ['ERROR', _('Job suffix'), _('Please enter a valid job suffix.')];
	}

	/**
	 * {@inheritDoc}
	 */
	public function loadAttributesFromAccountCopy(array $ldapAttributes, array $attributesToIgnore = []): void {
		$attributesToIgnore = array_merge(baseModule::ATTRIBUTES_TO_IGNORE_ON_COPY_DEFAULT, self::ATTRIBUTES_TO_IGNORE_ON_COPY);
		parent::loadAttributesFromAccountCopy($ldapAttributes, $attributesToIgnore);
	}

	/**
	 * Returns the HTML meta data for the main account page.
	 *
	 * @return htmlElement HTML meta data
	 */
	function display_html_attributes() {
		$container = new htmlResponsiveRow();
		$modules = $this->getAccountContainer()->get_type()->getModules();
		if ($this->isStructural() || (isset($this->attributes['objectClass']) && in_array('pykotaAccount', $this->attributes['objectClass']))) {
			// uid
			if ($this->manageUid($modules)) {
				$this->addSimpleInputTextField($container, 'uid', _('User name'), true);
			}
			else {
				// require uid
				$uid = $this->getCurrentUserName();
				if (empty($uid)) {
					$page = '';
					if ($this->getAccountContainer()->getAccountModule('posixAccount') != null) {
						$page = $this->getAccountContainer()->getAccountModule('posixAccount')->get_alias();
					}
					elseif ($this->getAccountContainer()->getAccountModule('inetOrgPerson') != null) {
						$page = $this->getAccountContainer()->getAccountModule('inetOrgPerson')->get_alias();
					}
					$msg = new htmlStatusMessage('INFO', sprintf(_("Please enter an user name on this page: %s"), $page));
					$container->add($msg);
				}
			}
			// pykotaUserName
			$this->addSimpleInputTextField($container, 'pykotaUserName', _('Pykota user name'));
			// balance
			$pykotaBalance = '';
			if (isset($this->attributes['pykotaBalance'][0])) {
				$pykotaBalance = $this->attributes['pykotaBalance'][0];
			}
			$container->addLabel(new htmlOutputText(_('Balance')));
			$balanceGroup = new htmlGroup();
			$balanceGroup->addElement(new htmlOutputText($pykotaBalance));
			$balanceGroup->addElement(new htmlSpacer('0.5rem', null));
			$balanceGroup->addElement(new htmlHelpLink('pykotaBalance'));
			$container->addField($balanceGroup);
			$container->addLabel(new htmlOutputText('&nbsp;', false));
			$historyGroup = new htmlGroup();
			$historyGroup->addElement(new htmlAccountPageButton(static::class, 'payments', 'open', _('Payment history')));
			if (!$this->getAccountContainer()->isNewAccount && !empty($this->moduleSettings['pykotaUser_jobSuffix'][0])) {
				$historyGroup->addElement(new htmlSpacer('5px', null));
				$historyGroup->addElement(new htmlAccountPageButton(static::class, 'jobs', 'open', _('Job history')));
			}
			$historyGroup->addElement(new htmlSpacer('5px', null));
			$historyGroup->addElement(new htmlHelpLink('pykotaPayments'));
			$container->addField($historyGroup);
			// limit by
			$limitOption = 'quota';
			if (!empty($this->attributes['pykotaLimitBy'][0])) {
				$limitOption = $this->attributes['pykotaLimitBy'][0];
			}
			$limitSelect = new htmlResponsiveSelect('pykotaLimitBy', $this->limitOptions, [$limitOption], _('Limit type'), 'pykotaLimitBy');
			$limitSelect->setHasDescriptiveElements(true);
			$limitSelect->setSortElements(false);
			$container->add($limitSelect);
			// overcharge factor
			$this->addSimpleInputTextField($container, 'pykotaOverCharge', _('Overcharge factor'));
			// cn
			if ($this->isStructural()) {
				$this->addSimpleInputTextField($container, 'cn', _('Common name'), true);
			}
			// mail
			if ($this->manageMail($modules)) {
				$this->addSimpleInputTextField($container, 'mail', _('Email address'));
			}
			// description
			if ($this->manageDescription($modules)) {
				$this->addMultiValueInputTextField($container, 'description', _('Description'), false, null, true);
			}
			// new payment
			$container->add(new htmlSubTitle(_('Payment')));
			$newPaymentAmount = new htmlResponsiveInputField(_('Amount'), 'pykotaBalanceAdd', '', '5em');
			$container->add($newPaymentAmount);
			$newPaymentComment = new htmlResponsiveInputField(_('Comment'), 'pykotaBalanceComment', '', '20em');
			$container->add($newPaymentComment);
			$newPaymentBtn = new htmlButton('addPayment', _('Add'));
			$newPaymentGroup = new htmlGroup();
			$newPaymentGroup->addElement($newPaymentBtn);
			$newPaymentGroup->addElement(new htmlSpacer('0.5rem', null));
			$newPaymentGroup->addElement(new htmlHelpLink('pykotaPaymentsAdd'));
			$container->add($newPaymentGroup, 12, 12, 12, 'text-center');
			// remove button
			if (!$this->isStructural()) {
				$container->addVerticalSpacer('2rem');
				$remButton = new htmlButton('remObjectClass', _('Remove PyKota extension'));
				$remButton->setCSSClasses(['lam-danger']);
				$container->add($remButton, 12, 12, 12, 'text-center');
			}
		}
		else {
			// add button
			$container->add(new htmlButton('addObjectClass', _('Add PyKota extension')));
		}
		return $container;
	}

	/**
	 * {@inheritDoc}
	 */
	public function process_attributes(): array {
		$errors = [];
		if (isset($_POST['addObjectClass'])) {
			if (!isset($this->attributes['objectClass'])) {
				$this->attributes['objectClass'] = [];
			}
			if (!in_array('pykotaAccount', $this->attributes['objectClass'])) {
				$this->attributes['objectClass'][] = 'pykotaAccount';
			}
			if (!in_array('pykotaAccountBalance', $this->attributes['objectClass'])) {
				$this->attributes['objectClass'][] = 'pykotaAccountBalance';
			}
			if (!isset($this->attributes['pykotaUserName'][0])) {
				$this->attributes['pykotaUserName'][0] = $this->getCurrentUserName();
			}
			return $errors;
		}
		$modules = $this->getAccountContainer()->get_type()->getModules();
		if (isset($_POST['remObjectClass'])) {
			$this->attributes['objectClass'] = array_delete(['pykotaAccount', 'pykotaAccountBalance'], $this->attributes['objectClass']);
			$attrs = ['pykotaLimitBy', 'pykotaUserName'];
			if ($this->manageDescription($modules)) {
				$attrs[] = 'description';
			}
			if ($this->manageMail($modules)) {
				$attrs[] = 'mail';
			}
			if ($this->manageUid($modules)) {
				$attrs[] = 'uid';
			}
			foreach ($attrs as $name) {
				if (isset($this->attributes[$name])) {
					unset($this->attributes[$name]);
				}
			}
			return $errors;
		}
		// skip processing if object class is not set
		if (!isset($this->attributes['objectClass']) || !in_array('pykotaAccount', $this->attributes['objectClass'])) {
			return $errors;
		}
		// uid
		if ($this->manageUid($modules)) {
			if (isset($_POST['uid']) && ($_POST['uid'] != '')) {
				if (!get_preg($_POST['uid'], 'username')) {
					$errors[] = $this->messages['uid'][0];
				}
				else {
					$this->attributes['uid'][0] = $_POST['uid'];
					if ((!isset($this->orig['uid'][0]) || ($this->attributes['uid'][0] != $this->orig['uid'][0]))
						&& $this->uidExists($_POST['uid'])) {
						$errors[] = $this->messages['uid'][2];
					}
				}
			}
			elseif (isset($this->attributes['uid'][0])) {
				unset($this->attributes['uid'][0]);
			}
		}
		// PyKota user name
		if (!empty($_POST['pykotaUserName'])) {
			if (!get_preg($_POST['pykotaUserName'], 'username')) {
				$errors[] = $this->messages['pykotaUserName'][0];
			}
			else {
				$this->attributes['pykotaUserName'][0] = $_POST['pykotaUserName'];
				if ((!isset($this->orig['pykotaUserName'][0]) || ($this->attributes['pykotaUserName'][0] != $this->orig['pykotaUserName'][0]))
					&& $this->pykotaUserNameExists($_POST['pykotaUserName'])) {
					$errors[] = $this->messages['pykotaUserName'][2];
				}
			}
		}
		else {
			$this->attributes['pykotaUserName'][0] = $this->getCurrentUserName();
		}
		// limit by
		$this->attributes['pykotaLimitBy'][0] = $_POST['pykotaLimitBy'];
		// cn
		if ($this->isStructural()) {
			$this->attributes['cn'][0] = $_POST['cn'];
			if (empty($this->attributes['cn'][0])) {
				$this->attributes['cn'][0] = $_POST['uid'];
			}
		}
		// mail
		if ($this->manageMail($modules)) {
			$this->attributes['mail'][0] = $_POST['mail'];
			if (!empty($_POST['mail']) && !get_preg($_POST['mail'], 'email')) {
				$errors[] = $this->messages['mail'][0];
			}
		}
		// description
		if ($this->manageDescription($modules)) {
			$this->processMultiValueInputTextField('description', $errors);
		}
		// overcharge factor
		$this->attributes['pykotaOverCharge'][0] = empty($_POST['pykotaOverCharge']) ? '1.0' : $_POST['pykotaOverCharge'];
		// add payment
		if (isset($_POST['addPayment'])) {
			$amount = $_POST['pykotaBalanceAdd'];
			if (!empty($amount) && (str_contains($amount, ','))) {
				$amount = str_replace(',', '.', $amount);
			}
			if (!empty($amount) && (!str_contains($amount, '.'))) {
				$amount .= '.0';
			}
			$comment = $_POST['pykotaBalanceComment'];
			if (!empty($comment)) {
				$comment = base64_encode($comment);
			}
			if (empty($amount) || (floatval($amount) === 0.0)) {
				$errors[] = $this->messages['pykotaPayments'][0];
			}
			else {
				$this->attributes['pykotaPayments'][] = getFormattedTime('Y-m-d H:i:s,00') . ' # ' . $amount . ' # ' . $comment;
				// new balance
				$newBalance = 0.0;
				if (!empty($this->attributes['pykotaBalance'][0])) {
					$newBalance = floatval($this->attributes['pykotaBalance'][0]);
				}
				$newBalance += $amount;
				$this->attributes['pykotaBalance'][0] = strval($newBalance);
				// total paid
				$total = 0.0;
				if (!empty($this->attributes['pykotaLifeTimePaid'][0])) {
					$total = floatval($this->attributes['pykotaLifeTimePaid'][0]);
				}
				$total += $amount;
				$this->attributes['pykotaLifeTimePaid'][0] = strval($total);
			}
		}
		return $errors;
	}

	/**
	 * Returns the HTML meta data for the payments page.
	 *
	 * @return htmlElement HTML meta data
	 */
	public function display_html_payments(): htmlElement {
		$container = new htmlResponsiveRow();
		// total paid
		$total = '';
		if (!empty($this->attributes['pykotaLifeTimePaid'][0])) {
			$total = $this->attributes['pykotaLifeTimePaid'][0];
		}
		$container->addLabel(new htmlOutputText(_('Total paid')));
		$totalPaidGroup = new htmlGroup();
		$totalPaidGroup->addElement(new htmlOutputText($total));
		$totalPaidGroup->addElement(new htmlSpacer('0.5rem', null));
		$totalPaidGroup->addElement(new htmlHelpLink('pykotaLifeTimePaid'));
		$container->addField($totalPaidGroup);
		// payment/job history
		if (!empty($this->attributes['pykotaPayments'][0])) {
			$container->add(new htmlSubTitle(_('Payment history')));
			$labels = [_('Date'), _('Amount'), _('Comment')];
			$data = [];
			rsort($this->attributes['pykotaPayments']);
			foreach ($this->attributes['pykotaPayments'] as $payment) {
				$parts = explode(' # ', $payment);
				$comment = empty($parts[2]) ? '' : base64_decode($parts[2]);
				$commentField = new htmlOutputText($comment);
				$amountFied = new htmlOutputText($parts[1]);
				$data[] = [
					new htmlOutputText($parts[0]),
					$amountFied,
					$commentField
				];
			}
			$historyTable = new htmlResponsiveTable($labels, $data);
			$historyTable->setWidths(['20%', '15%', '65%']);
			$container->add($historyTable);
		}
		// back button
		$container->addVerticalSpacer('2rem');
		$backButton = new htmlAccountPageButton(static::class, 'attributes', 'back', _('Back'));
		$container->add($backButton);
		return $container;
	}

	/**
	 * Processes user input of the payments module page.
	 * It checks if all input values are correct and updates the associated LDAP attributes.
	 *
	 * @return string[][] list of info/error messages
	 */
	public function process_payments(): array {
		return [];
	}

	/**
	 * Returns the HTML meta data for the jobs page.
	 *
	 * @return htmlElement HTML meta data
	 */
	public function display_html_jobs(): htmlElement {
		$container = new htmlResponsiveRow();
		// jobs
		$jobs = $this->getJobs($this->getCurrentUserName(), $this->moduleSettings['pykotaUser_jobSuffix'][0]);
		$titles = [
			_('Date'), _('Printer'), _('Price'), _('Size'), _('Title')
		];
		$data = [];
		foreach ($jobs as $job) {
			$data[] = [
				new htmlOutputText(formatLDAPTimestamp($job['createtimestamp'][0])),
				new htmlOutputText($job['pykotaprintername'][0]),
				new htmlOutputText($job['pykotajobprice'][0]),
				new htmlOutputText($job['pykotajobsize'][0]),
				new htmlOutputText($job['pykotatitle'][0])
			];
		}
		$table = new htmlResponsiveTable($titles, $data);
		$table->setWidths(['20%', '20%', '10%', '10%', '40%']);
		$container->add($table);
		// back button
		$container->addVerticalSpacer('2rem');
		$backButton = new htmlAccountPageButton(static::class, 'attributes', 'back', _('Back'));
		$container->add($backButton);
		return $container;
	}

	/**
	 * Processes user input of the jobs module page.
	 * It checks if all input values are correct and updates the associated LDAP attributes.
	 *
	 * @return string[][] list of info/error messages
	 */
	public function process_jobs(): array {
		return [];
	}

	/**
	 * {@inheritDoc}
	 */
	public function save_attributes(): array {
		if (!in_array('pykotaAccount', $this->attributes['objectClass']) && !in_array('pykotaAccount', $this->orig['objectClass'])) {
			// skip saving if the extension was not added/modified
			return [];
		}
		return parent::save_attributes();
	}

	/**
	 * {@inheritDoc}
	 */
	public function module_complete(): bool {
		if (in_array('pykotaAccount', $this->attributes['objectClass'])) {
			// require uid
			$uid = $this->getCurrentUserName();
			return !empty($uid);
		}
		return true;
	}

	/**
	 * {@inheritDoc}
	 */
	public function load_profile(array $profile): void {
		// profile mappings in meta data
		parent::load_profile($profile);
		// add extension
		if (isset($profile['pykotaUser_addExt'][0]) && ($profile['pykotaUser_addExt'][0] == "true")) {
			if (!in_array('pykotaAccount', $this->attributes['objectClass'])) {
				$this->attributes['objectClass'][] = 'pykotaAccount';
			}
			if (!in_array('pykotaAccountBalance', $this->attributes['objectClass'])) {
				$this->attributes['objectClass'][] = 'pykotaAccountBalance';
			}
		}
		if (isset($profile['pykotaUser_pykotaBalance'][0]) && ($profile['pykotaUser_pykotaBalance'][0] !== '') && empty($this->attributes['pykotaBalance'][0])) {
			$amount = $profile['pykotaUser_pykotaBalance'][0];
			if (!str_contains($amount, '.')) {
				$amount .= '.0';
			}
			$this->attributes['pykotaBalance'][0] = $amount;
			$this->attributes['pykotaLifeTimePaid'][0] = $amount;
			$this->attributes['pykotaPayments'][] = getFormattedTime('Y-m-d H:i:s,00') . ' # ' . $amount . ' # ';
		}
	}

	/**
	 * {@inheritDoc}
	 */
	public function get_uploadColumns(array $selectedModules, ConfiguredType $type): array {
		$return = parent::get_uploadColumns($selectedModules, $type);
		if ($this->manageUid($selectedModules)) {
			$return[] = [
				'name' => 'pykotaUser_uid',
				'description' => _('User name'),
				'help' => 'uid',
				'example' => _('smiller'),
				'required' => true,
				'unique' => true,
			];
		}
		if ($this->manageMail($selectedModules)) {
			$return[] = [
				'name' => 'pykotaUser_mail',
				'description' => _('Email address'),
				'help' => 'mail',
				'example' => _('user@company.com'),
			];
		}
		if ($this->manageDescription($selectedModules)) {
			$return[] = [
				'name' => 'pykotaUser_description',
				'description' => _('Description'),
				'help' => 'description',
				'example' => _('Temp, contract till December'),
			];
		}
		return $return;
	}

	/**
	 * {@inheritDoc}
	 */
	public function build_uploadAccounts(array $rawAccounts, array $ids, array &$partialAccounts, array $selectedModules, ConfiguredType &$type): array {
		$messages = [];
		for ($i = 0; $i < count($rawAccounts); $i++) {
			// add object classes
			if (!in_array('pykotaAccount', $partialAccounts[$i]['objectClass'])) {
				$partialAccounts[$i]['objectClass'][] = 'pykotaAccount';
			}
			if (!in_array('pykotaAccountBalance', $partialAccounts[$i]['objectClass'])) {
				$partialAccounts[$i]['objectClass'][] = 'pykotaAccountBalance';
			}
			if ($this->isStructural() && !in_array('pykotaObject', $partialAccounts[$i]['objectClass'])) {
				$partialAccounts[$i]['objectClass'][] = 'pykotaObject';
			}
			// cn
			if ($this->isStructural()) {
				$partialAccounts[$i]['cn'] = $rawAccounts[$i][$ids['pykotaUser_cn']];
			}
			// uid
			if ($this->manageUid($selectedModules) && !empty($rawAccounts[$i][$ids['pykotaUser_uid']])) {
				if (!get_preg($rawAccounts[$i][$ids['pykotaUser_uid']], 'username')) {
					$errMsg = $this->messages['uid'][1];
					$errMsg[] = [$i];
					$messages[] = $errMsg;
				}
				elseif ($this->uidExists($rawAccounts[$i][$ids['pykotaUser_uid']])) {
					$errMsg = $this->messages['uid'][3];
					$errMsg[] = [$i];
					$messages[] = $errMsg;
				}
				else {
					$partialAccounts[$i]['uid'] = $rawAccounts[$i][$ids['pykotaUser_uid']];
				}
			}
			// mail
			if ($this->manageUid($selectedModules) && !empty($rawAccounts[$i][$ids['pykotaUser_mail']])) {
				$this->mapSimpleUploadField($rawAccounts, $ids, $partialAccounts, $i, 'pykotaUser_mail', 'mail',
					'email', $this->messages['mail'][1], $messages);
			}
			// description
			$this->mapSimpleUploadField($rawAccounts, $ids, $partialAccounts, $i, 'pykotaUser_description', 'description');
			// PyKota user name
			if (!empty($rawAccounts[$i][$ids['pykotaUser_pykotaUserName']])) {
				if (!get_preg($rawAccounts[$i][$ids['pykotaUser_pykotaUserName']], 'username')) {
					$errMsg = $this->messages['pykotaUserName'][1];
					$errMsg[] = [$i];
					$messages[] = $errMsg;
				}
				elseif ($this->pykotaUserNameExists($rawAccounts[$i][$ids['pykotaUser_pykotaUserName']])) {
					$errMsg = $this->messages['pykotaUserName'][3];
					$errMsg[] = [$i];
					$messages[] = $errMsg;
				}
				else {
					$partialAccounts[$i]['pykotaUserName'] = $rawAccounts[$i][$ids['pykotaUser_pykotaUserName']];
				}
			}
			// limit by
			if (!empty($rawAccounts[$i][$ids['pykotaUser_pykotaLimitBy']])) {
				if (isset($this->limitOptions[$rawAccounts[$i][$ids['pykotaUser_pykotaLimitBy']]])) {
					$partialAccounts[$i]['pykotaLimitBy'] = $this->limitOptions[$rawAccounts[$i][$ids['pykotaUser_pykotaLimitBy']]];
				}
				else {
					$errMsg = $this->messages['pykotaLimitBy'][0];
					$errMsg[] = [$i];
					$messages[] = $errMsg;
				}
			}
			else {
				$partialAccounts[$i]['pykotaLimitBy'] = 'quota';
			}
			// overcharge factor
			if (!empty($rawAccounts[$i][$ids['pykotaUser_pykotaOverCharge']])) {
				$pykotaOverCharge = $rawAccounts[$i][$ids['pykotaUser_pykotaOverCharge']];
				if (!str_contains($pykotaOverCharge, '.')) {
					$pykotaOverCharge .= '.0';
				}
				if (!get_preg($pykotaOverCharge, 'float')) {
					$errMsg = $this->messages['pykotaOverCharge'][1];
					$errMsg[] = [$i];
					$messages[] = $errMsg;
				}
				else {
					$partialAccounts[$i]['pykotaOverCharge'] = $pykotaOverCharge;
				}
			}
			else {
				$partialAccounts[$i]['pykotaOverCharge'] = '1.0';
			}
			// balance
			if (!empty($rawAccounts[$i][$ids['pykotaUser_pykotaBalance']])) {
				$balance = $rawAccounts[$i][$ids['pykotaUser_pykotaBalance']];
				if (!str_contains($balance, '.')) {
					$balance .= '.0';
				}
				if (!get_preg($balance, 'float')) {
					$errMsg = $this->messages['pykotaBalance'][1];
					$errMsg[] = [$i];
					$messages[] = $errMsg;
				}
				else {
					$partialAccounts[$i]['pykotaBalance'] = $balance;
					$partialAccounts[$i]['pykotaLifeTimePaid'] = $balance;
					$comment = '';
					if (!empty($rawAccounts[$i][$ids['pykotaUser_pykotaBalanceComment']])) {
						$comment = base64_encode($rawAccounts[$i][$ids['pykotaUser_pykotaBalanceComment']]);
					}
					$partialAccounts[$i]['pykotaPayments'][0] = getFormattedTime('Y-m-d H:i:s,00') . ' # ' . $balance . ' # ' . $comment;
				}
			}
		}
		return $messages;
	}

	/**
	 * {@inheritDoc}
	 */
	public function get_pdfFields(string $typeId): array {
		$fields = parent::get_pdfFields($typeId);
		$typeManager = new TypeManager();
		$modules = $typeManager->getConfiguredType($typeId)->getModules();
		if ($this->manageUid($modules)) {
			$fields['uid'] = _('User name');
		}
		if ($this->manageMail($modules)) {
			$fields['mail'] = _('Email address');
		}
		if ($this->manageDescription($modules)) {
			$fields['description'] = _('Description');
		}
		return $fields;
	}

	/**
	 * {@inheritDoc}
	 */
	public function get_pdfEntries(array $pdfKeys, string $typeId): array {
		$return = [];
		$this->addSimplePDFField($return, 'cn', _('Common name'));
		$this->addSimplePDFField($return, 'uid', _('User name'));
		$this->addSimplePDFField($return, 'mail', _('Email address'));
		$this->addSimplePDFField($return, 'pykotaUserName', _('PyKota user name'));
		$this->addSimplePDFField($return, 'description', _('Description'));
		$limitByOptions = array_flip($this->limitOptions);
		$limitByValue = '';
		if (!empty($this->attributes['pykotaLimitBy'][0]) && isset($limitByOptions[$this->attributes['pykotaLimitBy'][0]])) {
			$limitByValue = $limitByOptions[$this->attributes['pykotaLimitBy'][0]];
		}
		$this->addPDFKeyValue($return, 'pykotaLimitBy', _('Limit type'), $limitByValue);
		$this->addSimplePDFField($return, 'pykotaOverCharge', _('Overcharge factor'));
		$this->addSimplePDFField($return, 'pykotaBalance', _('Balance'));
		$this->addSimplePDFField($return, 'pykotaLifeTimePaid', _('Total paid'));
		// payment history
		if (!empty($this->attributes['pykotaPayments'][0])) {
			$pdfTable = new PDFTable();
			$pdfRow = new PDFTableRow();
			$pdfRow->cells[] = new PDFTableCell(_('Date'), '20%', null, true);
			$pdfRow->cells[] = new PDFTableCell(_('Amount'), '10%', null, true);
			$pdfRow->cells[] = new PDFTableCell(_('Comment'), '70%', null, true);
			$pdfTable->rows[] = $pdfRow;
			for ($i = 0; $i < count($this->attributes['pykotaPayments']); $i++) {
				$parts = explode(' # ', $this->attributes['pykotaPayments'][$i]);
				$comment = ' ';
				if (!empty($parts[2])) {
					$comment = base64_decode($parts[2]);
				}
				$pdfRow = new PDFTableRow();
				$pdfRow->cells[] = new PDFTableCell($parts[0], '20%');
				$pdfRow->cells[] = new PDFTableCell($parts[1], '10%', PDFTableCell::ALIGN_RIGHT);
				$pdfRow->cells[] = new PDFTableCell($comment, '70%');
				$pdfTable->rows[] = $pdfRow;
			}
			$this->addPDFTable($return, 'pykotaPayments', $pdfTable);
		}
		return $return;
	}

	/**
	 * {@inheritDoc}
	 */
	public function getSelfServiceOptions(array $fields, array $attributes, bool $passwordChangeOnly, array $readOnlyFields): array {
		if ($passwordChangeOnly) {
			return []; // no Kolab fields as long no LDAP content can be read
		}
		if (!in_array('pykotaAccount', $attributes['objectClass'])) {
			return [];
		}
		$return = [];
		if (in_array('pykotaBalance', $fields)) {
			$pykotaBalance = '';
			if (isset($attributes['pykotaBalance'][0])) {
				$pykotaBalance = $attributes['pykotaBalance'][0];
			}
			$row = new htmlResponsiveRow();
			$row->addLabel(new htmlOutputText($this->getSelfServiceLabel('pykotaBalance', _('Balance'))));
			$row->addField(new htmlOutputText($pykotaBalance));
			$return['pykotaBalance'] = $row;
		}
		if (in_array('pykotaLifeTimePaid', $fields)) {
			$pykotaLifeTimePaid = '';
			if (isset($attributes['pykotaLifeTimePaid'][0])) {
				$pykotaLifeTimePaid = $attributes['pykotaLifeTimePaid'][0];
			}
			$row = new htmlResponsiveRow();
			$row->addLabel(new htmlOutputText($this->getSelfServiceLabel('pykotaLifeTimePaid', _('Total paid'))));
			$row->addField(new htmlOutputText($pykotaLifeTimePaid));
			$return['pykotaLifeTimePaid'] = $row;
		}
		// payment history
		if (in_array('pykotaPayments', $fields)) {
			$pykotaPayments = new htmlResponsiveRow();
			if (!empty($attributes['pykotaPayments'][0])) {
				$pykotaPayments->add(new htmlOutputText(_('Date')), 3, 3, 3, 'bold');
				$pykotaPayments->add(new htmlOutputText(_('Amount')), 3, 3, 3, 'bold');
				$pykotaPayments->add(new htmlOutputText(_('Comment')), 6, 6, 6, 'bold');
				rsort($attributes['pykotaPayments']);
				foreach ($attributes['pykotaPayments'] as $payment) {
					$parts = explode(' # ', $payment);
					$pykotaPayments->add(new htmlOutputText($parts[0]), 3);
					$amount = new htmlOutputText($parts[1]);
					$amount->alignment = htmlElement::ALIGN_RIGHT;
					$pykotaPayments->add($amount, 3);
					$pykotaPayments->add(new htmlOutputText(base64_decode($parts[2])), 6);
				}
			}
			$row = new htmlResponsiveRow();
			$row->add(new htmlSpacer(null, '10px'));
			$row = new htmlResponsiveRow();
			$row->add(new htmlOutputText($this->getSelfServiceLabel('pykotaPayments', _('Payment history'))), 12, 12, 12, 'bold text-left');
			$row->add($pykotaPayments);
			$return['pykotaPayments'] = $row;
		}
		// job history
		if (in_array('pykotaJobHistory', $fields) && !empty($this->selfServiceSettings->moduleSettings['pykotaUser_jobSuffix'][0]) && !empty($attributes['pykotaUserName'][0])) {
			$jobs = $this->getJobs($attributes['pykotaUserName'][0], $this->selfServiceSettings->moduleSettings['pykotaUser_jobSuffix'][0]);
			$pykotaJobs = new htmlResponsiveRow();
			$pykotaJobs->add(new htmlOutputText(_('Date')), 3, 3, 3, 'bold');
			$pykotaJobs->add(new htmlOutputText(_('Printer')), 3, 3, 3, 'bold');
			$pykotaJobs->add(new htmlOutputText(_('Price')), 2, 2, 2, 'bold');
			$pykotaJobs->add(new htmlOutputText(_('Size')), 1, 1, 1, 'bold');
			$title = new htmlOutputText(_('Title'));
			$title->alignment = htmlElement::ALIGN_LEFT;
			$pykotaJobs->add($title, 3, 3, 3, 'bold');
			foreach ($jobs as $job) {
				$pykotaJobs->add(new htmlOutputText(formatLDAPTimestamp($job['createtimestamp'][0])), 3);
				$pykotaJobs->add(new htmlOutputText($job['pykotaprintername'][0]), 3);
				$price = new htmlOutputText($job['pykotajobprice'][0]);
				$price->alignment = htmlElement::ALIGN_RIGHT;
				$pykotaJobs->add($price, 2);
				$size = new htmlOutputText($job['pykotajobsize'][0]);
				$size->alignment = htmlElement::ALIGN_RIGHT;
				$pykotaJobs->add($size, 1);
				$pykotaJobs->add(new htmlOutputText($job['pykotatitle'][0]), 3);
			}
			$row = new htmlResponsiveRow();
			$row->add(new htmlSpacer(null, '10px'));
			$row->add(new htmlOutputText($this->getSelfServiceLabel('pykotaJobHistory', _('Job history'))), 12, 12, 12, 'bold text-left');
			$row->add($pykotaJobs);
			$return['pykotaJobHistory'] = $row;
		}
		return $return;
	}

	/**
	 * {@inheritDoc}
	 */
	public function checkSelfServiceSettings(array &$options, selfServiceProfile &$profile): array {
		$errors = [];
		if ((static::class === 'pykotaUser')
			&& !empty($options['pykotaUser_jobSuffix'][0])
			&& !get_preg($options['pykotaUser_jobSuffix'][0], 'dn')) {
			$errors[] = $this->messages['jobSuffix'][0];
		}
		return $errors;
	}

	/**
	 * Returns if the uid attribute should be managed.
	 *
	 * @param string[] $modules account modules
	 * @return boolean manage uid attribute
	 */
	private function manageUid($modules) {
		return !in_array('inetOrgPerson', $modules) && !in_array('posixAccount', $modules);
	}

	/**
	 * Returns if the mail attribute should be managed.
	 *
	 * @param string[] $modules account modules
	 * @return boolean manage mail attribute
	 */
	private function manageMail($modules) {
		return !in_array('inetOrgPerson', $modules);
	}

	/**
	 * Returns if the description attribute should be managed.
	 *
	 * @param string[] $modules account modules
	 * @return boolean manage description attribute
	 */
	private function manageDescription($modules) {
		return !in_array('inetOrgPerson', $modules);
	}

	/**
	 * Returns if the given uid already exists.
	 *
	 * @param String $uid uid attribute value
	 * @return boolean uid exists
	 */
	private function uidExists($uid) {
		if ($this->uidCache === null) {
			$this->loadUserNameCache();
		}
		return in_array($uid, $this->uidCache);
	}

	/**
	 * Returns if the given pykotaUserName already exists.
	 *
	 * @param String $pykotaUserName pykotaUserName attribute value
	 * @return boolean pykotaUserName exists
	 */
	private function pykotaUserNameExists($pykotaUserName) {
		if ($this->pykotaUserNameCache === null) {
			$this->loadUserNameCache();
		}
		return in_array($pykotaUserName, $this->pykotaUserNameCache);
	}

	/**
	 * Loads the list of user names into the cache.
	 */
	private function loadUserNameCache(): void {
		$results = searchLDAPByFilter('(|(uid=*)(pykotaUserName=*))', ['uid', 'pykotaUserName'], [$this->get_scope()]);
		$this->uidCache = [];
		$this->pykotaUserNameCache = [];
		foreach ($results as $result) {
			if (isset($result['uid'][0])) {
				$this->uidCache[] = $result['uid'][0];
			}
			if (isset($result['pykotausername'][0])) {
				$this->pykotaUserNameCache[] = $result['pykotausername'][0];
			}
		}
	}

	/**
	 * Returns the current user name (uid) of this account.
	 *
	 * @return String user name
	 */
	private function getCurrentUserName() {
		if (!empty($this->attributes['uid'][0])) {
			return $this->attributes['uid'][0];
		}
		if ($this->getAccountContainer()->getAccountModule('posixAccount') != null) {
			$posix = $this->getAccountContainer()->getAccountModule('posixAccount');
			$attrs = $posix->getAttributes();
			if (!empty($attrs['uid'][0])) {
				return $attrs['uid'][0];
			}
		}
		if ($this->getAccountContainer()->getAccountModule('inetOrgPerson') != null) {
			$personal = $this->getAccountContainer()->getAccountModule('inetOrgPerson');
			$attrs = $personal->getAttributes();
			if (!empty($attrs['uid'][0])) {
				return $attrs['uid'][0];
			}
		}
		return '';
	}

	/**
	 * Returns a list of jobs for the given user reverse-sorted by date.
	 * The number of jobs is limited to 100.
	 *
	 * @param string $user user name
	 * @param string $suffix LDAP suffix for job objects
	 * @return array<string, string[]|string>[] jobs
	 */
	private function getJobs($user, $suffix): array {
		$attrs = ['createTimestamp', 'pykotaTitle', 'pykotaPrinterName', 'pykotaJobPrice', 'pykotaJobSize'];
		$filter = '(&(objectClass=pykotaJob)(pykotaUserName=' . $user . '))';
		$jobList = searchLDAP($suffix, $filter, $attrs);
		$jobs = [];
		foreach ($jobList as $index => $job) {
			$jobs[$job['createtimestamp'][0] . $index] = $job;
		}
		krsort($jobs);
		if (count($jobs) > 100) {
			$jobs = array_slice($jobs, 0, 100);
		}
		return array_values($jobs);
	}

	/**
	 * {@inheritDoc}
	 */
	public function get_configOptions(array $scopes, array $allScopes): htmlElement|array {
		$configContainer = new htmlResponsiveRow();
		$configContainer->add(new htmlResponsiveInputField(_('Job suffix'), 'pykotaUser_jobSuffix', '', 'jobSuffix'));
		return $configContainer;
	}

	/**
	 * @inheritDoc
	 */
	public function getListAttributeDescriptions(ConfiguredType $type): array {
		return [
			'pykotausername' => _('PyKota user name'),
			'pykotalimitby' => _('Limit type'),
			'pykotabalance' => _('Balance'),
			'pykotaovercharge' => _('Overcharge factor'),
			'pykotalifetimepaid' => _('Total paid'),
			'pykotapayments' => _('Payment history'),
		];
	}

	/**
	 * @inheritDoc
	 */
	public function getListRenderFunction(string $attributeName): ?callable {
		if ($attributeName === 'mail') {
			return function(array $entry, string $attribute): htmlElement {
				$group = new htmlGroup();
				if (isset($entry[$attribute][0]) && ($entry[$attribute][0] != '')) {
					for ($i = 0; $i < count($entry[$attribute]); $i++) {
						if ($i > 0) {
							$group->addElement(new htmlOutputText(", "));
						}
						$group->addElement(new htmlLink($entry[$attribute][$i], "mailto:" . $entry[$attribute][$i]));
					}
				}
				return $group;
			};
		}
		return null;
	}

}
