<?php
use Bitrix\Main,
    Bitrix\Main\Loader,
    Bitrix\Main\Context,
    Bitrix\Main\Localization\Loc;

if (!defined('B_PROLOG_INCLUDED') || B_PROLOG_INCLUDED !== true)
    die();

class DTKUsersEdit  extends CBitrixComponent
{

    /**
     * ID пользователя
     */
    protected $userId = 0;

    /**
     * Содержит данные запроса
     */
    protected $context;
    protected $request;

    /**
     * Значения полей
     */
    protected $fieldsValues = array();

    /**
     * Значения полей переданные через POST
     */
    protected $requestValues = array();

    /**
     * Список полей формы
     */
    protected $formFields = array();

    /**
     * Массив значений полей
     */
    protected $updateValues = array();

    /**
     * Массив значений полей для добавления\редактирования
     */
    protected $fieldsUpdateValues = array();

    /**
     * Статус добавления \ редактирования пользователя
     */
    protected $success = false;

    /**
     * Список ошибок
     */
    protected $errors = array();

    /**
     * Список полей пользователей
     */
    protected $arUserFields = array(
        'ID',
        'LOGIN',
        'EMAIL',
        'NAME',
        'LAST_NAME',
        'SECOND_NAME',
        'PERSONAL_BIRTHDAY',
        'PERSONAL_PROFESSION',
        'PERSONAL_WWW',
        'PERSONAL_ICQ',
        'PERSONAL_GENDER',
        'PERSONAL_PHOTO',
        'PERSONAL_PHONE',
        'PERSONAL_FAX',
        'PERSONAL_MOBILE',
        'PERSONAL_PAGER',
        'PERSONAL_STREET',
        'PERSONAL_MAILBOX',
        'PERSONAL_CITY',
        'PERSONAL_STATE',
        'PERSONAL_ZIP',
        'PERSONAL_COUNTRY',
        'PERSONAL_NOTES',
        'WORK_COMPANY',
        'WORK_DEPARTMENT',
        'WORK_POSITION',
        'WORK_WWW',
        'WORK_PHONE',
        'WORK_FAX',
        'WORK_PAGER',
        'WORK_STREET',
        'WORK_MAILBOX',
        'WORK_CITY',
        'WORK_STATE',
        'WORK_ZIP',
        'WORK_COUNTRY',
        'WORK_PROFILE',
        'WORK_NOTES',
        'ADMIN_NOTES',
        'WORK_LOGO',
        'XML_ID',
        'PASSWORD'
    );

    /**
     * Подключение ланговых файлов
     */
    public function onIncludeComponentLang()
    {
        $this->includeComponentLang(basename(__FILE__));
        Loc::loadMessages(__FILE__);
    }

    /**
     * Обработка параметров компонента
     */
    public function onPrepareComponentParams($arParams)
    {
        $this->userId = intval($arParams['USER_ID']);
        return $arParams;
    }

    protected function getUserFields($selectedFields)
    {
        $arFields = array();

        // User fields
        foreach ($this->arUserFields as $field)
        {
            if (in_array($field, $selectedFields))
            {
                $arField = array(
                    'NAME' => (strlen(Loc::getMessage('USER_FIELD_' . $field)) > 0) ? Loc::getMessage('USER_FIELD_' . $field) : $field,
                    'MULTIPLE' => 'N'
                );

                if ($field == 'PERSONAL_PHOTO' || $field == 'WORK_LOGO')
                {
                    $arField['TYPE'] = 'F';
                }

                if ($field == 'EMAIL' && $this->arParams['EDIT_GEN_LOGIN_AND_PASS'] == 'Y')
                {
                    $arField['REQUIRED'] = 'Y';
                }

                // Вместе с паролем получаем поле для подтверждения
                if ($field == 'PASSWORD')
                {
                    $arFields['CONFIRM_PASSWORD'] = array(
                        'NAME' => 'CONFIRM_PASSWORD',
                        'MULTIPLE' => 'N'
                    );
                }

                $arFields[$field] = $arField;
            }
        }

        // User props
        $arRes = $GLOBALS['USER_FIELD_MANAGER']->GetUserFields('USER', 0, LANGUAGE_ID);

        if (!empty($arRes))
        {
            foreach ($arRes as $key => $val)
            {
                if (in_array($val['FIELD_NAME'], $selectedFields))
                {
                    $arProp = array(
                        'NAME' => (strLen($val['EDIT_FORM_LABEL']) > 0 ? $val['EDIT_FORM_LABEL'] : $val['FIELD_NAME']),
                        'MULTIPLE' => $val['MULTIPLE']
                    );

                    if ($val['USER_TYPE_ID'] == 'file') // Файл
                    {
                        $arProp['TYPE'] = 'F';
                    }
                    elseif($val['USER_TYPE_ID'] == 'iblock_element') // Привязка к элементу инфоблока
                    {
                        $arProp['TYPE'] = 'L';
                    }
                    else
                    {
                        $arProp['TYPE'] = 'S';
                    }

                    $arFields[$val['FIELD_NAME']] = $arProp ;
                }
            }
        }

        return $arFields;
    }

    /**
     * Получить все значения полей указанного пользователя
     *
     * @param int - ID пользователя
     *
     * @return array
     */
    protected function getUserFieldsValues($userId, $selectedFields)
    {
        $fieldsValues = array();
        // Получаем значения свойств элемента инфоблока
        if($userId > 0)
        {
            $by = 'sort';
            $tmp = 'asc';
            $select = array(
                'FIELDS' => $selectedFields,
                'SELECT' => $selectedFields,
            );

            $rsUser = CUser::GetList(
                $by,
                $tmp,
                array(
                    'ID' => $this->userId
                ),
                $select
            );

            if ($arUser = $rsUser->GetNext())
            {
                foreach ($arUser as $fieldCode => $value)
                {
                    if ($this->fields[$fieldCode]['TYPE'] == 'F')
                    {
                        if ($arFile = CFile::GetFileArray($value))
                        {
                            $value = array(
                                'FILE' => $arFile
                            );
                        }
                        else
                        {
                            $value = '';
                        }
                    }

                    // Нет смысла выводить хэш пароля, поэтому значение остается пустым
                    if ($fieldCode == 'PASSWORD')
                        continue;

                    $fieldsValues[$fieldCode] = $value;
                }
            }
        }
        return $fieldsValues;
    }

    /*
     * Получить данные из запроса
     */
    protected function getRequestData()
    {
        $this->context = Context::getCurrent();
        $this->request = $this->context->getRequest();

        if ($this->userId == 0 && intval($this->request->get('ID')) > 0)
        {
            $this->userId = $this->request->get('ID');
        }

        if($this->request->getPost('submit') <> '')
        {
            $this->requestValues = $this->request->getPost('FIELDS');
        }
    }

    /*
     * Получаем данные
     */
    protected function getResultData()
    {
        $this->fields = $this->getUserFields($this->arParams['EDIT_FIELDS']);

        if ($this->userId > 0)
        {
            $this->fieldsValues = $this->getUserFieldsValues($this->userId, $this->arParams['EDIT_FIELDS']);
        }

        if (!empty($this->requestValues))
        {
            $this->fieldsValues = $this->prepareFieldsValues($this->fields, $this->requestValues, $this->fieldsValues);
        }
    }

    /*
     * Заменяем текущие значения, значениями переданными в REQUEST запросе
     */
    protected function prepareFieldsValues($fields, $requestValues, $fieldsValues)
    {
        // Присваимваем пустые значения свойствам, которых не было в запросе
        foreach ($fields as $fieldCode => $field)
        {
            if (!isset($requestValues[$fieldCode])){
                $requestValues[$fieldCode] = '';
            }
        }

        if (is_array($requestValues) && count($requestValues) > 0)
        {
            foreach($requestValues as $fieldCode => $fieldValue)
            {
                if ($fields[$fieldCode]['TYPE'] == 'F')
                {
                    continue;
                }
                $fieldsValues[$fieldCode] = htmlspecialcharsEx($fieldValue);
            }
        }

        // Сохранить старый пароль если не был передан новый
        if (empty($fieldsValues['PASSWORD']) && empty($fieldsValues['CONFIRM_PASSWORD']))
        {
            unset($fieldsValues['PASSWORD'], $fieldsValues['CONFIRM_PASSWORD']);
        }

        return $fieldsValues;
    }

    /*
     * Получить массив данных для вызова API добавления \ редактирования элемента инфоблока
     */
    protected function getUpdateFieldsValues($fields, $fieldsValues)
    {
        $delRequest = $this->request->get('DELETE_FILE');

        $updateValues = array();

        if (is_array($fieldsValues) && count($fieldsValues) > 0)
        {
            foreach($fieldsValues as $fieldCode => $fieldValue)
            {
                if ($fields[$fieldCode]['TYPE'] == 'F') // Файл
                {
                    $arFile = $this->request->getFile('FIELD_FILE_' . $fieldCode);
                    $arFile["del"] = ($delRequest[$fieldCode] == "Y") ? "Y" : "";

                    if (intval($fieldValue) > 0)
                    {
                        $arFile["old_file"] = $fieldValue;
                    }

                    if($arFile["del"] == 'Y' || $arFile['tmp_name'] <> '')
                    {
                        $updateValues[$fieldCode] = $arFile;
                    }
                    else
                    {
                        unset($updateValues[$fieldCode]);
                    }
                }
                else
                {
                    $updateValues[$fieldCode] = htmlspecialcharsBack($fieldValue);
                }

                if (substr($fieldCode, 0, 1) == '~')
                    unset($updateValues[$fieldCode]);
            }
        }

        return $updateValues;
    }

    /*
     * Выполнить добавление \ редактирование пользователя
     */
    protected function performAction()
    {
        $this->checkUpdateData($this->fields, $this->fieldsUpdateValues, $this->arParams['EDIT_REQUIRED_FIELDS']);

        if ($this->request->getPost('haserror') == '' && empty($this->errors))
        {
            if ($this->userId > 0)
            {
                $this->updateUser($this->userId, $this->fieldsUpdateValues);
            }
            else
            {
                if ($this->fieldsUpdateValues['LOGIN'] == '' || $this->fieldsUpdateValues['PASSWORD'] == '') {
                    $this->arParams['EDIT_GEN_LOGIN_AND_PASS'] = 'Y';
                }
                $this->addUser($this->fieldsUpdateValues, $this->arParams['EDIT_GEN_LOGIN_AND_PASS'], $this->arParams['USER_GROUP']);
            }

            if ($this->success == true)
            {
                global $APPLICATION;
                LocalRedirect($APPLICATION->GetCurPageParam("success=yes", array('success'), false));
            }
        }
    }

    /*
     * Подготовить данные для вывода
     */
    protected function prepareResultData()
    {
        $this->formFields = $this->getFormFields($this->fields, $this->arParams['EDIT_REQUIRED_FIELDS'], $this->errors['FIELDS'], $this->fieldsValues);
    }

    /*
     * Подготовить данные пришедщие из REQUEST запроса
     */
    protected function prepareRequestData()
    {
        $this->fieldsUpdateValues = $this->getUpdateFieldsValues($this->fields, $this->fieldsValues);
    }

    /**
     * Получаем массив полей формы для вывода
     *
     * @param array - Массив полей пользователя
     * @param array - Массив полей, выбранных обязательными для заполнения
     * @param array - Массив с ошибками полей
     * @param array - Массив текущих значений полей, либо переданных в запросе
     *
     * @return array
     */
    protected function getFormFields($fields, $fieldsRequired, $fieldsErrors, $fieldsValues)
    {
        $formFields = array();

        if(is_array($fields) && count($fields) > 0)
        {
            foreach($fields as $fieldCode => $field)
            {
                switch ($field['TYPE'])
                {
                    case 'L':
                        break;
                    case 'F':
                        $formFields[$fieldCode] = array(
                            'CODE' => $fieldCode,
                            'CONTROL_ID' => 'edit_cid_' . strtolower($fieldCode),
                            'CONTROL_NAME' => 'FIELDS[' . $fieldCode . ']',
                            'CONTROL_FILE_DEL_ID' => 'edit_file_del_cid_' . strtolower($fieldCode),
                            'CONTROL_FILE_ID' => 'edit_file_cid_' . strtolower($fieldCode),
                            'CONTROL_FILE_NAME' => 'FIELD_FILE_' . $fieldCode,
                            'CONTROL_FILE_DELETE' => 'DELETE_FILE[' . $fieldCode . ']',
                            'NAME' => $field['NAME'],
                            'REQUIRED' => (in_array($fieldCode, $fieldsRequired)) ? 'Y' : 'N',
                            'ERROR' => (isset($fieldsErrors[$fieldCode])) ? $fieldsErrors[$fieldCode] : '',
                            'VALUE' => $fieldsValues[$fieldCode]['FILE']
                        );
                        break;
                    default:
                        $formFields[$fieldCode] = array(
                            'CODE' => $fieldCode,
                            'CONTROL_ID' => 'edit_cid_' . strtolower($fieldCode),
                            'CONTROL_NAME' => 'FIELDS[' . $fieldCode . ']',
                            'NAME' => $field['NAME'],
                            'REQUIRED' => (in_array($fieldCode, $fieldsRequired) || $field['REQUIRED']) ? 'Y' : 'N',
                            'ERROR' => (isset($fieldsErrors[$fieldCode])) ? $fieldsErrors[$fieldCode] : '',
                            'VALUE' => $fieldsValues[$fieldCode]
                        );
                }
            }
        }

        return $formFields;
    }

    /*
     * Проверка переданных значений перед добавлением \ редактированием элемента инфоблока
     */
    protected function checkUpdateData($fields, $fieldsValues, $requiredFields)
    {
        //global $DB;
        if (is_array($fields) && count($fields) > 0)
        {
            foreach ($fieldsValues as $fieldCode => $fieldValue)
            {
                if (empty($fieldValue) && in_array($fieldCode, $requiredFields))
                {
                    $arError['FIELDS'][$fieldCode] = Loc::getMessage('ERROR_FIELD_EMPTY');
                }
            }

            if (!$GLOBALS['USER_FIELD_MANAGER']->CheckFields("USER", 0, $fieldsValues))
            {
                global $APPLICATION;
                $e = $APPLICATION->GetException();
                $propErrors = $e->GetMessages();
                $APPLICATION->ResetException();

                if (is_array($propErrors) && count($propErrors) > 0)
                {
                    foreach ($propErrors as $error)
                    {
                        $arError['FIELDS'][$error['id']] =  $error['text'];
                    }
                }
            }
        }

        $this->errors = $arError;
    }

    /**
     * Обновление пользователя
     *
     * @param int - ID пользователя
     * @param array - Список обновляемых полей
     *
     * @return void
     */
    protected function updateUser($userId, $updateValues)
    {
        if($userId > 0)
        {
            $user = new CUser;

            if ($updateValues['LOGIN'] == '' || $updateValues['PASSWORD'] == '')
            {
                unset($updateValues['LOGIN'], $updateValues['PASSWORD'], $updateValues['CONFIRM_PASSWORD']);
            }

            if (!$res = $user->Update($userId, $updateValues))
            {
                $this->errors['MAIN'][] = $user->LAST_ERROR;
            }
            else
            {
                $this->success = true;
            }
        }
    }

    /**
     * Добавление пользователя
     *
     * @param array - Список добавляемых полей
     *
     * @return void
     */
    protected function addUser($updateValues, $genLoginAndPass, $groupIds)
    {
        $user = new CUser;

        if ($genLoginAndPass == 'Y')
        {
            if ($updateValues['EMAIL'] != '')
            {
                $login = $updateValues['EMAIL'];
                $password = substr(md5($updateValues['EMAIL']), 10);

                $updateValues['LOGIN'] = $login;
                $updateValues['PASSWORD'] = $password;
                $updateValues['CONFIRM_PASSWORD'] = $password;
            }
            else
            {
                $this->errors['MAIN'][] = Loc::getMessage('ERROR_FIELD_EMAIL');
            }
        }

        $updateValues['GROUP_ID'] = $groupIds;

        if (!$resultId = $user->Add($updateValues))
        {
            $this->errors['MAIN'][] = $user->LAST_ERROR;
        }
        else
        {
            $this->success = true;
        }

        return $resultId;
    }

    /**
     * Заполняем массив arResult данными
     *
     * @return void
     */
    protected function formatResult()
    {
        $this->arResult['USER_ID'] = $this->userId;
        $this->arResult['UPDATE_VALUE'] = $this->fieldsUpdateValues;
        $this->arResult['FORM_FIELDS'] = $this->formFields;
        $this->arResult['ERRORS'] = $this->errors;
        $this->arResult["PARAMS_HASH"] = md5(serialize($this->arParams).$this->GetTemplateName());
        $this->arResult['SUCCESS'] = (empty($this->errors)) ? $this->request->get('success') : false;
        $this->arResult['SUCCESS_REDIRECT'] = $this->arParams['SUCCESS_REDIRECT'];
    }

    /**
     * Выполняем код компонента
     */
    public function executeComponent()
    {
        try
        {
            global $APPLICATION;

            $this->setFrameMode(false);

            $this->getRequestData();
            $this->getResultData();

            if ($this->request->getPost('submit') <> '')
            {
                $this->prepareRequestData();
                $this->performAction();
            }

            $this->prepareResultData();
            $this->formatResult();
        }
        catch (Main\SystemException $e)
        {
            ShowError($e->getMessage());
        }

        $this->includeComponentTemplate();
    }
}
?>