<?

use Bitrix\Calendar\Access\ActionDictionary;
use Bitrix\Calendar\Access\Model\TypeModel;
use Bitrix\Calendar\Access\TypeAccessController;
use Bitrix\Main\Loader;
use Bitrix\Calendar\Util;
use Bitrix\Main\UserTable;

class CCalendarType
{
	public const OPERATION_VIEW = 'calendar_type_view';
	public const OPERATION_ADD = 'calendar_type_add';
	public const OPERATION_EDIT = 'calendar_type_edit';
	public const OPERATION_EDIT_SECTION = 'calendar_type_edit_section';
	public const OPERATION_EDIT_ACCESS = 'calendar_type_edit_access';
	private static
		$Permissions = [],
		$arOp = [],
		$userOperationsCache = [];

	public static function GetList($params = [])
	{
		global $DB;
		$access = new CAccess();
		$access->UpdateCodes();
		$arFilter = $params['arFilter'] ?? null;
		$result = false;
		$cacheId = false;
		$cachePath = '';
		$arOrder = $params['arOrder'] ?? Array('XML_ID' => 'asc');
		$checkPermissions = ($params['checkPermissions'] ?? true) !== false;

		$bCache = CCalendar::CacheTime() > 0;

		if ($bCache)
		{
			$cache = new CPHPCache;
			$cacheId = serialize(array('type_list', $arFilter, $arOrder));
			$cachePath = CCalendar::CachePath().'type_list';

			if ($cache->InitCache(CCalendar::CacheTime(), $cacheId, $cachePath))
			{
				$res = $cache->GetVars();
				$result = $res["arResult"];
				$arTypeXmlIds = $res["arTypeXmlIds"];
			}
		}

		if (!$bCache || !isset($arTypeXmlIds))
		{
			$arFields = [
				"XML_ID" => ["FIELD_NAME" => "CT.XML_ID", "FIELD_TYPE" => "string"],
				"NAME" => ["FIELD_NAME" => "CT.NAME", "FIELD_TYPE" => "string"],
				"ACTIVE" => ["FIELD_NAME" => "CT.ACTIVE", "FIELD_TYPE" => "string"],
				"DESCRIPTION" => ["FIELD_NAME" => "CT.DESCRIPTION", "FIELD_TYPE" => "string"],
				"EXTERNAL_ID" => ["FIELD_NAME" => "CT.EXTERNAL_ID", "FIELD_TYPE" => "string"]
			];

			$arSqlSearch = [];
			if(is_array($arFilter))
			{
				$filter_keys = array_keys($arFilter);
				foreach ($filter_keys as $i => $value)
				{
					$n = mb_strtoupper($value);
					$val = $arFilter[$value];

					if (is_string($val) && !$val)
					{
						continue;
					}

					if ($n === 'XML_ID')
					{
						if (is_array($val))
						{
							$strXml = "";
							foreach($val as $xmlId)
							{
								$strXml .= ",'" . $DB->ForSql($xmlId) . "'";
							}
							$arSqlSearch[] = "CT.XML_ID in (".trim($strXml, ", ").")";
						}
						else
						{
							$arSqlSearch[] = GetFilterQuery("CT.XML_ID", $val, 'N');
						}
					}
					if ($n === 'EXTERNAL_ID')
					{
						$arSqlSearch[] = GetFilterQuery("CT.EXTERNAL_ID", $val, 'N');
					}
					elseif (isset($arFields[$n]))
					{
						$arSqlSearch[] = GetFilterQuery($arFields[$n]["FIELD_NAME"], $val);
					}
				}
			}

			$strOrderBy = '';
			foreach($arOrder as $by=>$order)
			{
				if (isset($arFields[mb_strtoupper($by)]))
				{
					$strOrderBy .= $arFields[mb_strtoupper($by)]["FIELD_NAME"] . ' '
						. (mb_strtolower($order) === 'desc' ? 'desc' : 'asc') . ',';
				}
			}

			if ($strOrderBy)
			{
				$strOrderBy = "ORDER BY " . rtrim($strOrderBy, ",");
			}

			$strSqlSearch = GetFilterSqlSearch($arSqlSearch);

			$strSql = "
				SELECT
					CT.*
				FROM
					b_calendar_type CT
				WHERE
					$strSqlSearch
				$strOrderBy";

			$res = $DB->Query($strSql);
			$result = [];
			$arTypeXmlIds = [];
			while($arRes = $res->Fetch())
			{
				$result[] = $arRes;
				$arTypeXmlIds[] = $arRes['XML_ID'];
			}

			if ($bCache && isset($cache))
			{
				$cache->StartDataCache(CCalendar::CacheTime(), $cacheId, $cachePath);
				$cache->EndDataCache(array(
					"arResult" => $result,
					"arTypeXmlIds" => $arTypeXmlIds
				));
			}
		}

		if ($checkPermissions && !empty($arTypeXmlIds))
		{
			$arPerm = self::GetArrayPermissions($arTypeXmlIds);
			$res = [];
			$arAccessCodes = [];
			$accessController = new TypeAccessController(CCalendar::GetCurUserId());

			if (is_array($result))
			{
				foreach($result as $type)
				{
					$typeXmlId = $type['XML_ID'];
					$typeModel = TypeModel::createFromXmlId($typeXmlId);
					$request = [
						ActionDictionary::ACTION_TYPE_VIEW => [],
						ActionDictionary::ACTION_TYPE_EDIT => [],
						ActionDictionary::ACTION_TYPE_ACCESS => [],
					];

					$result = $accessController->batchCheck($request, $typeModel);
					if ($result[ActionDictionary::ACTION_TYPE_VIEW])
					{
						$type['PERM'] = [
							'view' => true,
							'add' => $result[ActionDictionary::ACTION_TYPE_EDIT],
							'edit' => $result[ActionDictionary::ACTION_TYPE_EDIT],
							'edit_section' => $result[ActionDictionary::ACTION_TYPE_EDIT],
							'access' => $result[ActionDictionary::ACTION_TYPE_ACCESS],
						];

						if ($result[ActionDictionary::ACTION_TYPE_ACCESS])
						{
							$type['ACCESS'] = [];
							if (!empty($arPerm[$typeXmlId]))
							{
								// Add codes to get they full names for interface
								$currentAccessCodes = array_keys($arPerm[$typeXmlId]);
								foreach ($currentAccessCodes as $code)
								{
									if (!in_array($code, $arAccessCodes, true))
									{
										$arAccessCodes[] = $code;
									}
								}
								$type['ACCESS'] = $arPerm[$typeXmlId];
							}
						}
						$res[] = $type;
					}
				}
			}

			CCalendar::PushAccessNames($arAccessCodes);
			$result = $res;
		}

		return $result;
	}

	public static function Edit($params)
	{
		global $DB;
		$arFields = $params['arFields'];
		$XML_ID = preg_replace("/[^a-zA-Z0-9_]/i", "", $arFields['XML_ID']);
		$arFields['XML_ID'] = $XML_ID;
		if (!isset($arFields['XML_ID']) || $XML_ID == "")
		{
			return false;
		}

		//return $APPLICATION->ThrowException(GetMessage("EC_ACCESS_DENIED"));

		$access = $arFields['ACCESS'] ?? null;
		unset($arFields['ACCESS']);

		if (count($arFields) > 1) // We have not only XML_ID
		{
			if ($params['NEW']) // Add
			{
				$strSql = "SELECT * FROM b_calendar_type WHERE XML_ID='".$DB->ForSql($XML_ID)."'";
				$res = $DB->Query($strSql);
				if (!($arRes = $res->Fetch()))
				{
					$arInsert = $DB->PrepareInsert("b_calendar_type", $arFields);
					$strSql ="INSERT INTO b_calendar_type(".$arInsert[0].") VALUES(".$arInsert[1].")";
					$DB->Query($strSql);
				}
				else
				{
					false;
				}
			}
			else // Update
			{
				unset($arFields['XML_ID']);
				if (!empty($arFields))
				{
					$strUpdate = $DB->PrepareUpdate("b_calendar_type", $arFields);
					$strSql =
						"UPDATE b_calendar_type SET ".
						$strUpdate.
						" WHERE XML_ID='".$DB->ForSql($XML_ID)."'";
					$DB->QueryBind($strSql, array('DESCRIPTION' => $arFields['DESCRIPTION']));
				}
			}
		}

		//SaveAccess
		$accessController = new TypeAccessController(CCalendar::GetUserId());
		$typeModel = TypeModel::createFromXmlId($arFields['XML_ID']);

		if (is_array($access) && $accessController->check(ActionDictionary::ACTION_TYPE_ACCESS, $typeModel))
		{
			self::SavePermissions($XML_ID, $access);
		}

		CCalendar::ClearCache('type_list');
		return $XML_ID;
	}

	public static function Delete($XML_ID)
	{
		global $DB;
		// Del types
		$DB->Query("DELETE FROM b_calendar_type WHERE XML_ID='".$DB->ForSql($XML_ID)."'");

		// Del access for types
		$DB->Query("DELETE FROM b_calendar_access WHERE SECT_ID='".$DB->ForSql($XML_ID)."'");

		// Del sections
		$DB->Query("DELETE FROM b_calendar_section WHERE CAL_TYPE='".$DB->ForSql($XML_ID)."'");

		// Del events
		$DB->Query("DELETE FROM b_calendar_event WHERE CAL_TYPE='".$DB->ForSql($XML_ID)."'");

		CCalendar::ClearCache(array('type_list', 'section_list', 'event_list'));

		return true;
	}

	public static function SavePermissions($type, $taskPerm)
	{
		global $DB;
		$DB->Query("DELETE FROM b_calendar_access WHERE SECT_ID='".$DB->ForSql($type)."'");

		if (is_array($taskPerm))
		{
			foreach ($taskPerm as $accessCode => $taskId)
			{
				if (0 === strpos($accessCode, "SG"))
				{
					$accessCode = self::prepareGroupCode($accessCode);
				}

				$insert = $DB->PrepareInsert(
					"b_calendar_access",
					[
						"ACCESS_CODE" => $accessCode,
						"TASK_ID" => (int)$taskId,
						"SECT_ID" => $type
					]
				);

				$strSql = "INSERT INTO b_calendar_access(" . $insert[0] . ") VALUES(" . $insert[1] . ")";
				$DB->Query($strSql);
			}
		}
	}

	private static function prepareGroupCode($code)
	{
		$parsedCode = explode('_', $code);

		if (count($parsedCode) === 1)
		{
			$code .= '_K';
		}

		return $code;
	}


	public static function GetArrayPermissions($arTypes = [])
	{
		$sqlHelper = $connection = \Bitrix\Main\Application::getConnection()->getSqlHelper();
		$arTypes = array_map(static function($type) use ($sqlHelper) {
			return $sqlHelper->forSql($type);
		}, $arTypes);
		
		$query = \Bitrix\Calendar\Internals\AccessTable::query()
			->setSelect(['*'])
			->whereIn('SECT_ID', $arTypes)
			->exec()
		;

		while ($res = $query->fetch())
		{
			$xmlId = $res['SECT_ID'];
			if (!isset(self::$Permissions[$xmlId]) || !is_array(self::$Permissions[$xmlId]))
			{
				self::$Permissions[$xmlId] = [];
			}
			self::$Permissions[$xmlId][$res['ACCESS_CODE']] = $res['TASK_ID'];
		}
		foreach ($arTypes as $type)
		{
			if (!isset(self::$Permissions[$type]))
			{
				self::$Permissions[$type] = [];
			}
		}

		return self::$Permissions;
	}

	public static function CanDo($operation, $xmlId = 0, $userId = null)
	{
		global $USER;
		if ((!$USER || !is_object($USER)) || $USER->CanDoOperation('edit_php'))
		{
			return true;
		}

		if (!(int)$userId)
		{
			$userId = CCalendar::GetCurUserId();
		}

		if (
			CCalendar::IsBitrix24()
			&& Loader::includeModule('bitrix24')
			&& \CBitrix24::isPortalAdmin($userId)
		)
		{
			return true;
		}

		if (
			($xmlId === 'group' || $xmlId === 'user' || CCalendar::IsBitrix24())
			&& CCalendar::IsSocNet()
			&& CCalendar::IsSocnetAdmin()
		)
		{
			return true;
		}

		return in_array($operation, self::GetOperations($xmlId, $userId), true);
	}

	public static function GetOperations($xmlId, $userId = null)
	{
		global $USER;
		if (!$userId)
		{
			$userId = CCalendar::GetCurUserId();
		}

		$opCacheKey = $xmlId.'_'.$userId;

		if (isset(self::$userOperationsCache[$opCacheKey]) && is_array(self::$userOperationsCache[$opCacheKey]))
		{
			$result = self::$userOperationsCache[$opCacheKey];
		}
		else
		{
			$arCodes = [];
			if ($userId)
			{
				$arCodes = Util::getUserAccessCodes($userId);
			}

			if(!in_array('G2', $arCodes, true))
			{
				$arCodes[] = 'G2';
			}

			if($userId && !in_array('AU', $arCodes, true) && (int)$USER->GetId() === (int)$userId)
			{
				$arCodes[] = 'AU';
			}

			if($userId && !in_array('UA', $arCodes, true) && (int)$USER->GetId() === (int)$userId)
			{
				$arCodes[] = 'UA';
			}

			$key = $xmlId.'|'.implode(',', $arCodes);
			if(!isset(self::$arOp[$key]) || !is_array(self::$arOp[$key]))
			{
				if(!isset(self::$Permissions[$xmlId]))
				{
					self::GetArrayPermissions([$xmlId]);
				}
				$perms = self::$Permissions[$xmlId];

				self::$arOp[$key] = [];
				if(is_array($perms))
				{
					foreach($perms as $code => $taskId)
					{
						if (in_array($code, $arCodes, true))
						{
							self::$arOp[$key] = array_merge(self::$arOp[$key], CTask::GetOperations($taskId, true));
						}
					}
				}
			}
			$result = self::$userOperationsCache[$opCacheKey] = self::$arOp[$key];
		}

		return $result;
	}
}
?>