/*!
 * SAPUI5
 * Copyright (c) 2025 SAP SE or an SAP affiliate company. All rights reserved.
 */
import Log from "sap/base/Log";
import { DataSourceConfiguration } from "./SearchConfigurationTypes";
import { DataSource } from "./sinaNexTS/sina/DataSource";
import SearchResultListItemDocument from "./controls/resultview/SearchResultListItemDocument";
import Control from "sap/ui/core/Control";

const log = Log.getLogger("sap.esh.search.ui.SearchDataSourcesConfigurations");

const controlIds = [
    "searchResultListItem",
    "searchResultListItemContent",
    "searchResultListSelectionHandler",
];

const documentDataSourceConfiguration: DataSourceConfiguration = {
    searchResultListItemControl: SearchResultListItemDocument as any,
};

export class SearchDataSourceConfigurations {
    private dataSourceConfigurations: Record<string, DataSourceConfiguration> = {};
    private dataSourceConfigurations_Regexes: Array<DataSourceConfiguration> = [];
    private dataSourceLoadingProms: Record<string, Promise<void>> = {};

    public initDataSourceConfig(dataSources: Array<DataSourceConfiguration> = []): void {
        //
        for (let i = 0; i < dataSources.length; i++) {
            const dataSourceConfig = dataSources[i];
            if (dataSourceConfig.id) {
                // datasource configuration with id
                this.dataSourceConfigurations[dataSourceConfig.id] = dataSourceConfig;
            } else if (dataSourceConfig.regex) {
                // datasource configuration with regex
                const flags = dataSourceConfig.regexFlags || undefined;
                const regexObject = new RegExp(dataSourceConfig.regex, flags);
                if (regexObject) {
                    dataSourceConfig.regexObject = regexObject;
                    this.dataSourceConfigurations_Regexes.push(dataSourceConfig);
                }
            } else {
                // invalid datasource configuration
                const message =
                    "Following datasource configuration does neither include a valid id nor a regular expression, therefore it is ignored:\n" +
                    JSON.stringify(dataSourceConfig);
                log.warning(message);
            }
        }
    }

    public async loadCustomModulesForDataSourcesAsync(
        dataSources: Array<DataSource> = [],
        dataSourcesHints: Array<Record<string, unknown>> = []
    ): Promise<void> {
        await Promise.all(
            dataSources.map((dataSource, i) => {
                return this.loadCustomModulesForDataSourceAsync(dataSource, dataSourcesHints[i]);
            })
        );
    }

    public getDataSourceConfig(dataSource: DataSource): DataSourceConfiguration {
        const dataSourceConfig = this.dataSourceConfigurations[dataSource.id];
        if (!dataSourceConfig || !(dataSourceConfig as any).loaded) {
            return {};
        }
        return dataSourceConfig;
    }

    private loadCustomModulesForDataSourceAsync(
        dataSource: DataSource,
        dataSourceHints?: Record<string, unknown>
    ): Promise<void> {
        // check for datasource existence and id
        if (!dataSource || !dataSource.id) {
            return Promise.resolve();
        }

        // check if custom modules for this data source are already loading or loaded
        let dataSourceLoadingProm: any = this.dataSourceLoadingProms[dataSource.id];
        if (dataSourceLoadingProm) {
            return dataSourceLoadingProm;
        }

        // load custom modules for this data source
        const dataSourceConfiguration = this.getDataSourceConfigInternal(dataSource.id, dataSourceHints);
        dataSourceLoadingProm = (async () => {
            await Promise.all(
                controlIds.map(async (controlId) => {
                    const controlConstructorFunction = controlId + "Control";
                    // check if custom module for this control is already loaded
                    if (dataSourceConfiguration[controlConstructorFunction]) {
                        return;
                    }
                    // load custom module for this control
                    const modulePath = controlId;
                    dataSourceConfiguration[controlConstructorFunction] = await this.loadCustomModuleAsync(
                        dataSourceConfiguration[modulePath]
                    );
                })
            );
            (dataSourceConfiguration as any).loaded = true;
        })();

        this.dataSourceLoadingProms[dataSource.id] = dataSourceLoadingProm;
        return dataSourceLoadingProm;
    }

    private loadCustomModuleAsync(modulePath: string): Promise<typeof Control | undefined> {
        if (!modulePath) {
            return Promise.resolve(undefined);
        }
        return new Promise((resolve) => {
            try {
                sap.ui.require([modulePath.replace(/[.]/g, "/")], function (customControl) {
                    resolve(customControl);
                });
            } catch (e) {
                let message = "Could not load custom module '" + modulePath + "'. ";
                message += "Falling back to default data source configuration.";
                log.warning(message, e as Error);
                resolve(undefined);
            }
        });
    }

    private getDataSourceConfigInternal(dataSourceId: string, dataSourceHints): DataSourceConfiguration {
        // check for configuration by id
        let dataSourceConfiguration = this.dataSourceConfigurations[dataSourceId];
        if (dataSourceConfiguration) {
            this.modifyDataSourceConfigForDocuments(dataSourceConfiguration, dataSourceHints);
            return dataSourceConfiguration;
        }

        // check for configuration by regex
        for (let i = 0; i < this.dataSourceConfigurations_Regexes.length; i++) {
            if (this.dataSourceConfigurations_Regexes[i].regexObject.test(dataSourceId)) {
                dataSourceConfiguration = this.dataSourceConfigurations_Regexes[i];
                this.dataSourceConfigurations[dataSourceId] = dataSourceConfiguration; // cache config for future use
                this.modifyDataSourceConfigForDocuments(dataSourceConfiguration, dataSourceHints);
                return dataSourceConfiguration;
            }
        }

        // fallback to empty configuration
        dataSourceConfiguration = {};
        this.dataSourceConfigurations[dataSourceId] = dataSourceConfiguration; // cache config for future use
        this.modifyDataSourceConfigForDocuments(dataSourceConfiguration, dataSourceHints);
        return dataSourceConfiguration;
    }

    private modifyDataSourceConfigForDocuments(
        dataSourceConfiguration: DataSourceConfiguration,
        dataSourceHints
    ): void {
        if (dataSourceHints && dataSourceHints.isDocumentConnector) {
            if (!dataSourceConfiguration.searchResultListItem) {
                dataSourceConfiguration.searchResultListItem =
                    documentDataSourceConfiguration.searchResultListItem;
            }
        }
    }
}