// Copyright (C) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
import * as Enums from "./enums";
import * as Utils from "./utils";
import { GlobalSettings } from "./shared";
import { ChannelAdapter } from "./channel-adapter";
import {
    ActivityResponse,
    IActivityRequest,
    ActivityRequestTrigger,
    SuccessResponse,
    ErrorResponse,
    LoginRequestResponse
} from "./activity-request";
import { Strings } from "./strings";
import {
    SubmitAction,
    ExecuteAction,
    SerializationContext,
    AdaptiveCard,
    Action,
    Input,
    TokenExchangeResource,
    AuthCardButton,
    UniversalAction,
    ChoiceSetInput,
    DataQuery
} from "./card-elements";
import { Versions } from "./serialization";
import { HostConfig } from "./host-config";

function logEvent(level: Enums.LogLevel, message?: any, ...optionalParams: any[]) {
    if (GlobalSettings.applets.logEnabled) {
        if (GlobalSettings.applets.onLogEvent) {
            GlobalSettings.applets.onLogEvent(level, message, optionalParams);
        } else {
            /* eslint-disable no-console */
            switch (level) {
                case Enums.LogLevel.Warning:
                    console.warn(message, optionalParams);
                    break;
                case Enums.LogLevel.Error:
                    console.error(message, optionalParams);
                    break;
                default:
                    console.log(message, optionalParams);
                    break;
            }
            /* eslint-enable no-console */
        }
    }
}

class ActivityRequest implements IActivityRequest {
    constructor(
        readonly action: UniversalAction,
        readonly trigger: ActivityRequestTrigger,
        readonly consecutiveActions: number
    ) {}

    authCode?: string;
    authToken?: string;
    attemptNumber: number = 0;

    onSend: (sender: ActivityRequest) => void;

    // eslint-disable-next-line @typescript-eslint/require-await
    async retryAsync(): Promise<void> {
        if (this.onSend) {
            this.onSend(this);
        }
    }
}

export class AdaptiveApplet {
    private static readonly _submitMagicCodeActionId = "submitMagicCode";
    private static readonly _cancelMagicCodeAuthActionId = "cancelMagicCodeAuth";

    private _card?: AdaptiveCard;
    private _cardPayload: any;
    private _choiceSet?: ChoiceSetInput;
    private _allowAutomaticCardUpdate: boolean = false;
    private _refreshButtonHostElement: HTMLElement;
    private _cardHostElement: HTMLElement;
    private _progressOverlay?: HTMLElement;

    private displayCard(card: AdaptiveCard) {
        if (card.renderedElement) {
            Utils.clearElementChildren(this._cardHostElement);

            this._refreshButtonHostElement.style.display = "none";

            this._cardHostElement.appendChild(card.renderedElement);
        } else {
            throw new Error("displayCard: undefined card.");
        }
    }

    private showManualRefreshButton(refreshAction: ExecuteAction) {
        const displayBuiltInManualRefreshButton = this.onShowManualRefreshButton
            ? this.onShowManualRefreshButton(this)
            : true;

        if (displayBuiltInManualRefreshButton) {
            this._refreshButtonHostElement.style.display = "none";

            let renderedRefreshButton: HTMLElement | undefined = undefined;

            if (this.onRenderManualRefreshButton) {
                renderedRefreshButton = this.onRenderManualRefreshButton(this);
            } else {
                let message = Strings.runtime.refreshThisCard();

                if (GlobalSettings.applets.refresh.mode === Enums.RefreshMode.Automatic) {
                    let autoRefreshPausedMessage = Strings.runtime.automaticRefreshPaused();

                    if (autoRefreshPausedMessage[autoRefreshPausedMessage.length - 1] !== " ") {
                        autoRefreshPausedMessage += " ";
                    }

                    message = Strings.runtime.clckToRestartAutomaticRefresh();
                }

                const cardPayload = {
                    type: "AdaptiveCard",
                    version: "1.2",
                    body: [
                        {
                            type: "RichTextBlock",
                            horizontalAlignment: "right",
                            inlines: [
                                {
                                    type: "TextRun",
                                    text: message,
                                    selectAction: {
                                        type: "Action.Submit",
                                        id: "refreshCard"
                                    }
                                }
                            ]
                        }
                    ]
                };

                const card = new AdaptiveCard();
                card.parse(cardPayload, new SerializationContext(Versions.v1_2));
                card.onExecuteAction = (action: Action) => {
                    if (action.id === "refreshCard") {
                        Utils.clearElementChildren(this._refreshButtonHostElement);

                        this.internalExecuteAction(
                            refreshAction,
                            ActivityRequestTrigger.Automatic,
                            0
                        );
                    }
                };

                renderedRefreshButton = card.render();
            }

            if (renderedRefreshButton) {
                Utils.clearElementChildren(this._refreshButtonHostElement);

                this._refreshButtonHostElement.appendChild(renderedRefreshButton);

                this._refreshButtonHostElement.style.removeProperty("display");
            }
        }
    }

    private createActivityRequest(
        action: UniversalAction,
        trigger: ActivityRequestTrigger,
        consecutiveActions: number
    ): ActivityRequest | undefined {
        if (this.card) {
            const request = new ActivityRequest(action, trigger, consecutiveActions);
            request.onSend = (sender: ActivityRequest) => {
                sender.attemptNumber++;

                void this.internalSendActivityRequestAsync(request);
            };

            const cancel = this.onPrepareActivityRequest
                ? !this.onPrepareActivityRequest(this, request, action)
                : false;

            return cancel ? undefined : request;
        } else {
            throw new Error("createActivityRequest: no card has been set.");
        }
    }

    private createMagicCodeInputCard(attemptNumber: number): AdaptiveCard {
        const payload = {
            type: "AdaptiveCard",
            version: "1.0",
            body: [
                {
                    type: "TextBlock",
                    color: "attention",
                    text: attemptNumber === 1 ? undefined : "That didn't work... let's try again.",
                    wrap: true,
                    horizontalAlignment: "center"
                },
                {
                    type: "TextBlock",
                    text: 'Please login in the popup. You will obtain a magic code. Paste that code below and select "Submit"',
                    wrap: true,
                    horizontalAlignment: "center"
                },
                {
                    type: "Input.Text",
                    id: "magicCode",
                    placeholder: "Enter magic code"
                },
                {
                    type: "ActionSet",
                    horizontalAlignment: "center",
                    actions: [
                        {
                            type: "Action.Submit",
                            id: AdaptiveApplet._submitMagicCodeActionId,
                            title: "Submit"
                        },
                        {
                            type: "Action.Submit",
                            id: AdaptiveApplet._cancelMagicCodeAuthActionId,
                            title: "Cancel"
                        }
                    ]
                }
            ]
        };

        const card = new AdaptiveCard();
        card.parse(payload);

        return card;
    }

    private cancelAutomaticRefresh() {
        if (this._allowAutomaticCardUpdate) {
            logEvent(
                Enums.LogLevel.Warning,
                "Automatic card refresh has been cancelled as a result of the user interacting with the card."
            );
        }

        this._allowAutomaticCardUpdate = false;
    }

    private createSerializationContext(): SerializationContext {
        return this.onCreateSerializationContext
            ? this.onCreateSerializationContext(this)
            : new SerializationContext();
    }

    private internalSetCard(payload: any, consecutiveActions: number) {
        if (typeof payload === "object" && payload["type"] === "AdaptiveCard") {
            this._cardPayload = payload;
        }

        if (this._cardPayload) {
            try {
                const card = new AdaptiveCard();

                if (this.hostConfig) {
                    card.hostConfig = this.hostConfig;
                }

                const serializationContext = this.createSerializationContext();

                card.parse(this._cardPayload, serializationContext);

                const doChangeCard = this.onCardChanging
                    ? this.onCardChanging(this, this._cardPayload)
                    : true;

                if (doChangeCard) {
                    this._card = card;

                    if (
                        this._card.authentication &&
                        this._card.authentication.tokenExchangeResource &&
                        this.onPrefetchSSOToken
                    ) {
                        this.onPrefetchSSOToken(
                            this,
                            this._card.authentication.tokenExchangeResource
                        );
                    }

                    this._card.onExecuteAction = (action: Action) => {
                        // If the user takes an action, cancel any pending automatic refresh
                        this.cancelAutomaticRefresh();

                        this.internalExecuteAction(action, ActivityRequestTrigger.Manual, 0);
                    };
                    this._card.onInputValueChanged = (input: Input) => {
                        // If the user modifies an input, cancel any pending automatic refresh
                        this.cancelAutomaticRefresh();
                        if (input instanceof ChoiceSetInput && input.isDynamicTypeahead()) {
                            const filter = input.getFilterForDynamicSearch();
                            if (filter) {
                                const dataQueryAction = new DataQuery();
                                dataQueryAction.filter = filter;
                                dataQueryAction.dataset = input.choicesData?.dataset || "";
                                dataQueryAction.count = input.choicesData?.count;
                                dataQueryAction.skip = input.choicesData?.skip;

                                this._choiceSet = input;
                                this.internalExecuteAction(
                                    dataQueryAction,
                                    ActivityRequestTrigger.Manual,
                                    0 // consecutiveActions
                                );
                            }
                        }
                    };

                    this._card.render();

                    if (this._card.renderedElement) {
                        this.displayCard(this._card);

                        if (this.onCardChanged) {
                            this.onCardChanged(this);
                        }

                        if (this._card.refresh) {
                            if (
                                GlobalSettings.applets.refresh.mode ===
                                    Enums.RefreshMode.Automatic &&
                                consecutiveActions <
                                    GlobalSettings.applets.refresh
                                        .maximumConsecutiveAutomaticRefreshes
                            ) {
                                if (
                                    GlobalSettings.applets.refresh.timeBetweenAutomaticRefreshes <=
                                    0
                                ) {
                                    logEvent(
                                        Enums.LogLevel.Info,
                                        "Triggering automatic card refresh number " +
                                            (consecutiveActions + 1)
                                    );

                                    this.internalExecuteAction(
                                        this._card.refresh.action,
                                        ActivityRequestTrigger.Automatic,
                                        consecutiveActions + 1
                                    );
                                } else {
                                    logEvent(
                                        Enums.LogLevel.Info,
                                        "Scheduling automatic card refresh number " +
                                            (consecutiveActions + 1) +
                                            " in " +
                                            GlobalSettings.applets.refresh
                                                .timeBetweenAutomaticRefreshes +
                                            "ms"
                                    );

                                    const action = this._card.refresh.action;

                                    this._allowAutomaticCardUpdate = true;

                                    window.setTimeout(() => {
                                        if (this._allowAutomaticCardUpdate) {
                                            this.internalExecuteAction(
                                                action,
                                                ActivityRequestTrigger.Automatic,
                                                consecutiveActions + 1
                                            );
                                        }
                                    }, GlobalSettings.applets.refresh.timeBetweenAutomaticRefreshes);
                                }
                            } else if (
                                GlobalSettings.applets.refresh.mode !== Enums.RefreshMode.Disabled
                            ) {
                                if (consecutiveActions > 0) {
                                    logEvent(
                                        Enums.LogLevel.Warning,
                                        "Stopping automatic refreshes after " +
                                            consecutiveActions +
                                            " consecutive refreshes."
                                    );
                                } else {
                                    logEvent(
                                        Enums.LogLevel.Warning,
                                        "The card has a refresh section, but automatic refreshes are disabled."
                                    );
                                }

                                if (
                                    GlobalSettings.applets.refresh
                                        .allowManualRefreshesAfterAutomaticRefreshes ||
                                    GlobalSettings.applets.refresh.mode === Enums.RefreshMode.Manual
                                ) {
                                    logEvent(Enums.LogLevel.Info, "Showing manual refresh button.");

                                    this.showManualRefreshButton(this._card.refresh.action);
                                }
                            }
                        }
                    }
                }
            } catch (error) {
                // Ignore all errors
                logEvent(Enums.LogLevel.Error, "setCard: " + error);
            }
        }
    }

    private internalExecuteAction(
        action: Action,
        trigger: ActivityRequestTrigger,
        consecutiveActions: number
    ) {
        if (action instanceof UniversalAction) {
            if (this.channelAdapter) {
                const request = this.createActivityRequest(action, trigger, consecutiveActions);

                if (request) {
                    void request.retryAsync();
                }
            } else {
                throw new Error("internalExecuteAction: No channel adapter set.");
            }
        }

        if (this.onAction) {
            this.onAction(this, action);
        }
    }

    private createProgressOverlay(request: ActivityRequest): HTMLElement | undefined {
        if (!this._progressOverlay) {
            if (this.onCreateProgressOverlay) {
                this._progressOverlay = this.onCreateProgressOverlay(this, request);
            } else {
                this._progressOverlay = document.createElement("div");
                this._progressOverlay.className = "aaf-progress-overlay";

                const spinner = document.createElement("div");
                spinner.className = "aaf-spinner";
                spinner.style.width = "28px";
                spinner.style.height = "28px";

                this._progressOverlay.appendChild(spinner);
            }
        }

        return this._progressOverlay;
    }

    private removeProgressOverlay(request: IActivityRequest) {
        if (this.onRemoveProgressOverlay) {
            this.onRemoveProgressOverlay(this, request);
        }

        if (this._progressOverlay !== undefined) {
            this.renderedElement.removeChild(this._progressOverlay);

            this._progressOverlay = undefined;
        }
    }

    private activityRequestSucceeded(
        response: SuccessResponse,
        parsedContent: string | AdaptiveCard | undefined
    ) {
        if (this.onActivityRequestSucceeded) {
            this.onActivityRequestSucceeded(this, response, parsedContent);
        }
    }

    private activityRequestFailed(response: ErrorResponse): number {
        return this.onActivityRequestFailed
            ? this.onActivityRequestFailed(this, response)
            : GlobalSettings.applets.defaultTimeBetweenRetryAttempts;
    }

    private showAuthCodeInputDialog(request: ActivityRequest) {
        const showBuiltInAuthCodeInputCard = this.onShowAuthCodeInputDialog
            ? this.onShowAuthCodeInputDialog(this, request)
            : true;

        if (showBuiltInAuthCodeInputCard) {
            const authCodeInputCard = this.createMagicCodeInputCard(request.attemptNumber);
            authCodeInputCard.render();
            authCodeInputCard.onExecuteAction = (submitMagicCodeAction: Action) => {
                if (this.card && submitMagicCodeAction instanceof SubmitAction) {
                    switch (submitMagicCodeAction.id) {
                        case AdaptiveApplet._submitMagicCodeActionId:
                            let authCode: string | undefined = undefined;

                            if (
                                submitMagicCodeAction.data &&
                                typeof (<any>submitMagicCodeAction.data)["magicCode"] === "string"
                            ) {
                                authCode = (<any>submitMagicCodeAction.data)["magicCode"];
                            }

                            if (authCode) {
                                this.displayCard(this.card);

                                request.authCode = authCode;
                                void request.retryAsync();
                            } else {
                                alert("Please enter the magic code you received.");
                            }

                            break;
                        case AdaptiveApplet._cancelMagicCodeAuthActionId:
                            logEvent(Enums.LogLevel.Warning, "Authentication cancelled by user.");

                            this.displayCard(this.card);

                            break;
                        default:
                            logEvent(
                                Enums.LogLevel.Error,
                                "Unexpected action taken from magic code input card (id = " +
                                    submitMagicCodeAction.id +
                                    ")"
                            );

                            alert(Strings.magicCodeInputCard.somethingWentWrong());

                            break;
                    }
                }
            };

            this.displayCard(authCodeInputCard);
        }
    }

    private async internalSendActivityRequestAsync(request: ActivityRequest) {
        if (!this.channelAdapter) {
            throw new Error("internalSendActivityRequestAsync: channelAdapter is not set.");
        }
        const { action } = request;
        if (action instanceof ExecuteAction) {
            await this.internalSendExecuteRequestAsync(request);
        } else if (action instanceof DataQuery) {
            await this.internalSendDataQueryRequestAsync(request);
        } else {
            throw new Error("internalSendActivityRequestAsync: Unhandled Action Type");
        }
    }

    private async internalSendExecuteRequestAsync(request: ActivityRequest) {
        if (!this.channelAdapter) {
            throw new Error("internalSendExecuteRequestAsync: channelAdapter is not set.");
        }

        const overlay = this.createProgressOverlay(request);

        if (overlay !== undefined) {
            this.renderedElement.appendChild(overlay);
        }

        let done = false;

        while (!done) {
            let response: ActivityResponse | undefined = undefined;

            if (request.attemptNumber === 1) {
                logEvent(
                    Enums.LogLevel.Info,
                    "Sending activity request to channel (attempt " + request.attemptNumber + ")"
                );
            } else {
                logEvent(
                    Enums.LogLevel.Info,
                    "Re-sending activity request to channel (attempt " + request.attemptNumber + ")"
                );
            }

            try {
                response = await this.channelAdapter.sendRequestAsync(request);
            } catch (error) {
                logEvent(Enums.LogLevel.Error, "Activity request failed: " + error);

                this.removeProgressOverlay(request);

                done = true;
            }

            if (response) {
                if (response instanceof SuccessResponse) {
                    this.removeProgressOverlay(request);

                    if (response.rawContent === undefined) {
                        throw new Error(
                            "internalSendExecuteRequestAsync: Action.Execute result is undefined"
                        );
                    }

                    let parsedContent = response.rawContent;

                    try {
                        parsedContent = JSON.parse(response.rawContent);
                    } catch {
                        // Leave parseContent as is
                    }

                    if (typeof parsedContent === "string") {
                        logEvent(
                            Enums.LogLevel.Info,
                            "The activity request returned a string after " +
                                request.attemptNumber +
                                " attempt(s)."
                        );

                        this.activityRequestSucceeded(response, parsedContent);
                    } else if (
                        typeof parsedContent === "object" &&
                        parsedContent["type"] === "AdaptiveCard"
                    ) {
                        logEvent(
                            Enums.LogLevel.Info,
                            "The activity request returned an Adaptive Card after " +
                                request.attemptNumber +
                                " attempt(s)."
                        );

                        this.internalSetCard(parsedContent, request.consecutiveActions);
                        this.activityRequestSucceeded(response, this.card);
                    } else {
                        throw new Error(
                            "internalSendExecuteRequestAsync: Action.Execute result is of unsupported type (" +
                                typeof response.rawContent +
                                ")"
                        );
                    }

                    done = true;
                } else if (response instanceof ErrorResponse) {
                    const retryIn: number = this.activityRequestFailed(response);

                    if (
                        retryIn >= 0 &&
                        request.attemptNumber < GlobalSettings.applets.maximumRetryAttempts
                    ) {
                        logEvent(
                            Enums.LogLevel.Warning,
                            `Activity request failed: ${response.error.message}. Retrying in ${retryIn}ms`
                        );

                        request.attemptNumber++;

                        await new Promise<void>((resolve, _reject) => {
                            window.setTimeout(() => {
                                resolve();
                            }, retryIn);
                        });
                    } else {
                        logEvent(
                            Enums.LogLevel.Error,
                            `Activity request failed: ${response.error.message}. Giving up after ${request.attemptNumber} attempt(s)`
                        );

                        this.removeProgressOverlay(request);

                        done = true;
                    }
                } else if (response instanceof LoginRequestResponse) {
                    logEvent(
                        Enums.LogLevel.Info,
                        "The activity request returned a LoginRequestResponse after " +
                            request.attemptNumber +
                            " attempt(s)."
                    );

                    if (request.attemptNumber <= GlobalSettings.applets.maximumRetryAttempts) {
                        let attemptOAuth = true;

                        if (response.tokenExchangeResource && this.onSSOTokenNeeded) {
                            // Attempt to use SSO. The host will return true if it can handle SSO, in which case
                            // we bypass OAuth
                            attemptOAuth = !this.onSSOTokenNeeded(
                                this,
                                request,
                                response.tokenExchangeResource
                            );
                        }

                        if (attemptOAuth) {
                            // Attempt to use OAuth
                            this.removeProgressOverlay(request);

                            if (response.signinButton === undefined) {
                                throw new Error(
                                    "internalSendExecuteRequestAsync: the login request doesn't contain a valid signin URL."
                                );
                            }

                            logEvent(
                                Enums.LogLevel.Info,
                                "Login required at " + response.signinButton.value
                            );

                            if (this.onShowSigninPrompt) {
                                // Bypass the built-in auth prompt if the host app handles it
                                this.onShowSigninPrompt(this, request, response.signinButton);
                            } else {
                                this.showAuthCodeInputDialog(request);

                                const left =
                                    window.screenX +
                                    (window.outerWidth - GlobalSettings.applets.authPromptWidth) /
                                        2;
                                const top =
                                    window.screenY +
                                    (window.outerHeight - GlobalSettings.applets.authPromptHeight) /
                                        2;

                                window.open(
                                    response.signinButton.value,
                                    response.signinButton.title
                                        ? response.signinButton.title
                                        : "Sign in",
                                    `width=${GlobalSettings.applets.authPromptWidth},height=${GlobalSettings.applets.authPromptHeight},left=${left},top=${top}`
                                );
                            }
                        }
                    } else {
                        logEvent(
                            Enums.LogLevel.Error,
                            "Authentication failed. Giving up after " +
                                request.attemptNumber +
                                " attempt(s)"
                        );

                        alert(Strings.magicCodeInputCard.authenticationFailed());
                    }

                    // Exit the loop. After a LoginRequestResponse, the host app is responsible for retrying the request
                    break;
                } else {
                    throw new Error("Unhandled response type: " + JSON.stringify(response));
                }
            }
        }
    }

    private async internalSendDataQueryRequestAsync(request: ActivityRequest) {
        if (!this.channelAdapter) {
            throw new Error("internalSendDataQueryRequestAsync: channel adapter not set");
        }
        const filter = (request.action as DataQuery).filter;
        if (this._choiceSet) {
            this._choiceSet.showLoadingIndicator();
            let response: ActivityResponse | undefined = undefined;
            try {
                response = await this.channelAdapter.sendRequestAsync(request);
            } catch (error) {
                this._choiceSet.showErrorIndicator(filter, "Unable to load");
                logEvent(Enums.LogLevel.Error, "Activity request failed: " + error);
            }
            if (response) {
                if (response instanceof SuccessResponse) {
                    const rawResponse = response.rawContent;
                    if (rawResponse) {
                        let parsedResponse;
                        try {
                            parsedResponse = JSON.parse(rawResponse);
                        } catch (error) {
                            this._choiceSet.showErrorIndicator(filter, "Unable to load");
                            throw new Error(
                                "internalSendDataQueryRequestAsync: Cannot parse response object: " +
                                    rawResponse
                            );
                        }
                        if (typeof parsedResponse === "object") {
                            this._choiceSet.renderChoices(filter, parsedResponse);
                            this.activityRequestSucceeded(response, rawResponse);
                        } else {
                            this._choiceSet.showErrorIndicator(filter, "Error loading results");
                            throw new Error(
                                "internalSendDataQueryRequestAsync: Data.Query result is of unsupported type (" +
                                    typeof rawResponse +
                                    ")"
                            );
                        }
                    } else {
                        this._choiceSet.showErrorIndicator(filter, "Unable to load");
                        throw new Error(
                            "internalSendDataQueryRequestAsync: Data.Query result is undefined"
                        );
                    }
                } else if (response instanceof ErrorResponse) {
                    this._choiceSet.showErrorIndicator(
                        filter,
                        response.error.message || "Error loading results"
                    );
                    logEvent(
                        Enums.LogLevel.Error,
                        `Activity request failed: ${response.error.message}.`
                    );
                    this.activityRequestFailed(response);
                } else {
                    this._choiceSet.showErrorIndicator(filter, "Unable to load");
                    throw new Error("Unhandled response type: " + JSON.stringify(response));
                }
            } else {
                this._choiceSet.removeLoadingIndicator();
            }
        }
    }

    readonly renderedElement: HTMLElement;

    hostConfig?: HostConfig;
    channelAdapter?: ChannelAdapter;

    onCardChanging?: (sender: AdaptiveApplet, card: any) => boolean;
    onCardChanged?: (sender: AdaptiveApplet) => void;
    onPrefetchSSOToken?: (
        sender: AdaptiveApplet,
        tokenExchangeResource: TokenExchangeResource
    ) => void;
    onSSOTokenNeeded?: (
        sender: AdaptiveApplet,
        request: IActivityRequest,
        tokenExchangeResource: TokenExchangeResource
    ) => boolean;
    onPrepareActivityRequest?: (
        sender: AdaptiveApplet,
        request: IActivityRequest,
        action: UniversalAction
    ) => boolean;
    onActivityRequestSucceeded?: (
        sender: AdaptiveApplet,
        response: SuccessResponse,
        parsedContent: string | AdaptiveCard | undefined
    ) => void;
    onActivityRequestFailed?: (sender: AdaptiveApplet, response: ErrorResponse) => number;
    onCreateSerializationContext?: (sender: AdaptiveApplet) => SerializationContext;
    onCreateProgressOverlay?: (
        sender: AdaptiveApplet,
        request: IActivityRequest
    ) => HTMLElement | undefined;
    onRemoveProgressOverlay?: (sender: AdaptiveApplet, request: IActivityRequest) => void;
    onRenderManualRefreshButton?: (sender: AdaptiveApplet) => HTMLElement | undefined;
    onAction?: (sender: AdaptiveApplet, action: Action) => void;
    onShowManualRefreshButton?: (sender: AdaptiveApplet) => boolean;
    onShowAuthCodeInputDialog?: (sender: AdaptiveApplet, request: IActivityRequest) => boolean;
    onShowSigninPrompt?: (
        sender: AdaptiveApplet,
        request: IActivityRequest,
        signinButton: AuthCardButton
    ) => void;

    constructor() {
        this.renderedElement = document.createElement("div");
        this.renderedElement.className = "aaf-cardHost";
        this.renderedElement.style.position = "relative";
        this.renderedElement.style.display = "flex";
        this.renderedElement.style.flexDirection = "column";

        this._cardHostElement = document.createElement("div");

        this._refreshButtonHostElement = document.createElement("div");
        this._refreshButtonHostElement.className = "aaf-refreshButtonHost";
        this._refreshButtonHostElement.style.display = "none";

        this.renderedElement.appendChild(this._cardHostElement);
        this.renderedElement.appendChild(this._refreshButtonHostElement);
    }

    refreshCard() {
        if (this._card && this._card.refresh) {
            this.internalExecuteAction(this._card.refresh.action, ActivityRequestTrigger.Manual, 0);
        }
    }

    setCard(payload: any) {
        this.internalSetCard(payload, 0);
    }

    get card(): AdaptiveCard | undefined {
        return this._card;
    }
}