<?php
//<title>CommerceML</title>
IncludeModuleLangFile($_SERVER['DOCUMENT_ROOT'].'/bitrix/modules/catalog/import_setup_templ.php');
$startImportExecTime = microtime(true);

global $USER;
$bTmpUserCreated = false;
if (!CCatalog::IsUserExists())
{
	$bTmpUserCreated = true;
	if (isset($USER))
		$USER_TMP = $USER;
	$USER = new CUser();
}

$strImportErrorMessage = "";
$strImportOKMessage = "";

if (file_exists($_SERVER["DOCUMENT_ROOT"]."/bitrix/php_interface/include/1c_mutator.php"))
	include($_SERVER["DOCUMENT_ROOT"]."/bitrix/php_interface/include/1c_mutator.php");

ClearVars("f_");

class XMLNode
{
	var $childs;
	var $parent;
	var $value;
	var $attributes;
	var $name;
	var $r;

	public function __construct(&$parent, $attributes, $name)
	{
		$this->r=rand();
		$this->parent=$parent;
		$this->attributes=$attributes;
		$this->name=$name;
		$this->childs=NULL;
		$this->value=rand();
		if($parent!=NULL)
			$this->parent->childs[$name][]=$this;
	}

	function GetAttribute($name)
	{
		return (isset($this->attributes[$name]) ? $this->attributes[$name] : null);
	}

	function XMLSetValue($new_val)
	{
		$this->r=rand();
//		echo " SetValue===".$this->name." [".$this->r."] = ".$new_val." \n";
		$this->value=$new_val;
	}

	function &select_nodes($str_node)
	{
		$tmp = trim($str_node, "/ \r\n\t\0\x0B");
		if (!($p = mb_strpos($tmp, "/")))
			$p = mb_strlen($tmp);
		$str_node = trim(mb_substr($tmp, 0, $p));
		if('' === $str_node)
			return $this;

		$tmp = trim(mb_substr($tmp, $p + 1));
		if('' === $tmp)
			return $this->childs[$str_node];

		return $this->childs[$str_node][0]->select_nodes($tmp);
	}
}

class CBitrixCommerceCmlXmlParser
{
	var $parser;
	var $cur;
	var $xml;

	function Load($file)
	{
		if ($fd = fopen($file, "rb"))
		{
			$content = fread($fd, filesize($file));
			fclose ($fd);
			$this->parse($content);
			return true;
		}

		return false;
	}

	function LoadString(&$text)
	{
		if ($text <> '')
		{
			$this->parse($text);
			return true;
		}

		return false;
	}

	function unquote($str)
	{
		$search = array(
					"'&(quot|#34);'i",
					"'&(amp|#38);'i",
					"'&(lt|#60);'i",
					"'&(gt|#62);'i",
					"'&#(\d+);'e"
					);

		$replace = array(
					"\"",
					"&",
					"<",
					">",
					"chr(\\1)"
					);

		$str = preg_replace($search, $replace, $str);

		return $str;
	}

	function parse(&$data)		//, $last
	{
		$data = preg_replace("#<\!--.*?-->#s", "", $data);

		$pb = mb_strpos($data, "<");
		while($pb!==false)
		{
			$pe = mb_strpos($data, ">", $pb);
			if($pe === false) break;
			$tag_cont = mb_substr($data, $pb + 1, $pe - $pb - 1);
			$pb = mb_strpos($data, "<", $pe);

			$check_str = mb_substr($tag_cont, 0, 1);
			if($check_str=="?")
				continue;
			elseif($check_str=="!")
				continue;
			elseif($check_str=="/")
				$this->endElement(mb_substr($tag_cont, 1));
			else
			{
				$p=0;
				$ltag_cont = mb_strlen($tag_cont);
				while(($p < $ltag_cont) && (mb_strpos(" \t\n\r", mb_substr($tag_cont, $p, 1)) === false))
					$p++;
				$name = mb_substr($tag_cont, 0, $p);
				$at = mb_substr($tag_cont, $p);
				if(mb_strpos($at, "&") !== false)
					$bAmp = true;
				else
					$bAmp = false;

				preg_match_all("/(\\S+)\\s*=\\s*[\"](.*?)[\"]/su", $at, $attrs_tmp);
				$attrs = array();
				for($i=0, $intCount = count($attrs_tmp[1]); $i < $intCount; $i++)
					$attrs[$attrs_tmp[1][$i]] = ($bAmp ? $this->unquote($attrs_tmp[2][$i]) : $attrs_tmp[2][$i]);
				$this->startElement($name, $attrs);
				if(mb_substr($tag_cont, -1) === "/")
					$this->endElement($name);
			}
		}
	}


	function startElement($name, $attrs)
	{
		$bTemp=false;
		if($this->cur==NULL)
			$bTemp=true;

		$this->cur = new XMLNode($this->cur, $attrs, $name);

		if($bTemp)
			$this->xml = $this->cur;
	}

	function endElement($name)
	{
		if($this->cur->parent!=NULL)
			$this->cur = $this->cur->parent;
	}

	function cdata($parser,$cdata)
	{
		if(trim($cdata)!="")
		{
			$this->cur->XMLSetValue(trim($cdata));
		}
	}

	function select_nodes_attrib($str_node)
	{
		$tmp=$this->select_nodes($str_node);
		$result=array();
		for($i=0, $intCount = count($tmp);$i < $intCount;$i++)
		{
			$arTemp=$tmp[$i]->attributes;
			$result[]=$arTemp;
		}

		return $result;
	}

	function select_nodes($str_node)
	{
		if(!is_object($this->xml)) return array();
		$result=array(0=>$this->xml);
		$tmp = explode ("/", $str_node);
		for($i=2, $intCount = count($tmp);$i<$intCount;$i++)
		{
			if($tmp[$i]!="")
			{
				if(!is_array($result[0]->childs)) return array();
				$result = $result[0]->childs[$tmp[$i]];
			}
		}

		return $result;
	}
}



function AddSectionsRecursive($parent="", $parent_id=0)
{
	global $tmpid, $arGrTmp, $strImportErrorMessage, $IBLOCK_ID, $arGroups, $STT_GROUP_ADD, $STT_GROUP_UPDATE, $STT_GROUP_ERROR;

	global $boolTranslitSection, $arTranslitSection;

	global $activateFileData;

	$arChld = $arGrTmp[$tmpid.$parent];
	if(!is_array($arChld)) return;
	for($i=0, $intCount = count($arChld); $i<$intCount; $i++)
	{
		$GROUP_XML_ID = $arChld[$i]["GROUP_XML_ID"];
		$GROUP_NAME = $arChld[$i]["GROUP_NAME"];

		$bs = new CIBlockSection();
		$res = CIBlockSection::GetList(array(), Array("XML_ID"=>$GROUP_XML_ID, "IBLOCK_ID"=>$IBLOCK_ID, 'CHECK_PERMISSIONS' => 'N'));
		$bNewGroup_tmp = False;
		if($arr = $res->Fetch())
		{
			$GROUP_ID = $arr["ID"];
			$arFields = array(
				"NAME"=>$GROUP_NAME,
				"TMP_ID"=>$tmpid,
				"IBLOCK_SECTION_ID"=>$parent_id
			);
			if ($boolTranslitSection)
				$arFields['CODE'] = CUtil::translit($GROUP_NAME, 'ru', $arTranslitSection);
			if ('Y' == $activateFileData)
				$arFields['ACTIVE'] = 'Y';
			$res = $bs->Update($GROUP_ID, $arFields, false);
		}
		else
		{
			$bNewGroup_tmp = True;
			$arFields = Array(
				"ACTIVE"=>"Y",
				"IBLOCK_SECTION_ID"=>$parent_id,
				"IBLOCK_ID"=>$IBLOCK_ID,
				"NAME"=>$GROUP_NAME,
				"TMP_ID"=>$tmpid,
				"XML_ID"=>$GROUP_XML_ID
				);
			if ($boolTranslitSection)
				$arFields['CODE'] = CUtil::translit($GROUP_NAME, 'ru', $arTranslitSection);
			$GROUP_ID = $bs->Add($arFields, false);
			$res = ($GROUP_ID>0);
		}

		if(!$res)
		{
			$strImportErrorMessage .= str_replace("#ERROR#", $bs->LAST_ERROR, str_replace("#NAME#", "[".$GROUP_ID."] \"".$GROUP_NAME."\" (".$GROUP_XML_ID.")", GetMessage("CICML_ERROR_ADD_SECTION"))).".<br>";
			$STT_GROUP_ERROR++;
		}
		else
		{
			if ($bNewGroup_tmp) $STT_GROUP_ADD++;
			else $STT_GROUP_UPDATE++;

			$arGroups[$GROUP_XML_ID] = $GROUP_ID;
			AddSectionsRecursive($GROUP_XML_ID, $GROUP_ID);
		}
	}
}

if (!function_exists("file_get_contents"))
{
	function file_get_contents($filename)
	{
		$fd = fopen("$filename", "rb");
		$content = fread($fd, filesize($filename));
		fclose($fd);
		return $content;
	}
}


$DATA_FILE_NAME = "";

$STT_GROUP_ADD = 0;		$STT_GROUP_UPDATE = 0;		$STT_GROUP_ERROR = 0;
$STT_CATALOG_ADD = 0;	$STT_CATALOG_UPDATE = 0;	$STT_CATALOG_ERROR = 0;
$STT_PROP_ADD = 0;		$STT_PROP_UPDATE = 0;		$STT_PROP_ERROR = 0;
$STT_PRODUCT_ADD = 0;	$STT_PRODUCT_UPDATE = 0;	$STT_PRODUCT_ERROR = 0;

if (isset($_FILES["FILE_1C"]) && is_uploaded_file($_FILES["FILE_1C"]["tmp_name"]))
	$DATA_FILE_NAME = $_FILES["FILE_1C"]["tmp_name"];

if ($DATA_FILE_NAME == '')
{
	if ($URL_FILE_1C <> '')
	{
		$URL_FILE_1C = Rel2Abs("/", $URL_FILE_1C);
		if (file_exists($_SERVER["DOCUMENT_ROOT"].$URL_FILE_1C) && is_file($_SERVER["DOCUMENT_ROOT"].$URL_FILE_1C))
			$DATA_FILE_NAME = $_SERVER["DOCUMENT_ROOT"].$URL_FILE_1C;
	}
}

if ($DATA_FILE_NAME == '')
	$strImportErrorMessage .= GetMessage("CICML_NO_LOAD_FILE")."<br>";

global $IBLOCK_TYPE_ID;
$IBLOCK_TYPE_ID = trim(strval($IBLOCK_TYPE_ID));
if ($IBLOCK_TYPE_ID <> '')
{
	$rsIBlockTypes = CIBlockType::GetByID($IBLOCK_TYPE_ID);
	if (!($arIBlockType = $rsIBlockTypes->Fetch()))
	{
		$IBLOCK_TYPE_ID = '';
	}
}
if ($IBLOCK_TYPE_ID == '')
{
	$IBLOCK_TYPE_ID = COption::GetOptionString("catalog", "default_catalog_1c", "");
}
if ($IBLOCK_TYPE_ID == '')
{
	$iblocks = CIBlockType::GetList(Array('SORT' => 'ASC'));
	if ($iblocks->ExtractFields("f_"))
		$IBLOCK_TYPE_ID = $f_ID;
}

if ($IBLOCK_TYPE_ID == '')
	$strImportErrorMessage .= GetMessage("CICML_NO_IBLOCK")."<br>";

if ($outFileAction!="F" && $outFileAction!="H" && $outFileAction!="D")
	$outFileAction = COption::GetOptionString("catalog", "default_outfile_action", "D");

if ($outFileAction!="F" && $outFileAction!="H")
	$outFileAction = "D";

if ('' === $strImportErrorMessage)
{
	$xml = new CBitrixCommerceCmlXmlParser();
	$xml_content = file_get_contents($DATA_FILE_NAME);

	if (!$xml_content || $xml_content == '')
		$strImportErrorMessage .= GetMessage("CICML_NO_LOAD_DATA")."<br>";
}

if ('' === $strImportErrorMessage)
{
	if ($CONVERT_UTF8 != "Y" && $CONVERT_UTF8 != "N")
		$CONVERT_UTF8 = COption::GetOptionString("catalog", "default_convert_utf8", "N");

	if (true)
	{
		$xml_content = \Bitrix\Main\Text\Encoding::convertEncoding($xml_content, $CONVERT_UTF8 == "Y"? "utf-8": "windows-1251", LANG_CHARSET);

		if (!$xml_content || $xml_content == '')
		{
			if ($ex = $APPLICATION->GetException())
				$strImportErrorMessage .= $ex->GetString();
			else
				$strImportErrorMessage .= "Error converting from UTF-8"."<br>";
		}
	}
}

$USE_TRANSLIT = (isset($USE_TRANSLIT) && 'Y' == $USE_TRANSLIT ? 'Y' : 'N');
$ADD_TRANSLIT = (isset($ADD_TRANSLIT) && 'Y' == $ADD_TRANSLIT ? 'Y' : 'N');

if (!isset($keepExistingProperties))
{
	$keepExistingProperties = ($outFileAction = "D" ? 'N' : 'Y');
}
else
{
	$keepExistingProperties = ('N' == $keepExistingProperties ? 'N' : 'Y');
}

$activateFileData = (isset($activateFileData) && 'Y' == $activateFileData ? 'Y' : 'N');

global $nameUTF;
$nameUTF = array();
include(__DIR__.'/ru/commerceml_run_name.php');
if (!isset($nameUTF) || !is_array($nameUTF) || empty($nameUTF))
	$strImportErrorMessage .= GetMessage('CAT_ADM_CML1_IMP_ERR_NAMEUTF').'<br>';

if ('' === $strImportErrorMessage)
{
	$xml->LoadString($xml_content);

	$comm = $xml->select_nodes("/BizTalk/Body/".$nameUTF['CommerceInfo']);
	if (!is_object($comm[0]))
	{
		$comm = $xml->select_nodes("/".$nameUTF['CommerceInfo']);
		if (!is_object($comm[0]))
			$strImportErrorMessage .= GetMessage("CICML_INVALID_FILE")."<br>";
	}
	$strVersion = $comm[0]->GetAttribute($nameUTF['CommerceInfoVersion']);
	if (null !== $strVersion)
	{
		if (version_compare($strVersion, '2.0') >= 0)
		{
			$strImportErrorMessage .= GetMessage("CICML_INVALID_VERSION")."<br>";
		}
	}
	if ($comm[0]->name == $nameUTF['Yandex'])
	{
		$strImportErrorMessage .= GetMessage('CICML_NO_YANDEX');
	}
}

if ('' === $strImportErrorMessage)
{
	$arPriceType = array();
	$offerlists = $comm[0]->select_nodes("/".$nameUTF['OffersList']);
	if (is_array($offerlists))
	{
		for ($i = 0, $intOFCount = count($offerlists); $i < $intOFCount; $i++)
		{
			$xOfferListNode = $offerlists[$i];

			$props = $xOfferListNode->select_nodes("/".$nameUTF['PropertyValue']);
			for ($j = 0, $intPropCount = count($props); $j < $intPropCount; $j++)
			{
				$arPriceType[$props[0]->GetAttribute($nameUTF['CatalogID'])] = $props[0]->GetAttribute($nameUTF['PropertyId']);
				break;
			}
		}
	}

	$SITE_ID = 'ru';
	$dbSite = CSite::GetByID($SITE_ID);
	if (!$dbSite->Fetch())
	{
		$dbSite = CSite::GetList();
		$arSite = $dbSite->Fetch();
		$SITE_ID = $arSite['ID'];
	}

	$ib = new CIBlock();
	$el = new CIBlockElement();

	$tmpid = md5(uniqid(""));
	$arCatalogs = array();
	$arCatalogsParams = array();
	$catalogs = $comm[0]->select_nodes("/".$nameUTF['Catalog']);
	if (is_array($catalogs))
	{
		for ($i = 0, $intCatCount = count($catalogs); $i < $intCatCount; $i++)
		{
			$xCatNode = $catalogs[$i];

			$IBLOCK_XML_ID = $xCatNode->GetAttribute($nameUTF['ID']);
			$IBLOCK_NAME = $xCatNode->GetAttribute($nameUTF['Name']);
			$IBLOCK_DESC = $xCatNode->GetAttribute($nameUTF['Description']);

			$res = CIBlock::GetList(array(), array("=TYPE" => $IBLOCK_TYPE_ID, "=XML_ID" => $IBLOCK_XML_ID, 'CHECK_PERMISSIONS' => 'Y', 'MIN_PERMISSION' => 'W'));
			$bNewRecord_tmp = false;
			if ($res_arr = $res->Fetch())
			{
				$IBLOCK_ID = $res_arr["ID"];
				$res = $ib->Update($IBLOCK_ID,
					array(
						"NAME" => $IBLOCK_NAME,
						"TMP_ID" => $tmpid,
						"DESCRIPTION" => $IBLOCK_DESC
					)
				);
				\Bitrix\Iblock\PropertyIndex\Manager::markAsInvalid($IBLOCK_ID);
			}
			elseif ($USER->IsAdmin())
			{
				$bNewRecord_tmp = true;
				$arFields = array(
					"ACTIVE" => "Y",
					"NAME" => $IBLOCK_NAME,
					"XML_ID" => $IBLOCK_XML_ID,
					"TMP_ID" => $tmpid,
					"IBLOCK_TYPE_ID" => $IBLOCK_TYPE_ID,
					"LID" => $SITE_ID,
					"WORKFLOW" => "N",
				);
				if ('Y' == $USE_TRANSLIT && 'Y' == $ADD_TRANSLIT)
				{
					$arFields['FIELDS'] = array(
						'CODE' => array(
							'DEFAULT_VALUE' => array(
								'TRANSLITERATION' => 'Y',
							),
						),
						'SECTION_CODE' => array(
							'DEFAULT_VALUE' => array(
								'TRANSLITERATION' => 'Y',
							),
						)
					);
				}

				$IBLOCK_ID = $ib->Add($arFields);
				$res = ($IBLOCK_ID > 0);
			}
			else
				$res = false;

			if (!$res)
			{
				$strImportErrorMessage .= str_replace("#ERROR#", $ib->LAST_ERROR, str_replace("#NAME#", "[".$IBLOCK_ID."] \"".$IBLOCK_NAME."\" (".$IBLOCK_XML_ID.")", GetMessage("CICML_ERROR_ADDING_CATALOG"))).".<br>";
				$STT_CATALOG_ERROR++;
			}
			else
			{
				$boolIBlockTranslit = $USE_TRANSLIT;
				$boolTranslitElement = false;
				$boolTranslitSection = false;
				$arTranslitElement = array();
				$arTranslitSection = array();

				if ('Y' == $boolIBlockTranslit)
				{
					$boolOutTranslit = false;
					$arIBlock = CIBlock::GetArrayByID($IBLOCK_ID);
					if (isset($arIBlock['FIELDS']['CODE']['DEFAULT_VALUE']))
					{
						if ('Y' == $arIBlock['FIELDS']['CODE']['DEFAULT_VALUE']['TRANSLITERATION']
							&& 'Y' == $arIBlock['FIELDS']['CODE']['DEFAULT_VALUE']['USE_GOOGLE'])
						{
							$boolOutTranslit = true;
						}
					}
					if (isset($arIBlock['FIELDS']['SECTION_CODE']['DEFAULT_VALUE']))
					{
						if ('Y' == $arIBlock['FIELDS']['SECTION_CODE']['DEFAULT_VALUE']['TRANSLITERATION']
							&& 'Y' == $arIBlock['FIELDS']['SECTION_CODE']['DEFAULT_VALUE']['USE_GOOGLE'])
						{
							$boolOutTranslit = true;
						}
					}
					if ($boolOutTranslit)
					{
						$boolIBlockTranslit = 'N';
						$strImportErrorMessage .= str_replace("#ERROR#", GetMessage('CATI_USE_CODE_TRANSLIT_OUT'), str_replace("#NAME#", "[".$IBLOCK_ID."] \"".$IBLOCK_NAME."\" (".$IBLOCK_XML_ID.")", GetMessage("CICML_ERROR_ADDING_CATALOG"))).".<br>";
						$STT_CATALOG_ERROR++;
						continue;
					}

					if ('Y' == $boolIBlockTranslit)
					{
						if (isset($arIBlock['FIELDS']['CODE']['DEFAULT_VALUE']))
						{
							$arTransSettings = $arIBlock['FIELDS']['CODE']['DEFAULT_VALUE'];
							$boolTranslitElement = ('Y' == $arTransSettings['TRANSLITERATION'] ? true : false);
							$arTranslitElement = array(
								"max_len" => $arTransSettings['TRANS_LEN'],
								"change_case" => $arTransSettings['TRANS_CASE'],
								"replace_space" => $arTransSettings['TRANS_SPACE'],
								"replace_other" => $arTransSettings['TRANS_OTHER'],
								"delete_repeat_replace" => ('Y' == $arTransSettings['TRANS_EAT'] ? true : false),
								"use_google" => ('Y' == $arTransSettings['USE_GOOGLE'] ? true : false),
							);
						}
						if (isset($arIBlock['FIELDS']['SECTION_CODE']['DEFAULT_VALUE']))
						{
							$arTransSettings = $arIBlock['FIELDS']['SECTION_CODE']['DEFAULT_VALUE'];
							$boolTranslitSection = ('Y' == $arTransSettings['TRANSLITERATION'] ? true : false);
							$arTranslitSection = array(
								"max_len" => $arTransSettings['TRANS_LEN'],
								"change_case" => $arTransSettings['TRANS_CASE'],
								"replace_space" => $arTransSettings['TRANS_SPACE'],
								"replace_other" => $arTransSettings['TRANS_OTHER'],
								"delete_repeat_replace" => ('Y' == $arTransSettings['TRANS_EAT'] ? true : false),
								"use_google" => ('Y' == $arTransSettings['USE_GOOGLE'] ? true : false),
							);
						}
					}
				}

				if ($bNewRecord_tmp) $STT_CATALOG_ADD++;
				else $STT_CATALOG_UPDATE++;

				$arCatalogs[$IBLOCK_XML_ID] = $IBLOCK_ID;

				if (!CCatalog::GetByID($IBLOCK_ID))
					CCatalog::Add(array("IBLOCK_ID" => $IBLOCK_ID));


				$arProperties = array();
				$ibp = new CIBlockProperty();
				$props = $xCatNode->select_nodes("/".$nameUTF['Property']);

				for ($j = 0, $intPropCount = count($props); $j < $intPropCount; $j++)
				{
					$xPropNode = $props[$j];

					$PROP_XML_ID = $xPropNode->GetAttribute($nameUTF['ID']);
					$PROP_TYPE = $xPropNode->GetAttribute($nameUTF['DataType']);
					$PROP_MULTIPLE = ($xPropNode->GetAttribute($nameUTF['Multiple']) == "1" ? "Y" : "N");
					$PROP_NAME = $xPropNode->GetAttribute($nameUTF['Name']);
					$PROP_DEF = $xPropNode->GetAttribute($nameUTF['DefaultValue']);
					if ($PROP_TYPE == "enumeration")
						$PROP_TYPE = "L";
					else
						$PROP_TYPE = "S";

					if ($arPriceType[$IBLOCK_XML_ID] == $PROP_XML_ID)
						continue;

					$res = CIBlock::GetProperties($IBLOCK_ID, array(), array("IBLOCK_ID" => $IBLOCK_ID, "XML_ID" => $PROP_XML_ID));
					$bNewRecord_tmp = false;
					if ($res_arr = $res->Fetch())
					{
						$PROP_ID = $res_arr["ID"];
						$res = $ibp->Update($PROP_ID,
							array(
								"NAME" => $PROP_NAME,
								"TYPE" => $PROP_TYPE,
								"MULTIPLE" => $PROP_MULTIPLE,
								"DEFAULT_VALUE" => $PROP_DEF,
								"TMP_ID" => $tmpid
							)
						);
					}
					else
					{
						$bNewRecord_tmp = true;
						$arFields = array(
							"NAME" => $PROP_NAME,
							"ACTIVE" => "Y",
							"SORT" => "500",
							"DEFAULT_VALUE" => $PROP_DEF,
							"XML_ID" => $PROP_XML_ID,
							"TMP_ID" => $tmpid,
							"MULTIPLE" => $PROP_MULTIPLE,
							"PROPERTY_TYPE" => $PROP_TYPE,
							"IBLOCK_ID" => $IBLOCK_ID
						);
						$PROP_ID = $ibp->Add($arFields);
						$res = (intval($PROP_ID) > 0);
					}

					if (!$res)
					{
						$strImportErrorMessage .= str_replace("#ERROR#", $ibp->LAST_ERROR, str_replace("#NAME#", "[".$PROP_ID."] \"".$PROP_NAME."\" (".$PROP_XML_ID.")", GetMessage("CICML_ERROR_ADD_PROPS"))).".<br>";
						$STT_PROP_ERROR++;
					}
					else
					{
						if ($bNewRecord_tmp) $STT_PROP_ADD++;
						else $STT_PROP_UPDATE++;

						$arProperties[$PROP_XML_ID] = $PROP_ID;
					}

					if ($PROP_TYPE == "L")
					{
						$pren = new CIBlockPropertyEnum();
						$arPropertiesEnum[$PROP_XML_ID] = array();
						$prop_enums = $xPropNode->select_nodes("/".$nameUTF['PropertyVariant']);
						for ($k = 0, $intEnumPropCount = count($prop_enums); $k < $intEnumPropCount; $k++)
						{
							$xPropEnum = $prop_enums[$k];
							$PROP_ENUM_XML_ID = $xPropEnum->GetAttribute($nameUTF['ID']);
							$PROP_ENUM_NAME = $xPropEnum->GetAttribute($nameUTF['Name']);
							$PROP_ENUM_DEF = ($PROP_ENUM_XML_ID == $PROP_DEF ? "Y" : "N");

							$arFields = array(
								"DEF" => $PROP_ENUM_DEF,
								"TMP_ID" => $tmpid,
								"VALUE" => $PROP_ENUM_NAME,
								"PROPERTY_ID" => $PROP_ID,
								"XML_ID" => $PROP_ENUM_XML_ID
							);
							$res = CIBlockPropertyEnum::GetList(array(), array("PROPERTY_ID" => $PROP_ID, "XML_ID" => $PROP_ENUM_XML_ID));
							if ($arr = $res->Fetch())
							{
								$PROP_ENUM_ID = $arr["ID"];
								$pren->Update($PROP_ENUM_ID, $arFields);
							}
							else
							{
								$PROP_ENUM_ID = $pren->Add($arFields);
							}
							$arPropertiesEnum[$PROP_XML_ID][$PROP_ENUM_XML_ID] = $PROP_ENUM_ID;
						}
					}
				}

				if (function_exists("catalog_property_mutator_1c"))
					catalog_property_mutator_1c();

				$arGrTmp = array();
				$groups = $xCatNode->select_nodes("/".$nameUTF['Category']);
				for ($j = 0, $intGroupCount = count($groups); $j < $intGroupCount; $j++)
				{
					$xGroupNode = $groups[$j];

					$GROUP_XML_ID = $xGroupNode->GetAttribute($nameUTF['ID']);
					$GROUP_PARENT_XML_ID = $xGroupNode->GetAttribute($nameUTF['ParentCategory']);
					$GROUP_NAME = $xGroupNode->GetAttribute($nameUTF['Name']);

					$arGrTmp[$tmpid.$GROUP_PARENT_XML_ID][] = array(
						"GROUP_XML_ID" => $GROUP_XML_ID,
						"GROUP_PARENT_XML_ID" => $GROUP_PARENT_XML_ID,
						"GROUP_NAME" => $GROUP_NAME
					);
				}

				$arGroups = array();
				AddSectionsRecursive();
				CIBlockSection::ReSort($IBLOCK_ID);

				$arProducts = array();
				$products = $xCatNode->select_nodes("/".$nameUTF['Product']);
				for ($j = 0, $intProdCount = count($products); $j < $intProdCount; $j++)
				{
					$xProductNode = $products[$j];

					$PRODUCT_XML_ID = $xProductNode->GetAttribute($nameUTF['ID']);
					$PRODUCT_PARENT_XML_ID = $xProductNode->GetAttribute($nameUTF['ParentCategory']);
					$PRODUCT_NAME = $xProductNode->GetAttribute($nameUTF['Name']);

					$PROP = array();
					$GROUPS_ID = array();
					if ($PRODUCT_PARENT_XML_ID <> '' && $arGroups[$PRODUCT_PARENT_XML_ID] <> '')
						$GROUPS_ID[] = $arGroups[$PRODUCT_PARENT_XML_ID];

					$prod_groups = $xProductNode->select_nodes("/".$nameUTF['CategoryReference']);
					for ($k = 0, $intProdGroupCount = count($prod_groups); $k < $intProdGroupCount; $k++)
					{
						$xProductGroupsNode = $prod_groups[$k];
						$PRODUCT_GROUP_XML_ID = $xProductGroupsNode->GetAttribute($nameUTF['IdInCatalog']);
						if ($arGroups[$PRODUCT_GROUP_XML_ID] <> '')
							$GROUPS_ID[] = $arGroups[$PRODUCT_GROUP_XML_ID];
					}

					$prop_vals = $xProductNode->select_nodes("/".$nameUTF['PropertyValue']);
					for ($k = 0, $intPropValCount = count($prop_vals); $k < $intPropValCount; $k++)
					{
						$xPropertyValueNode = $prop_vals[$k];

						$PROP_VAL_PROPERTY_XML_ID = $xPropertyValueNode->GetAttribute($nameUTF['PropertyId']);
						$PROP_VAL_VALUE = $xPropertyValueNode->GetAttribute($nameUTF['Value']);
						if ($arProperties[$PROP_VAL_PROPERTY_XML_ID] <> '')
						{
							if (is_array($arPropertiesEnum[$PROP_VAL_PROPERTY_XML_ID]))
							{
								if ($arPropertiesEnum[$PROP_VAL_PROPERTY_XML_ID][$PROP_VAL_VALUE] <> '')
									$PROP[$arProperties[$PROP_VAL_PROPERTY_XML_ID]][] = $arPropertiesEnum[$PROP_VAL_PROPERTY_XML_ID][$PROP_VAL_VALUE];
							}
							else
								$PROP[$arProperties[$PROP_VAL_PROPERTY_XML_ID]][] = $PROP_VAL_VALUE;
						}
					}

					$arLoadProductArray = array(
						"MODIFIED_BY" => $USER->GetID(),
						"IBLOCK_SECTION" => $GROUPS_ID,
						"IBLOCK_ID" => $IBLOCK_ID,
						"NAME" => $PRODUCT_NAME,
						"XML_ID" => $PRODUCT_XML_ID,
						"TMP_ID" => $tmpid,
						"PROPERTY_VALUES" => $PROP
					);
					if ($boolTranslitElement)
						$arLoadProductArray['CODE'] = CUtil::translit($PRODUCT_NAME, 'ru', $arTranslitElement);

					$res = CIBlockElement::GetList(array(), array("IBLOCK_ID" => $IBLOCK_ID, "XML_ID" => $PRODUCT_XML_ID));
					$bNewRecord_tmp = false;
					if ($arr = $res->Fetch())
					{
						$PRODUCT_ID = $arr["ID"];
						if ('Y' == $activateFileData)
							$arLoadProductArray['ACTIVE'] = 'Y';
						if (function_exists("catalog_product_mutator_1c"))
						{
							$arLoadProductArray = catalog_product_mutator_1c($arLoadProductArray, $xProductNode, false);
						}
						$res = $el->Update($PRODUCT_ID, $arLoadProductArray);
					}
					else
					{
						$bNewRecord_tmp = true;
						$arLoadProductArray["ACTIVE"] = "Y";
						if (function_exists("catalog_product_mutator_1c"))
							$arLoadProductArray = catalog_product_mutator_1c($arLoadProductArray, $xProductNode, true);
						$PRODUCT_ID = $el->Add($arLoadProductArray);
						$res = ($PRODUCT_ID > 0);
					}

					if (!$res)
					{
						$strImportErrorMessage .= str_replace("#ERROR#", $el->LAST_ERROR, str_replace("#NAME#", "[".$PRODUCT_ID."] \"".$PRODUCT_NAME."\" (".$PRODUCT_XML_ID.")", GetMessage("CICML_ERROR_ADDING_PRODUCT"))).".<br>";
						$STT_PRODUCT_ERROR++;
					}
					else
					{
						if ($bNewRecord_tmp) $STT_PRODUCT_ADD++;
						else $STT_PRODUCT_UPDATE++;

						$arProducts[$PRODUCT_XML_ID] = $PRODUCT_ID;
					}


					$arCatalogsParams[$IBLOCK_XML_ID] = array(
						"arProperties" => $arProperties,
						"arPropertiesEnum" => $arPropertiesEnum,
						"arGroups" => $arGroups,
						"arProducts" => $arProducts
					);
				}

				if ('N' == $keepExistingProperties)
				{
					$res = CIBlockProperty::GetList(array(), array("IBLOCK_ID" => $IBLOCK_ID, "!TMP_ID" => $tmpid));
					while ($arr = $res->Fetch())
					{
						CIBlockProperty::Delete($arr["ID"]);
					}

					$res = CIBlockPropertyEnum::GetList(array(), array("IBLOCK_ID" => $IBLOCK_ID, "!TMP_ID" => $tmpid));
					while ($arr = $res->Fetch())
					{
						CIBlockPropertyEnum::Delete($arr["ID"]);
					}
				}

				if ($outFileAction != "F")
				{
					$bs = new CIBlockSection;
					$res = CIBlockSection::GetList(array(), array("IBLOCK_ID" => $IBLOCK_ID, "!TMP_ID" => $tmpid, 'CHECK_PERMISSIONS' => 'N'));
					while ($arr = $res->Fetch())
					{
						if ($outFileAction != "H")
						{
							CIBlockSection::Delete($arr["ID"]);
						}
						else
						{
							$bs->Update($arr["ID"], array("NAME" => $arr["NAME"], "ACTIVE" => "N"));
						}
					}

					$res = CIBlockElement::GetList(array(), array("IBLOCK_ID" => $IBLOCK_ID, "!TMP_ID" => $tmpid));
					while ($arr = $res->Fetch())
					{
						if ($outFileAction != "H")
						{
							CIBlockElement::Delete($arr["ID"]);
						}
						else
						{
							$el->Update($arr["ID"], array("ACTIVE" => "N"));
						}
					}
				}

			}
		}
	}

	global $arCurrencies;
	$arCurrencies = array();
	include(__DIR__.'/ru/commerceml_run_cur.php');
	if (!isset($arCurrencies) || !is_array($arCurrencies) || empty($arCurrencies))
		$strImportErrorMessage .= GetMessage('CAT_ADM_CML1_IMP_ERR_CMLCUR').'<br>';

//	$arProductsTmp = array();
//	foreach ($arCatalogsParams as $key=>$Val)
//	{
//		$arProductsTmp[$key] = $Val["arProducts"];
//	}
//	$arProductsTmp = $arCatalogsParams[$IBLOCK_XML_ID]["arProducts"];
	$arProductsTmpA = $arCatalogsParams;

	if (is_array($offerlists))
	{
		for ($i = 0, $intOFListCount = count($offerlists); $i < $intOFListCount; $i++)
		{
			$xOfferListNode = $offerlists[$i];

			$IBLOCK_XML_ID = $xOfferListNode->GetAttribute($nameUTF['CatalogID']);
			$OFFER_LIST_DESC = $xOfferListNode->GetAttribute($nameUTF['Description']);
			$OFFER_LIST_CURRENCY = $arCurrencies[$xOfferListNode->GetAttribute($nameUTF['Currency'])];
			if ($OFFER_LIST_CURRENCY == '')
				$OFFER_LIST_CURRENCY = "USD";

			//detect "price type" property
			$props = $xOfferListNode->select_nodes("/".$nameUTF['PropertyValue']);
			if (!is_object($props[0]))
				continue;

			$PRICE_TYPE = $props[0]->GetAttribute($nameUTF['Value']);
			$res = CCatalogGroup::GetListEx(array(), array("NAME" => $PRICE_TYPE), false, false, array('ID', 'NAME'));
			if ($arr = $res->Fetch())
				$PRICE_ID = $arr["ID"];
			else
				$PRICE_ID = CCatalogGroup::Add(
					array(
						"NAME" => $PRICE_TYPE,
						"USER_LANG" => array("ru" => $PRICE_TYPE)
					)
				);

			$arProducts = $arCatalogsParams[$IBLOCK_XML_ID]["arProducts"];

			$arOffers = array();
			$offers = $xOfferListNode->select_nodes("/".$nameUTF['Offer']);

			for ($j = 0, $intOtOFCount = count($offers); $j < $intOtOFCount; $j++)
			{
				$xOfferNode = $offers[$j];

				$PRODUCT_XML_ID = $xOfferNode->GetAttribute($nameUTF['ProductId']);

				// we shouldn't go to 'continue', but should search product in DB by XML_ID
				// and in array if absent. Then we'll be able to load only prices without products
				$PRODUCT_ID = 0;
				if (!isset($arProducts[$PRODUCT_XML_ID]))
				{
					if (!isset($arIBlockCacheTmp[$IBLOCK_XML_ID])
						|| intval($arIBlockCacheTmp[$IBLOCK_XML_ID]) <= 0)
					{
						$db_res_tmp = CIBlock::GetList(array(), array("XML_ID" => $IBLOCK_XML_ID));
						if ($ar_res_tmp = $db_res_tmp->Fetch())
						{
							$arIBlockCacheTmp[$IBLOCK_XML_ID] = intval($ar_res_tmp["ID"]);
						}
					}

					$db_res_tmp = CIBlockElement::GetList(array(), array("XML_ID" => $PRODUCT_XML_ID, "IBLOCK_ID" => $arIBlockCacheTmp[$IBLOCK_XML_ID]));
					if ($ar_res_tmp = $db_res_tmp->Fetch())
					{
						$PRODUCT_ID = intval($ar_res_tmp["ID"]);
						$arCatalogsParams[$IBLOCK_XML_ID]["arProducts"][$PRODUCT_XML_ID] = $PRODUCT_ID;
					}
				}
				else
				{
					$PRODUCT_ID = intval($arProducts[$PRODUCT_XML_ID]);
				}

				if ($PRODUCT_ID <= 0)
					continue;

				unset($arProductsTmpA[$IBLOCK_XML_ID]["arProducts"][$PRODUCT_XML_ID]);

				$OFFER_PRICE = DoubleVal(str_replace(",", ".", $xOfferNode->GetAttribute($nameUTF['Price'])));
				$OFFER_UPAK = $xOfferNode->GetAttribute($nameUTF['Package']);
				$OFFER_QUANTITY = intval($xOfferNode->GetAttribute($nameUTF['Amount']));
				$OFFER_UNIT = $xOfferNode->GetAttribute($nameUTF['Unit']);
				$OFFER_CURRENCY = $arCurrencies[$xOfferNode->GetAttribute($nameUTF['Currency'])];
				if ($OFFER_CURRENCY == '')
					$OFFER_CURRENCY = $OFFER_LIST_CURRENCY;

				$arLoadOfferArray = array(
					"ID" => $PRODUCT_ID,
					"QUANTITY" => $OFFER_QUANTITY
				);
				if (function_exists("catalog_offer_mutator_1c"))
				{
					$arLoadOfferArray = catalog_offer_mutator_1c($arLoadOfferArray, $xOfferNode);
				}

				$khjk = CCatalogProduct::Add($arLoadOfferArray);

				$arFields = array(
					"PRODUCT_ID" => $PRODUCT_ID,
					"CATALOG_GROUP_ID" => $PRICE_ID,
					"PRICE" => $OFFER_PRICE,
					"CURRENCY" => $OFFER_CURRENCY
				);

				$res = CPrice::GetList(
					array(),
					array(
						"PRODUCT_ID" => $PRODUCT_ID,
						"CATALOG_GROUP_ID" => $PRICE_ID
					)
				);
				if ($arr = $res->Fetch())
					$khjk = CPrice::Update($arr["ID"], $arFields);
				else
					$khjk = CPrice::Add($arFields);
			}
		}
	}

	if (COption::GetOptionString("catalog", "deactivate_1c_no_price", "N")=="Y")
	{
		foreach ($arProductsTmpA as $keyA=>$valA)
		{
			foreach ($valA["arProducts"] as $keyB=>$valB)
			{
				$res = $el->Update(intval($valB), Array("ACTIVE" => "N"));
			}
		}
	}

	$strImportOKMessage .= str_replace("#TIME#", RoundEx(microtime(true) - $startImportExecTime, 2), GetMessage("CICML_LOAD_TIME"))."<br>";
	$strImportOKMessage .= str_replace("#NUM#", ($STT_CATALOG_UPDATE + $STT_CATALOG_ADD), GetMessage("CICML_LOAD_CATALOG"))." ";
	$strImportOKMessage .= str_replace("#NUM_UPD#", $STT_CATALOG_UPDATE, str_replace("#NUM_NEW#", $STT_CATALOG_ADD, GetMessage("CICML_LOAD_NEW_UPD")))." ";

	if (intval($STT_CATALOG_ERROR) > 0)
		$strImportOKMessage .= str_replace("#NUM#", $STT_CATALOG_ERROR, GetMessage("CICML_LOAD_ERROR"));
	$strImportOKMessage .= "<br>";

	$strImportOKMessage .= str_replace("#NUM#", ($STT_GROUP_UPDATE + $STT_GROUP_ADD), GetMessage("CICML_LOAD_GROUP"))." ";
	$strImportOKMessage .= str_replace("#NUM_UPD#", $STT_GROUP_UPDATE, str_replace("#NUM_NEW#", $STT_GROUP_ADD, GetMessage("CICML_LOAD_GROUP_NEW_UPD")))." ";

	if (intval($STT_GROUP_ERROR) > 0)
		$strImportOKMessage .= str_replace("#NUM#", $STT_GROUP_ERROR, GetMessage("CICML_LOAD_GROUP_ERROR"));
	$strImportOKMessage .= "<br>";

	$strImportOKMessage .= str_replace("#NUM#", ($STT_PROP_UPDATE + $STT_PROP_ADD), GetMessage("CICML_LOAD_PROPS"))." ";
	$strImportOKMessage .= str_replace("#NUM_UPD#", $STT_PROP_UPDATE, str_replace("#NUM_NEW#", $STT_PROP_ADD, GetMessage("CICML_LOAD_PROPS_NEW_UPD")))." ";

	if (intval($STT_PROP_ERROR) > 0)
		$strImportOKMessage .= str_replace("#NUM#", $STT_PROP_ERROR, GetMessage("CICML_LOAD_PROPS_ERROR"));
	$strImportOKMessage .= "<br>";

	$strImportOKMessage .= str_replace("#NUM#", ($STT_PRODUCT_UPDATE + $STT_PRODUCT_ADD), GetMessage("CICML_LOAD_PROD"))." ";
	$strImportOKMessage .= str_replace("#NUM_UPD#", $STT_PRODUCT_UPDATE, str_replace("#NUM_NEW#", $STT_PRODUCT_ADD, GetMessage("CICML_LOAD_PROD_NEW_UPD")))." ";

	if (intval($STT_PRODUCT_ERROR) > 0)
		$strImportOKMessage .= str_replace("#NUM#", $STT_PRODUCT_ERROR, GetMessage("CICML_LOAD_PROD_ERROR"));
	$strImportOKMessage .= "<br>";
}

if ($bTmpUserCreated)
{
	if (isset($USER_TMP))
	{
		$USER = $USER_TMP;
		unset($USER_TMP);
	}
}