import React from 'react';

import {useHistory} from 'react-router-dom';

import {
    getNodeHostLabel,
    getNodeHostPath,
} from '../../../components/NodeHostWrapper/NodeHostWrapper';
import type {PaginatedTableData, RenderErrorMessage} from '../../../components/PaginatedTable';
import {PAGINATED_TABLE_IDS, ResizeablePaginatedTable} from '../../../components/PaginatedTable';
import {NODES_COLUMNS_IDS} from '../../../components/nodesColumns/constants';
import type {NodesColumn} from '../../../components/nodesColumns/types';
import {VISIBLE_ENTITIES} from '../../../store/reducers/storage/constants';
import type {PreparedStorageNode, VisibleEntities} from '../../../store/reducers/storage/types';
import type {NodesGroupByField} from '../../../types/api/nodes';
import {cn} from '../../../utils/cn';
import {useHideUnavailableNodes} from '../../../utils/hooks/useHideUnavailableNodes';
import {NodesUptimeFilterValues, isUnavailableNode} from '../../../utils/nodes';
import {STORAGE_NODES_DEFAULT_ROW_HEIGHT} from '../PaginatedStorageNodes/nodeExpertModeLayout';

import {StorageNodesEmptyDataMessage} from './StorageNodesEmptyDataMessage';
import {STORAGE_NODES_COLUMNS_WIDTH_LS_KEY} from './columns/constants';
import {getStorageNodes} from './getNodes';
import i18n from './i18n';

import './StorageNodes.scss';

const b = cn('ydb-storage-nodes');

const getRowUnavailableClassName = (row: PreparedStorageNode) =>
    b('node', {unavailable: isUnavailableNode(row)});

interface PaginatedStorageNodesTableProps {
    columns: NodesColumn[];

    database?: string;
    nodeId?: string | number;
    groupId?: string | number;

    filterGroup?: string;
    filterGroupBy?: NodesGroupByField;

    searchValue: string;
    visibleEntities: VisibleEntities;
    nodesUptimeFilter: NodesUptimeFilterValues;
    onShowAll: VoidFunction;

    scrollContainerRef: React.RefObject<HTMLElement>;
    renderErrorMessage: RenderErrorMessage;
    initialEntitiesCount?: number;
    rowHeight?: number;
    onDataFetched?: (data: PaginatedTableData<PreparedStorageNode>) => void;
}

export const PaginatedStorageNodesTable = ({
    columns,
    database,
    nodeId,
    groupId,
    filterGroup,
    filterGroupBy,
    searchValue,
    visibleEntities,
    nodesUptimeFilter,
    onShowAll,
    scrollContainerRef,
    renderErrorMessage,
    initialEntitiesCount,
    rowHeight = STORAGE_NODES_DEFAULT_ROW_HEIGHT,
    onDataFetched,
}: PaginatedStorageNodesTableProps) => {
    const history = useHistory();
    const {hideUnavailable} = useHideUnavailableNodes();
    const tableFilters = React.useMemo(() => {
        return {
            searchValue,
            hideUnavailable,
            visibleEntities,
            nodesUptimeFilter,
            database,
            nodeId,
            groupId,
            filterGroup,
            filterGroupBy,
        };
    }, [
        hideUnavailable,
        searchValue,
        visibleEntities,
        nodesUptimeFilter,
        database,
        nodeId,
        groupId,
        filterGroup,
        filterGroupBy,
    ]);

    const renderEmptyDataMessage = () => {
        if (
            visibleEntities !== VISIBLE_ENTITIES.all ||
            nodesUptimeFilter !== NodesUptimeFilterValues.All
        ) {
            return (
                <StorageNodesEmptyDataMessage
                    onShowAll={onShowAll}
                    nodesUptimeFilter={nodesUptimeFilter}
                    visibleEntities={visibleEntities}
                />
            );
        }

        return i18n('empty.default');
    };

    return (
        <ResizeablePaginatedTable
            getKeyboardRowKey={(node) => node.NodeId}
            getKeyboardRowLabel={getNodeHostLabel}
            onKeyboardActivate={(node) => {
                const nodePath = getNodeHostPath(node, database);
                if (nodePath) {
                    history.push(nodePath);
                }
            }}
            columnsWidthLSKey={STORAGE_NODES_COLUMNS_WIDTH_LS_KEY}
            scrollContainerRef={scrollContainerRef}
            columns={columns}
            fetchData={getStorageNodes}
            rowHeight={
                columns.some((column) => column.name === NODES_COLUMNS_IDS.PDisks)
                    ? rowHeight
                    : undefined
            }
            initialEntitiesCount={initialEntitiesCount}
            renderErrorMessage={renderErrorMessage}
            renderEmptyDataMessage={renderEmptyDataMessage}
            getRowClassName={getRowUnavailableClassName}
            filters={tableFilters}
            tableName={PAGINATED_TABLE_IDS.STORAGE_NODES}
            onDataFetched={onDataFetched}
        />
    );
};