import { LSAClient } from '@lenovo-software/lsa-clients-common';
import { WebLimitBlockType, WebLimitParams } from '@lenovo-software/lsa-clients-common/dist/models/limitingModels';
import { Logger } from '../../common/logger';

// TODO: Read from LSAClient
const MAX_ALLOWED_URLS = 100;

export class WebLimitBlockPage {
    private blockTypeParamName: string = 'bt';
    private urlListParamName: string = 'u';

    private blockTypeParamAllBlocked: string = 'all';
    private blockTypeParamAllowed: string = 'allowed';
    private blockTypeParamBlocked: string = 'blocked';

    private envBlockPage: string = 'https://lanschoolair.lenovosoftware.com/assets/client-limiting/index.html';

    private logger = Logger.getInstance();

    constructor() {
        this.init();
    }

    private init(): void {
        const apiServer = LSAClient.getInstance().clientParams.apiServerForHTTPS;
        if (apiServer && apiServer.length > 0) {
            const re = /api-lsa-([0-9a-z-_]*)\.lenovosoftware\.com/i;
            let env = '';
            let a = apiServer.match(re);
            if (a && Array.isArray(a) && a.length > 1) {
                env = a[1];
            }

            if (env.length > 1)
                this.envBlockPage = this.envBlockPage.replace('lanschoolair.', 'lanschoolair-' + env + '.');
        }
    }

    getWebLimitBlockPage(params: WebLimitParams): string {
        let blockQueryString = this.getBlockingPageQueryString(params);
        if (blockQueryString && blockQueryString.length > 0) {
            const classParam = this.getFormParamForClass(params.className);
            if (classParam && classParam.length > 0) blockQueryString += '&' + classParam;
        }

        let blockPage = blockQueryString ? this.envBlockPage + '?' + blockQueryString : '';
        this.logger.logMessage('WebLimitBlockPage: ' + blockPage);
        return blockPage;
    }

    getFormParamForClass(className: string): string | undefined {
        if (className && className.length > 0) {
            return this.formParam('limitedby', className);
        }
    }

    getBlockPageToIgnore(): string {
        return this.envBlockPage + '*';
    }

    formParam = function (name: string, value: string): string {
        return name + '=' + value;
    };

    getBlockingPageQueryString(params: WebLimitParams): string | undefined {
        this.logger.logMessage('getBlockingPageQueryString');
        if (!params) {
            return;
        }

        const sitesLength = params?.sites?.length || 0;

        if (params.blockType === WebLimitBlockType.BlockAll) {
            return this.formParam(this.blockTypeParamName, this.blockTypeParamAllBlocked);
        } else if (params.blockType === WebLimitBlockType.Block && sitesLength >= 0) {
            return this.formParam(this.blockTypeParamName, this.blockTypeParamBlocked);
        } else if (params.blockType === WebLimitBlockType.Allow) {
            // return this.formParam(this.blockTypeParamName, this.blockTypeParamBlocked);
            let qs = this.formParam(this.blockTypeParamName, this.blockTypeParamAllowed);

            if (params.sites && sitesLength > 0) {
                let allowedUrlConstruct = '';
                for (let i = 0; i < sitesLength && i < MAX_ALLOWED_URLS; i++) {
                    if (i > 0) allowedUrlConstruct += ',';

                    allowedUrlConstruct += encodeURIComponent(params.sites[i]);
                }

                qs += '&' + this.formParam(this.urlListParamName, allowedUrlConstruct);
            } else {
                // LSA-950: An empty array of "allowed" websites should block all sites
                return this.formParam(this.blockTypeParamName, this.blockTypeParamAllBlocked);
            }

            return qs;
        }
    }
}