if (!window.partnerLedTrialProfiler) {
    window.PartnerLedTrialProfiler = class PartnerLedTrialProfiler {
        constructor(opts) {
            const SELECTORS = {
                formWrapper: ".profiler-form",
                submitButton: ".submit",
                formElement: ".form-element",
                input: "input",
                inputChecked: "input:checked",
            };

            const EVENTS = {
                ON_CHANGE: "change",
                ON_SUBMIT: "submit",
            };

            const STRINGS = {
                PROFILER: "-profiler",
                ARIA_DISABLED: "aria-disabled",
                PROFILERFORMDATA: "profilerFormData",
                QUALIFIEDPARTNERS: "qualifiedPartners",
                PROFILERSUMMARY: "ProfilerSummary"
            };

            let ELEMENTS = {};

            let MAPS = {};
           
            const setupElements = () => {
                ELEMENTS = {
                    ...ELEMENTS,
                    form: this.wrapper.querySelector(SELECTORS.formWrapper),
                    submit: this.wrapper.querySelector(SELECTORS.submitButton),
                    questionContainer: this.wrapper.querySelectorAll(SELECTORS.formElement),
                    input: this.wrapper.querySelectorAll(SELECTORS.input),
                };
                STRINGS.trialType = ELEMENTS.form.dataset.trialtype;
                STRINGS.standardTrialUrl = ELEMENTS.form.dataset.standardtrialurl;
                STRINGS.recommenderPageUrl = ELEMENTS.form.dataset.recommenderpageurl;
                STRINGS.rankingJSON = ELEMENTS.form.dataset.partnerjson;
                MAPS.partnerRankingMaster = JSON.parse(STRINGS.rankingJSON);
                MAPS.partnerRanking = MAPS.partnerRankingMaster[STRINGS.trialType];
            };

            const buildProfilerFormData = () => {
                const formData = new FormData(ELEMENTS.form);
                const profilerData = {};
                formData.forEach((key, name) => {
                    const value = ELEMENTS.form.querySelector(
                        `[value="${key}"]`
                    ).dataset.item;

                    const label = ELEMENTS.form.querySelector(`#${name}`).dataset.questionlabel;

                    if (!profilerData[name]) {
                        profilerData[name] = {
                            questionLabel: label,
                            answer: []
                        };
                    }

                    profilerData[name].answer.push({ key, value });
                });
            
                // Extracts answer values from profilerData and stores it in an array
                const answerList = Object.values(profilerData).map(question => question.answer.map(item => item.value).join(','));
                prepareTelemetryData(answerList);

                return profilerData;
            };

            /**
            * Prepares telemetry data for Profiler Summary
            * @param {Array} answerList 
            */
            const prepareTelemetryData = (answerList) => {
                MAPS.profilerTelemetryData = {
                    id: STRINGS.PROFILERSUMMARY,
                };
                answerList.forEach((answer, index) => {
                    MAPS.profilerTelemetryData[`field${index + 1}`] = answer;
                });
            };

            /**
            * Captures a page action event.
            * @param {string} actionType
            * @param {string[]} contentTags
            * @param {number} behavior
            */
            const firePageAction = (actionType = "A", contentTags, behavior = 0) => {
                const overrides = {
                  actionType: actionType,
                  behavior: behavior,
                  contentTags: contentTags
                };
                try {
                  window.telemetry.webAnalyticsPlugin?.capturePageAction(null, overrides);
                }
                catch (error) {
                  console.error(error);
                }
            };

            const profilerSubmitHandler = (e) => {
                e.preventDefault();
                const profilerData = buildProfilerFormData();
                let qualifiedPartners = [];

                MAPS.partnerRanking.forEach((partner) => {
                    let totalRank = null;
                    let ranks = [];

                    const rankingObj = JSON.parse(partner.ranking);
                    Object.keys(rankingObj).forEach((qid) => {
                        const answersData = rankingObj[qid];

                        if (profilerData[qid]) {
                            profilerData[qid].answer.forEach((profilerAnswer) => {
                                const evaluatedRankObj = answersData.find(
                                    (answer) => answer.key == profilerAnswer.key
                                );
                                if (evaluatedRankObj) {
                                    ranks.push(evaluatedRankObj.rank);
                                }
                            });
                        }
                    });

                    const isPartnerQualified = !ranks.some((rank) => rank === "NULL");
                    

                    if (isPartnerQualified) {
                        totalRank = ranks.reduce((acc, eachRank) => {
                            const numericRank =
                                parseInt(eachRank);
                            return acc + numericRank;
                        }, 0);
                    }

                    if (totalRank !== null) {
                        qualifiedPartners.push({
                            id: partner.id,
                            rank: totalRank,
                            salesValue: partner.salesValue,
                            partnerName: partner.partnerName,
                        });
                    }
                });
                const sortedPartners = getSortedPartners(qualifiedPartners);
                MAPS.qualifiedPartnerIds = buildQualifiedPartnerIdsObj(sortedPartners);
                setLocalStorageValues();

                // Trigger page action event
                firePageAction("A", MAPS.profilerTelemetryData, 22);

                window.location.href = MAPS.qualifiedPartnerIds.length > 0 ? STRINGS.recommenderPageUrl : STRINGS.standardTrialUrl;
            };

            const getSortedPartners = (qualifiedPartners) => {
                return qualifiedPartners.slice().sort((partnerA, partnerB) => {
                    const partnerRankCompare = partnerB.rank - partnerA.rank;
                    if (partnerRankCompare !== 0) {
                        return partnerRankCompare;
                    }
                    return compareSalesValueAndName(partnerA, partnerB);
                    
                });
            };

            const compareSalesValueAndName = (partnerA, partnerB) => {
                const partnerSalesValueCompare = partnerB.salesValue - partnerA.salesValue;
                    if (partnerSalesValueCompare !== 0) {
                        return partnerSalesValueCompare;
                    }
            
                return partnerA.partnerName.localeCompare(partnerB.partnerName);
            }

            const buildQualifiedPartnerIdsObj = (sortedPartners) => {
                return sortedPartners.map(
                    (partner, index) => ({
                        id: index + 1,
                        partnerId: partner.id,
                    })
                );
            } ;

            const setLocalStorageValues = () => {
                localStorageUtil.setItem(STRINGS.PROFILERFORMDATA, buildProfilerFormData());
                localStorageUtil.setItem(STRINGS.QUALIFIEDPARTNERS, MAPS.qualifiedPartnerIds);
            };

            const updateButtonState = () => {
                let isValid = true;

                ELEMENTS.questionContainer.forEach((container) => {
                    const questionInputs = container.querySelectorAll(
                        SELECTORS.inputChecked
                    );
                    if (questionInputs.length === 0) {
                        isValid = false;
                    }
                });
                isValid
                ? (ELEMENTS.submit.disabled = !isValid, ELEMENTS.submit.setAttribute(STRINGS.ARIA_DISABLED, 'false'))
                : (ELEMENTS.submit.disabled = true, ELEMENTS.submit.setAttribute(STRINGS.ARIA_DISABLED, 'true'));
            };

            this._init = () => {
                setupElements(this.wrapper);

                // On Submit button event listener
                ELEMENTS.form.addEventListener(
                    EVENTS.ON_SUBMIT,
                    profilerSubmitHandler
                );

                // On change event listener for input
                ELEMENTS.input.forEach((input) => {
                    input.addEventListener(EVENTS.ON_CHANGE, updateButtonState);
                });
            };

            this.wrapper = opts.element;
            this._init();
            const localStorageUtil = new LocalStorageUtil({
                storageKey: STRINGS.trialType + STRINGS.PROFILER,
            });
        }
    };
}
partnerLedTrialProfilerInstances = [];