import React from 'react';

import type {NodesColumnId} from '../../../../components/nodesColumns/constants';
import {
    NODES_COLUMNS_IDS,
    NODES_COLUMNS_TITLES,
} from '../../../../components/nodesColumns/constants';
import {
    useBlobStorageCapacityMetricsEnabled,
    useBridgeModeEnabled,
} from '../../../../store/reducers/capabilities/hooks';
import {VISIBLE_ENTITIES} from '../../../../store/reducers/storage/constants';
import {
    mergeColumnsPreservingHiddenPositions,
    useSelectedColumns,
} from '../../../../utils/hooks/useSelectedColumns';

import {getStorageNodesColumns} from './columns';
import {
    CAPACITY_METRICS_USER_SETTINGS_COLUMNS_IDS,
    DEFAULT_STORAGE_NODES_COLUMNS,
    REQUIRED_STORAGE_NODES_COLUMNS,
    STORAGE_NODES_SELECTED_COLUMNS_LS_KEY,
} from './constants';
import type {GetStorageNodesColumnsParams} from './types';

const LEGACY_CAPACITY_COLUMN_IDS: NodesColumnId[] = [NODES_COLUMNS_IDS.DiskSpaceUsage];

export function useStorageNodesSelectedColumns({
    visibleEntities,
    database,
    viewContext,
    columnsSettings,
}: GetStorageNodesColumnsParams) {
    const bridgeModeEnabled = useBridgeModeEnabled();
    const blobMetricsEnabled = useBlobStorageCapacityMetricsEnabled();

    const skippedColumnIds = React.useMemo(() => {
        const skipped: NodesColumnId[] = [];

        if (!bridgeModeEnabled) {
            skipped.push(NODES_COLUMNS_IDS.PileName);
        }

        return skipped;
    }, [bridgeModeEnabled]);

    const columns = React.useMemo(() => {
        const allColumns = getStorageNodesColumns({database, viewContext, columnsSettings});

        return allColumns.filter((column) => !skippedColumnIds.some((id) => id === column.name));
    }, [database, viewContext, columnsSettings, skippedColumnIds]);

    const stickyColumns = React.useMemo(() => {
        if (visibleEntities === VISIBLE_ENTITIES.missing) {
            return [...REQUIRED_STORAGE_NODES_COLUMNS, NODES_COLUMNS_IDS.Missing];
        }
        return REQUIRED_STORAGE_NODES_COLUMNS;
    }, [visibleEntities]);

    const requiredColumns = React.useMemo(() => {
        return columnsSettings?.expertMode
            ? [...stickyColumns, NODES_COLUMNS_IDS.PDisks]
            : stickyColumns;
    }, [columnsSettings?.expertMode, stickyColumns]);

    const defaultColumns = React.useMemo(() => {
        if (!bridgeModeEnabled) {
            return DEFAULT_STORAGE_NODES_COLUMNS;
        }
        return DEFAULT_STORAGE_NODES_COLUMNS.includes(NODES_COLUMNS_IDS.PileName)
            ? DEFAULT_STORAGE_NODES_COLUMNS
            : [...DEFAULT_STORAGE_NODES_COLUMNS, NODES_COLUMNS_IDS.PileName];
    }, [bridgeModeEnabled]);

    const selectedColumns = useSelectedColumns(
        columns,
        STORAGE_NODES_SELECTED_COLUMNS_LS_KEY,
        NODES_COLUMNS_TITLES,
        defaultColumns,
        requiredColumns,
        stickyColumns,
    );

    const hiddenCapacityColumnIds = blobMetricsEnabled
        ? LEGACY_CAPACITY_COLUMN_IDS
        : CAPACITY_METRICS_USER_SETTINGS_COLUMNS_IDS;
    const setColumns: typeof selectedColumns.setColumns = React.useCallback(
        (value) => {
            selectedColumns.setColumns(
                mergeColumnsPreservingHiddenPositions(
                    value,
                    selectedColumns.columnsToSelect,
                    hiddenCapacityColumnIds,
                ),
            );
        },
        [hiddenCapacityColumnIds, selectedColumns],
    );

    return React.useMemo(() => {
        return {
            ...selectedColumns,
            columnsToShow: selectedColumns.columnsToShow.filter(
                ({name}) => !hiddenCapacityColumnIds.some((columnId) => columnId === name),
            ),
            columnsToSelect: selectedColumns.columnsToSelect.filter(
                ({id}) => !hiddenCapacityColumnIds.some((columnId) => columnId === id),
            ),
            setColumns,
        };
    }, [hiddenCapacityColumnIds, selectedColumns, setColumns]);
}