/*!
 * @license
 * Copyright 2019 Alfresco Software, Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import { BrowserActions, BrowserVisibility, DateUtil, DocumentListPage, TogglePage } from '@alfresco/adf-testing';
import { $$, browser, by, element, ElementFinder, ElementArrayFinder, protractor } from 'protractor';
import { DropActions } from '../../actions/drop.actions';
import { CreateLibraryDialogPage } from './dialog/create-library-dialog.page';
import { FolderDialogPage } from './dialog/folder-dialog.page';
import { NavigationBarPage } from './navigation-bar.page';

import path = require('path');
import { DropdownPage } from '../../../lib/testing/src/lib/material/pages/dropdown.page';

export class ContentServicesPage {

    columns = {
        name: 'Display name',
        size: 'Size',
        nodeId: 'Node id',
        createdBy: 'Created by',
        created: 'Created'
    };

    contentList: DocumentListPage = new DocumentListPage(element.all(by.css('adf-upload-drag-area adf-document-list')).first());
    togglePage: TogglePage = new TogglePage();
    createFolderDialog: FolderDialogPage = new FolderDialogPage();
    createLibraryDialog: CreateLibraryDialogPage = new CreateLibraryDialogPage();
    dragAndDropAction: DropActions = new DropActions();

    multipleFileUploadToggle: ElementFinder = element(by.id('adf-document-list-enable-drop-files'));
    uploadBorder: ElementFinder = element(by.id('document-list-container'));
    contentServices: ElementFinder = element(by.css('.app-sidenav-link[data-automation-id="Content Services"]'));
    currentFolder: ElementFinder = element(by.css('div[class*="adf-breadcrumb-item adf-active"] div'));
    createFolderButton: ElementFinder = element(by.css('button[data-automation-id="create-new-folder"]'));
    editFolderButton: ElementFinder = element(by.css('button[data-automation-id="edit-folder"]'));
    deleteNodesButton: ElementFinder = element(by.css('button[data-automation-id="delete-toolbar-button"]'));
    createLibraryButton: ElementFinder = element(by.css('button[data-automation-id="create-new-library"]'));
    activeBreadcrumb: ElementFinder = element(by.css('div[class*="active"]'));
    tooltip = by.css('div[class*="--text adf-full-width"] span');
    uploadFileButton: ElementFinder = element(by.css('.adf-upload-button-file-container button'));
    uploadFileButtonInput: ElementFinder = element(by.css('input[data-automation-id="upload-single-file"]'));
    uploadMultipleFileButton: ElementFinder = element(by.css('input[data-automation-id="upload-multiple-files"]'));
    uploadFolderButton: ElementFinder = element(by.css('input[data-automation-id="uploadFolder"]'));
    errorSnackBar: ElementFinder = element(by.css('simple-snack-bar[class*="mat-simple-snackbar"]'));
    emptyPagination: ElementFinder = element(by.css('adf-pagination[class*="adf-pagination__empty"]'));
    dragAndDrop: ElementFinder = element.all(by.css('adf-upload-drag-area div')).first();
    nameHeader: ElementFinder = element(by.css('div[data-automation-id="auto_id_name"] > span'));
    sizeHeader: ElementFinder = element(by.css('div[data-automation-id="auto_id_content.sizeInBytes"] > span'));
    createdByHeader: ElementFinder = element(by.css('div[data-automation-id="auto_id_createdByUser.displayName"] > span'));
    createdHeader: ElementFinder = element(by.css('div[data-automation-id="auto_id_createdAt"] > span'));
    recentFiles: ElementFinder = element(by.css('.app-container-recent'));
    recentFilesExpanded: ElementFinder = element(by.css('.app-container-recent mat-expansion-panel-header.mat-expanded'));
    recentFilesClosed: ElementFinder = element(by.css('.app-container-recent mat-expansion-panel-header'));
    recentFileIcon: ElementFinder = element(by.css('.app-container-recent mat-expansion-panel-header mat-icon'));
    emptyFolder: ElementFinder = element(by.css('.adf-empty-folder-this-space-is-empty'));
    emptyFolderImage: ElementFinder = element(by.css('.adf-empty-folder-image'));
    emptyRecent: ElementFinder = element(by.css('.app-container-recent .app-empty-list__title'));
    gridViewButton: ElementFinder = element(by.css('button[data-automation-id="document-list-grid-view"]'));
    cardViewContainer: ElementFinder = element(by.css('div.app-document-list-container div.adf-datatable-card'));
    shareNodeButton: ElementFinder = element(by.cssContainingText('mat-icon', ' share '));
    nameColumnHeader = 'name';
    createdByColumnHeader = 'createdByUser.displayName';
    createdColumnHeader = 'createdAt';
    deleteContentElement: ElementFinder = element(by.css('button[data-automation-id*="DELETE"]'));
    metadataAction: ElementFinder = element(by.css('button[data-automation-id*="METADATA"]'));
    versionManagerAction: ElementFinder = element(by.css('button[data-automation-id*="VERSIONS"]'));
    moveContentElement: ElementFinder = element(by.css('button[data-automation-id*="MOVE"]'));
    copyContentElement: ElementFinder = element(by.css('button[data-automation-id*="COPY"]'));
    lockContentElement: ElementFinder = element(by.css('button[data-automation-id="DOCUMENT_LIST.ACTIONS.LOCK"]'));
    downloadContent: ElementFinder = element(by.css('button[data-automation-id*="DOWNLOAD"]'));
    downloadButton: ElementFinder = element(by.css('button[title="Download"]'));
    favoriteButton: ElementFinder = element(by.css('button[data-automation-id="favorite"]'));
    markedFavorite: ElementFinder = element(by.cssContainingText('button[data-automation-id="favorite"] mat-icon', 'star'));
    notMarkedFavorite: ElementFinder = element(by.cssContainingText('button[data-automation-id="favorite"] mat-icon', 'star_border'));
    multiSelectToggle: ElementFinder = element(by.cssContainingText('span.mat-slide-toggle-content', ' Multiselect (with checkboxes) '));
    selectAllCheckbox: ElementFinder = element(by.css('.adf-checkbox-sr-only'));
    selectionModeDropdown: ElementFinder = element(by.css('.mat-select[aria-label="Selection Mode"]'));
    selectedNodesList: ElementArrayFinder = element.all(by.css('.app-content-service-settings li'));

    siteListDropdown = new DropdownPage(element(by.css(`mat-select[data-automation-id='site-my-files-option']`)));
    sortingDropdown = new DropdownPage(element(by.css('mat-select[data-automation-id="grid-view-sorting"]')));

    async pressContextMenuActionNamed(actionName): Promise<void> {
        await BrowserActions.clickExecuteScript(`button[data-automation-id="context-${actionName}"]`);
    }

    async checkContextActionIsVisible(actionName) {
        const actionButton: ElementFinder = element(by.css(`button[data-automation-id="context-${actionName}"`));
        await BrowserVisibility.waitUntilElementIsVisible(actionButton);
    }

    async isContextActionEnabled(actionName): Promise<boolean> {
        const actionButton: ElementFinder = element(by.css(`button[data-automation-id="context-${actionName}"`));
        await BrowserVisibility.waitUntilElementIsVisible(actionButton);
        return actionButton.isEnabled();
    }

    getDocumentList(): DocumentListPage {
        return this.contentList;
    }

    async closeActionContext(): Promise<void> {
        await BrowserActions.closeMenuAndDialogs();
    }

    async checkLockedIcon(content): Promise<void> {
        return this.contentList.checkLockedIcon(content);
    }

    async checkUnlockedIcon(content): Promise<void> {
        return this.contentList.checkUnlockedIcon(content);
    }

    async checkDeleteIsDisabled(content): Promise<void> {
        await this.contentList.clickOnActionMenu(content);
        await this.waitForContentOptions();
        const disabledDelete: ElementFinder = element(by.css(`button[data-automation-id*='DELETE'][disabled='true']`));
        await BrowserVisibility.waitUntilElementIsVisible(disabledDelete);
    }

    async deleteContent(content): Promise<void> {
        await this.contentList.clickOnActionMenu(content);
        await this.waitForContentOptions();
        await BrowserActions.click(this.deleteContentElement);
    }

    async clickDeleteOnToolbar(): Promise<void> {
        await BrowserActions.click(this.deleteNodesButton);
    }

    async checkToolbarDeleteIsDisabled(): Promise<void> {
        await BrowserActions.checkIsDisabled(this.deleteNodesButton);
    }

    async metadataContent(content): Promise<void> {
        await this.contentList.clickOnActionMenu(content);
        await this.waitForContentOptions();
        await BrowserActions.click(this.metadataAction);
    }

    async versionManagerContent(content): Promise<void> {
        await this.contentList.clickOnActionMenu(content);
        await this.waitForContentOptions();
        await BrowserActions.click(this.versionManagerAction);
    }

    async copyContent(content): Promise<void> {
        await this.contentList.clickOnActionMenu(content);
        await BrowserActions.click(this.copyContentElement);
    }

    async moveContent(content): Promise<void> {
        await this.contentList.clickOnActionMenu(content);
        await BrowserActions.click(this.moveContentElement);
    }

    async lockContent(content): Promise<void> {
        await this.contentList.clickOnActionMenu(content);
        await BrowserActions.click(this.lockContentElement);
    }

    async waitForContentOptions(): Promise<void> {
        await BrowserVisibility.waitUntilElementIsVisible(this.copyContentElement);
        await BrowserVisibility.waitUntilElementIsVisible(this.moveContentElement);
        await BrowserVisibility.waitUntilElementIsVisible(this.deleteContentElement);
        await BrowserVisibility.waitUntilElementIsVisible(this.downloadContent);
    }

    async clickFileHyperlink(fileName): Promise<void> {
        const hyperlink = this.contentList.dataTablePage().getFileHyperlink(fileName);
        await BrowserActions.click(hyperlink);
    }

    async checkFileHyperlinkIsEnabled(fileName): Promise<void> {
        const hyperlink = this.contentList.dataTablePage().getFileHyperlink(fileName);
        await BrowserVisibility.waitUntilElementIsVisible(hyperlink);
    }

    async clickHyperlinkNavigationToggle(): Promise<void> {
        const hyperlinkToggle: ElementFinder = element(by.cssContainingText('.mat-slide-toggle-content', 'Hyperlink navigation'));
        await BrowserActions.click(hyperlinkToggle);
    }

    async enableDropFilesInAFolder(): Promise<void> {
        await this.togglePage.enableToggle(this.multipleFileUploadToggle);
    }

    async disableDropFilesInAFolder(): Promise<void> {
        await browser.executeScript('arguments[0].scrollIntoView()', this.multipleFileUploadToggle);
        await this.togglePage.disableToggle(this.multipleFileUploadToggle);
    }

    async getElementsDisplayedId() {
        return this.contentList.dataTablePage().getAllRowsColumnValues(this.columns.nodeId);
    }

    checkElementsDateSortedAsc(elements) {
        let sorted = true;
        let i = 0;

        while (elements.length > 1 && sorted === true && i < (elements.length - 1)) {
            const left = DateUtil.parse(elements[i], 'DD-MM-YY');
            const right = DateUtil.parse(elements[i + 1], 'DD-MM-YY');
            if (left > right) {
                sorted = false;
            }
            i++;
        }

        return sorted;
    }

    checkElementsDateSortedDesc(elements) {
        let sorted = true;
        let i = 0;

        while (elements.length > 1 && sorted === true && i < (elements.length - 1)) {
            const left = DateUtil.parse(elements[i], 'DD-MM-YY');
            const right = DateUtil.parse(elements[i + 1], 'DD-MM-YY');
            if (left < right) {
                sorted = false;
            }
            i++;
        }

        return sorted;
    }

    async checkRecentFileToBeShowed() {
        await BrowserVisibility.waitUntilElementIsVisible(this.recentFiles);
    }

    async expandRecentFiles(): Promise<void> {
        await this.checkRecentFileToBeShowed();
        await this.checkRecentFileToBeClosed();
        await BrowserActions.click(this.recentFilesClosed);
        await this.checkRecentFileToBeOpened();
    }

    async closeRecentFiles(): Promise<void> {
        await this.checkRecentFileToBeShowed();
        await this.checkRecentFileToBeOpened();
        await BrowserActions.click(this.recentFilesExpanded);
        await this.checkRecentFileToBeClosed();
    }

    async checkRecentFileToBeClosed(): Promise<void> {
        await BrowserVisibility.waitUntilElementIsVisible(this.recentFilesClosed);
    }

    async checkRecentFileToBeOpened(): Promise<void> {
        await BrowserVisibility.waitUntilElementIsVisible(this.recentFilesExpanded);
    }

    async getRecentFileIcon(): Promise<string> {
        return BrowserActions.getText(this.recentFileIcon);
    }

    async checkDocumentListElementsAreDisplayed(): Promise<void> {
        await this.checkAcsContainer();
        await this.waitForTableBody();
    }

    async checkAcsContainer(): Promise<void> {
        await BrowserVisibility.waitUntilElementIsVisible(this.uploadBorder);
    }

    async waitForTableBody(): Promise<void> {
        await this.contentList.waitForTableBody();
    }

    async goToDocumentList(): Promise<void> {
        const navigationBarPage = new NavigationBarPage();
        await navigationBarPage.clickContentServicesButton();
    }

    async clickOnContentServices(): Promise<void> {
        await BrowserActions.click(this.contentServices);
    }

    async numberOfResultsDisplayed(): Promise<number> {
        return this.contentList.dataTablePage().numberOfRows();
    }

    async currentFolderName(): Promise<string> {
        return BrowserActions.getText(this.currentFolder);
    }

    async getAllRowsNameColumn(): Promise<any> {
        return this.contentList.getAllRowsColumnValues(this.columns.name);
    }

    async sortByName(sortOrder: string): Promise<any> {
        await this.contentList.dataTable.sortByColumn(sortOrder, this.nameColumnHeader);
    }

    async sortByAuthor(sortOrder: string): Promise<any> {
        await this.contentList.dataTable.sortByColumn(sortOrder, this.createdByColumnHeader);
    }

    async sortByCreated(sortOrder: string): Promise<any> {
        await this.contentList.dataTable.sortByColumn(sortOrder, this.createdColumnHeader);
    }

    async sortAndCheckListIsOrderedByName(sortOrder: string): Promise<any> {
        await this.sortByName(sortOrder);
        return this.checkListIsSortedByNameColumn(sortOrder);
    }

    async checkListIsSortedByNameColumn(sortOrder: string): Promise<any> {
        return this.contentList.dataTablePage().checkListIsSorted(sortOrder, this.columns.name);
    }

    async checkListIsSortedByCreatedColumn(sortOrder: string): Promise<any> {
        return this.contentList.dataTablePage().checkListIsSorted(sortOrder, this.columns.created);
    }

    async checkListIsSortedByAuthorColumn(sortOrder: string): Promise<any> {
        return this.contentList.dataTablePage().checkListIsSorted(sortOrder, this.columns.createdBy);
    }

    async checkListIsSortedBySizeColumn(sortOrder: string): Promise<any> {
        return this.contentList.dataTablePage().checkListIsSorted(sortOrder, this.columns.size);
    }

    async sortAndCheckListIsOrderedByAuthor(sortOrder: string): Promise<any> {
        await this.sortByAuthor(sortOrder);
        return this.checkListIsSortedByAuthorColumn(sortOrder);
    }

    async sortAndCheckListIsOrderedByCreated(sortOrder: string): Promise<any> {
        await this.sortByCreated(sortOrder);
        return this.checkListIsSortedByCreatedColumn(sortOrder);
    }

    async doubleClickRow(nodeName): Promise<void> {
        await this.contentList.doubleClickRow(nodeName);
    }

    async selectRow(nodeName): Promise<void> {
        await this.contentList.selectRow(nodeName);
    }

    async clickOnCreateNewFolder(): Promise<void> {
        await BrowserActions.click(this.createFolderButton);
    }

    async clickOnFavoriteButton(): Promise<void> {
        await BrowserActions.click(this.favoriteButton);
    }

    async checkIsMarkedFavorite(): Promise<void> {
        await BrowserVisibility.waitUntilElementIsVisible(this.markedFavorite);
    }

    async checkIsNotMarkedFavorite(): Promise<void> {
        await BrowserVisibility.waitUntilElementIsVisible(this.notMarkedFavorite);
    }

    async clickOnEditFolder(): Promise<void> {
        await BrowserActions.click(this.editFolderButton);
    }

    async isEditFolderButtonEnabled(): Promise<boolean> {
        return this.editFolderButton.isEnabled();
    }

    async openCreateLibraryDialog(): Promise<void> {
        await BrowserActions.click(this.createLibraryButton);
        await this.createLibraryDialog.waitForDialogToOpen();
    }

    async createNewFolder(folderName: string): Promise<void> {
        await this.clickOnCreateNewFolder();
        await this.createFolderDialog.addFolderName(folderName);
        await this.createFolderDialog.clickOnCreateUpdateButton();
    }

    async createAndOpenNewFolder(folderName: string): Promise<void> {
        await this.createNewFolder(folderName);
        await this.checkContentIsDisplayed(folderName);
        await this.openFolder(folderName);
    }

    async openFolder(folderName: string): Promise<void> {
        await this.doubleClickRow(folderName);
        await this.checkDocumentListElementsAreDisplayed();
    }

    async checkContentIsDisplayed(content): Promise<void> {
        await this.contentList.dataTablePage().checkContentIsDisplayed(this.columns.name, content);
    }

    async checkContentsAreDisplayed(content): Promise<void> {
        for (let i = 0; i < content.length; i++) {
            await this.checkContentIsDisplayed(content[i]);
        }
    }

    async checkContentIsNotDisplayed(content): Promise<void> {
        await this.contentList.dataTablePage().checkContentIsNotDisplayed(this.columns.name, content);
    }

    async deleteAndCheckFolderNotDisplayed(folderName: string): Promise<void> {
        await this.deleteContent(folderName);
        await this.checkContentIsNotDisplayed(folderName);
    }

    async deleteSubFolderUnderRoot(folderName: string, subFolderName: string): Promise<void> {
        await this.goToDocumentList();
        await this.openFolder(folderName);
        await this.deleteAndCheckFolderNotDisplayed(subFolderName);
    }

    async getActiveBreadcrumb(): Promise<string> {
        await BrowserVisibility.waitUntilElementIsVisible(this.activeBreadcrumb);
        return this.activeBreadcrumb.getAttribute('title');
    }

    async uploadFile(fileLocation): Promise<void> {
        await this.checkUploadButton();
        await this.uploadFileButtonInput.sendKeys(path.resolve(path.join(browser.params.testConfig.main.rootPath, fileLocation)));
        await this.checkUploadButton();
    }

    async uploadMultipleFile(files): Promise<void> {
        await BrowserVisibility.waitUntilElementIsPresent(this.uploadMultipleFileButton);
        let allFiles = path.resolve(path.join(browser.params.testConfig.main.rootPath, files[0]));
        for (let i = 1; i < files.length; i++) {
            allFiles = allFiles + '\n' + path.resolve(path.join(browser.params.testConfig.main.rootPath, files[i]));
        }
        await this.uploadMultipleFileButton.sendKeys(allFiles);
        await BrowserVisibility.waitUntilElementIsPresent(this.uploadMultipleFileButton);
    }

    async uploadFolder(folderLocation: string): Promise<void> {
        await BrowserVisibility.waitUntilElementIsPresent(this.uploadFolderButton);
        await this.uploadFolderButton.sendKeys(path.resolve(path.join(browser.params.testConfig.main.rootPath, folderLocation)));
    }

    async getSingleFileButtonTooltip(): Promise<string> {
        await BrowserVisibility.waitUntilElementIsPresent(this.uploadFileButton);
        return this.uploadFileButtonInput.getAttribute('title');
    }

    async getMultipleFileButtonTooltip(): Promise<string> {
        await BrowserVisibility.waitUntilElementIsPresent(this.uploadMultipleFileButton);
        return this.uploadMultipleFileButton.getAttribute('title');
    }

    async getFolderButtonTooltip(): Promise<string> {
        await BrowserVisibility.waitUntilElementIsPresent(this.uploadFolderButton);
        return this.uploadFolderButton.getAttribute('title');
    }

    async checkUploadButton(): Promise<void> {
        await BrowserVisibility.waitUntilElementIsClickable(this.uploadFileButton);
    }

    async uploadButtonIsEnabled(): Promise<boolean> {
        return this.uploadFileButton.isEnabled();
    }

    async getErrorMessage(): Promise<string> {
        return BrowserActions.getText(this.errorSnackBar);
    }

    async enableInfiniteScrolling(): Promise<void> {
        const infiniteScrollButton: ElementFinder = element(by.cssContainingText('.mat-slide-toggle-content', 'Enable Infinite Scrolling'));
        await BrowserActions.click(infiniteScrollButton);
    }

    async enableCustomPermissionMessage(): Promise<void> {
        const customPermissionMessage: ElementFinder = element(by.cssContainingText('.mat-slide-toggle-content', 'Enable custom permission message'));
        await BrowserActions.click(customPermissionMessage);
    }

    async enableMediumTimeFormat(): Promise<void> {
        const mediumTimeFormat: ElementFinder = element(by.css('#enableMediumTimeFormat'));
        await BrowserActions.click(mediumTimeFormat);
    }

    async enableThumbnails(): Promise<void> {
        const thumbnailSlide: ElementFinder = element(by.id('adf-thumbnails-upload-switch'));
        await BrowserActions.click(thumbnailSlide);
    }

    async checkPaginationIsNotDisplayed(): Promise<void> {
        await BrowserVisibility.waitUntilElementIsVisible(this.emptyPagination);
    }

    async getDocumentListRowNumber(): Promise<number> {
        const documentList: ElementFinder = element(by.css('adf-upload-drag-area adf-document-list'));
        await BrowserVisibility.waitUntilElementIsVisible(documentList);
        return $$('adf-upload-drag-area adf-document-list .adf-datatable-row').count();
    }

    async checkColumnNameHeader(): Promise<void> {
        await BrowserVisibility.waitUntilElementIsVisible(this.nameHeader);
    }

    async checkColumnSizeHeader(): Promise<void> {
        await BrowserVisibility.waitUntilElementIsVisible(this.sizeHeader);
    }

    async checkColumnCreatedByHeader(): Promise<void> {
        await BrowserVisibility.waitUntilElementIsVisible(this.createdByHeader);
    }

    async checkColumnCreatedHeader(): Promise<void> {
        await BrowserVisibility.waitUntilElementIsVisible(this.createdHeader);
    }

    async checkDragAndDropDIsDisplayed(): Promise<void> {
        await BrowserVisibility.waitUntilElementIsVisible(this.dragAndDrop);
    }

    async dragAndDropFile(file: string): Promise<void> {
        await this.checkDragAndDropDIsDisplayed();
        await this.dragAndDropAction.dropFile(this.dragAndDrop, file);
    }

    async dragAndDropFolder(folderName: string): Promise<void> {
        await this.checkDragAndDropDIsDisplayed();
        await this.dragAndDropAction.dropFolder(this.dragAndDrop, folderName);
    }

    async checkLockIsDisplayedForElement(name): Promise<void> {
        const lockButton: ElementFinder = element(by.css(`div.adf-datatable-cell[data-automation-id="${name}"] button`));
        await BrowserVisibility.waitUntilElementIsVisible(lockButton);
    }

    async getColumnValueForRow(file, columnName): Promise<string> {
        return this.contentList.dataTablePage().getColumnValueForRow(this.columns.name, file, columnName);
    }

    async getStyleValueForRowText(rowName, styleName): Promise<string> {
        const row: ElementFinder = element(by.css(`div.adf-datatable-cell[data-automation-id="${rowName}"] span.adf-datatable-cell-value[title="${rowName}"]`));
        await BrowserVisibility.waitUntilElementIsVisible(row);
        return row.getCssValue(styleName);
    }

    async checkEmptyFolderTextToBe(text): Promise<void> {
        await BrowserVisibility.waitUntilElementIsVisible(this.emptyFolder);
        await expect(await this.emptyFolder.getText()).toContain(text);
    }

    async checkEmptyFolderImageUrlToContain(url): Promise<void> {
        await BrowserVisibility.waitUntilElementIsVisible(this.emptyFolderImage);
        await expect(await this.emptyFolderImage.getAttribute('src')).toContain(url);
    }

    async checkEmptyRecentFileIsDisplayed(): Promise<void> {
        await BrowserVisibility.waitUntilElementIsVisible(this.emptyRecent);
    }

    async getRowIconImageUrl(fileName): Promise<string> {
        const iconRow: ElementFinder = element(by.css(`.app-document-list-container div.adf-datatable-cell[data-automation-id="${fileName}"] img`));
        await BrowserVisibility.waitUntilElementIsVisible(iconRow);
        return iconRow.getAttribute('src');
    }

    async checkGridViewButtonIsVisible(): Promise<void> {
        await BrowserVisibility.waitUntilElementIsVisible(this.gridViewButton);
    }

    async clickGridViewButton(): Promise<void> {
        await this.checkGridViewButtonIsVisible();
        await BrowserActions.click(this.gridViewButton);
    }

    async checkCardViewContainerIsDisplayed(): Promise<void> {
        await BrowserVisibility.waitUntilElementIsVisible(this.cardViewContainer);
    }

    async getCardElementShowedInPage(): Promise<number> {
        await BrowserVisibility.waitUntilElementIsVisible(this.cardViewContainer);
        return $$('div.app-document-list-container div.adf-datatable-card div.adf-cell-value img').count();
    }

    async getDocumentCardIconForElement(elementName): Promise<string> {
        const elementIcon: ElementFinder = element(by.css(`.app-document-list-container div.adf-datatable-cell[data-automation-id="${elementName}"] img`));
        return elementIcon.getAttribute('src');
    }

    async checkDocumentCardPropertyIsShowed(elementName, propertyName): Promise<void> {
        const elementProperty: ElementFinder = element(by.css(`.app-document-list-container div.adf-datatable-cell[data-automation-id="${elementName}"][title="${propertyName}"]`));
        await BrowserVisibility.waitUntilElementIsVisible(elementProperty);
    }

    async getAttributeValueForElement(elementName, propertyName): Promise<string> {
        const elementSize = element(by.css(`.app-document-list-container div.adf-datatable-cell[data-automation-id="${elementName}"][title="${propertyName}"] span`));
        return BrowserActions.getText(elementSize);
    }

    async checkMenuIsShowedForElementIndex(elementIndex): Promise<void> {
        const elementMenu: ElementFinder = element(by.css(`button[data-automation-id="action_menu_${elementIndex}"]`));
        await BrowserVisibility.waitUntilElementIsVisible(elementMenu);
    }

    async navigateToCardFolder(folderName): Promise<void> {
        await BrowserActions.closeMenuAndDialogs();
        const folderCard: ElementFinder = element(by.css(`.app-document-list-container div.adf-image-table-cell.adf-datatable-cell[data-automation-id="${folderName}"]`));
        await BrowserActions.click(folderCard);
        const folderSelected: ElementFinder = element(by.css(`.adf-datatable-row.adf-is-selected div[data-automation-id="${folderName}"].adf-datatable-cell--image`));
        await BrowserVisibility.waitUntilElementIsVisible(folderSelected);
        await browser.actions().sendKeys(protractor.Key.ENTER).perform();
    }

    async selectGridSortingFromDropdown(sortingOption): Promise<void> {
        await this.sortingDropdown.selectDropdownOption(sortingOption);
    }

    async checkRowIsDisplayed(rowName): Promise<void> {
        const row = this.contentList.dataTablePage().getCellElementByValue(this.columns.name, rowName);
        await BrowserVisibility.waitUntilElementIsVisible(row);
    }

    async clickShareButton(): Promise<void> {
        await BrowserActions.closeMenuAndDialogs();
        await BrowserActions.click(this.shareNodeButton);
    }

    async checkSelectedSiteIsDisplayed(siteName): Promise<void> {
        await this.siteListDropdown.checkOptionIsSelected(siteName);
    }

    async selectSite(siteName: string): Promise<void> {
        await this.siteListDropdown.selectDropdownOption(siteName);
    }

    async clickDownloadButton(): Promise<void> {
        await BrowserActions.closeMenuAndDialogs();
        await BrowserActions.click(this.downloadButton);
    }

    async clickMultiSelectToggle() {
        await BrowserActions.closeMenuAndDialogs();
        await BrowserActions.click(this.multiSelectToggle);
    }
    async multiSelectToggleIsEnabled(): Promise<boolean> {
        return this.multiSelectToggle.isEnabled();
    }
    async clickSelectAllCheckbox(): Promise<void> {
        await BrowserActions.click(this.selectAllCheckbox);
    }

    getRowByName(rowName): ElementFinder {
        return this.contentList.dataTable.getRow(this.columns.name, rowName);
    }

    async selectFolder(folderName: string): Promise<void> {
        const folderSelected: ElementFinder = element(by.css(`div[data-automation-id="${folderName}"] .adf-datatable-center-img-ie`));
        await BrowserVisibility.waitUntilElementIsVisible(folderSelected);
        await BrowserActions.click(folderSelected);
    }

    async selectFolderWithCommandKey(folderName: string): Promise<void> {
        await browser.actions().sendKeys(protractor.Key.COMMAND).perform();
        await this.selectRow(folderName);
        await browser.actions().sendKeys(protractor.Key.NULL).perform();
    }

    async chooseSelectionMode(option: string): Promise<void> {
        const dropdownPage = new DropdownPage(this.selectionModeDropdown);
        await dropdownPage.selectDropdownOption(option);
    }

    async getItemSelected(): Promise<string> {
        return BrowserActions.getArrayText(this.selectedNodesList);
    }

    async selectItemWithCheckbox(itemName: string): Promise<void> {
        const item: ElementFinder = element(by.css(`adf-datatable-row[aria-label="${itemName}"] mat-checkbox .mat-checkbox-input`));
        await BrowserVisibility.waitUntilElementIsVisible(item);
        await BrowserActions.click(item);
    }

    async unSelectItemWithCheckbox(itemName: string): Promise<void> {
        const item: ElementFinder = element(by.css(`adf-datatable-row[aria-label="${itemName} selected"] mat-checkbox .mat-checkbox-input`));
        await BrowserVisibility.waitUntilElementIsVisible(item);
        await BrowserActions.click(item);
    }
}