var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
import Response from "../../../Response";
import MicrosoftTeamsAuthAction from "./Auth";
import { MicrosoftTeamsAlertActionType } from "./ActionTypes";
import logger from "../../../Logger";
import ObjectID from "../../../../../Types/ObjectID";
import AlertService from "../../../../Services/AlertService";
import CaptureSpan from "../../../Telemetry/CaptureSpan";
import AlertInternalNoteService from "../../../../Services/AlertInternalNoteService";
import OnCallDutyPolicyService from "../../../../Services/OnCallDutyPolicyService";
import AlertStateService from "../../../../Services/AlertStateService";
import UserNotificationEventType from "../../../../../Types/UserNotification/UserNotificationEventType";
export default class MicrosoftTeamsAlertActions {
    static isAlertAction(data) {
        return (data.actionType.includes("alert") ||
            data.actionType === MicrosoftTeamsAlertActionType.AckAlert ||
            data.actionType === MicrosoftTeamsAlertActionType.ResolveAlert ||
            data.actionType === MicrosoftTeamsAlertActionType.ViewAlert ||
            data.actionType === MicrosoftTeamsAlertActionType.AlertCreated ||
            data.actionType === MicrosoftTeamsAlertActionType.AlertStateChanged ||
            data.actionType === MicrosoftTeamsAlertActionType.ViewAddAlertNote ||
            data.actionType === MicrosoftTeamsAlertActionType.SubmitAlertNote ||
            data.actionType ===
                MicrosoftTeamsAlertActionType.ViewExecuteAlertOnCallPolicy ||
            data.actionType ===
                MicrosoftTeamsAlertActionType.SubmitExecuteAlertOnCallPolicy ||
            data.actionType === MicrosoftTeamsAlertActionType.ViewChangeAlertState ||
            data.actionType === MicrosoftTeamsAlertActionType.SubmitChangeAlertState);
    }
    static async handleAlertAction(data) {
        const { teamsRequest, action } = data;
        logger.debug("Handling Microsoft Teams alert action:", {
            projectId: teamsRequest.projectId.toString(),
            actionType: action.actionType,
        });
        logger.debug(action);
        try {
            switch (action.actionType) {
                case MicrosoftTeamsAlertActionType.AckAlert:
                    await this.acknowledgeAlert({
                        teamsRequest,
                        action,
                    });
                    break;
                case MicrosoftTeamsAlertActionType.ResolveAlert:
                    await this.resolveAlert({
                        teamsRequest,
                        action,
                    });
                    break;
                case MicrosoftTeamsAlertActionType.ViewAlert:
                    // This is handled by opening the URL directly
                    break;
                default:
                    logger.debug("Unhandled alert action: " + action.actionType, {
                        projectId: teamsRequest.projectId.toString(),
                        actionType: action.actionType,
                    });
                    break;
            }
        }
        catch (error) {
            logger.error("Error handling Microsoft Teams alert action:", {
                projectId: teamsRequest.projectId.toString(),
                actionType: action.actionType,
            });
            logger.error(error);
        }
        Response.sendTextResponse(data.req, data.res, "");
    }
    static async acknowledgeAlert(data) {
        var _a;
        const alertId = data.action.actionValue || "";
        if (!alertId) {
            logger.error("No alert ID provided for acknowledge action", {
                projectId: data.teamsRequest.projectId.toString(),
            });
            return;
        }
        logger.debug("Acknowledging alert: " + alertId, {
            projectId: data.teamsRequest.projectId.toString(),
            alertId: alertId,
        });
        try {
            const alert = await AlertService.findOneBy({
                query: {
                    _id: alertId,
                    projectId: data.teamsRequest.projectId,
                },
                select: {
                    _id: true,
                    projectId: true,
                    currentAlertState: {
                        _id: true,
                        name: true,
                        isAcknowledgedState: true,
                    },
                },
                props: {
                    isRoot: true,
                },
            });
            if (!alert) {
                logger.error("Alert not found: " + alertId, {
                    projectId: data.teamsRequest.projectId.toString(),
                    alertId: alertId,
                });
                return;
            }
            if ((_a = alert.currentAlertState) === null || _a === void 0 ? void 0 : _a.isAcknowledgedState) {
                logger.debug("Alert is already acknowledged", {
                    projectId: data.teamsRequest.projectId.toString(),
                    alertId: alertId,
                });
                return;
            }
            const oneUptimeUserId = await MicrosoftTeamsAuthAction.getOneUptimeUserIdFromTeamsUserId({
                teamsUserId: data.teamsRequest.userId || "",
                projectId: data.teamsRequest.projectId,
            });
            await AlertService.acknowledgeAlert(new ObjectID(alertId), oneUptimeUserId);
            logger.debug("Alert acknowledged successfully", {
                projectId: data.teamsRequest.projectId.toString(),
                alertId: alertId,
            });
        }
        catch (error) {
            logger.error("Error acknowledging alert:", {
                projectId: data.teamsRequest.projectId.toString(),
                alertId: alertId,
            });
            logger.error(error);
        }
    }
    static async resolveAlert(data) {
        var _a;
        const alertId = data.action.actionValue || "";
        if (!alertId) {
            logger.error("No alert ID provided for resolve action", {
                projectId: data.teamsRequest.projectId.toString(),
            });
            return;
        }
        logger.debug("Resolving alert: " + alertId, {
            projectId: data.teamsRequest.projectId.toString(),
            alertId: alertId,
        });
        try {
            const alert = await AlertService.findOneBy({
                query: {
                    _id: alertId,
                    projectId: data.teamsRequest.projectId,
                },
                select: {
                    _id: true,
                    projectId: true,
                    currentAlertState: {
                        _id: true,
                        name: true,
                        isResolvedState: true,
                    },
                },
                props: {
                    isRoot: true,
                },
            });
            if (!alert) {
                logger.error("Alert not found: " + alertId, {
                    projectId: data.teamsRequest.projectId.toString(),
                    alertId: alertId,
                });
                return;
            }
            if ((_a = alert.currentAlertState) === null || _a === void 0 ? void 0 : _a.isResolvedState) {
                logger.debug("Alert is already resolved", {
                    projectId: data.teamsRequest.projectId.toString(),
                    alertId: alertId,
                });
                return;
            }
            const oneUptimeUserId = await MicrosoftTeamsAuthAction.getOneUptimeUserIdFromTeamsUserId({
                teamsUserId: data.teamsRequest.userId || "",
                projectId: data.teamsRequest.projectId,
            });
            await AlertService.resolveAlert(new ObjectID(alertId), oneUptimeUserId);
            logger.debug("Alert resolved successfully", {
                projectId: data.teamsRequest.projectId.toString(),
                alertId: alertId,
            });
        }
        catch (error) {
            logger.error("Error resolving alert:", {
                projectId: data.teamsRequest.projectId.toString(),
                alertId: alertId,
            });
            logger.error(error);
        }
    }
    static async handleBotAlertAction(data) {
        var _a, _b;
        const { actionType, actionValue, value, projectId, oneUptimeUserId, turnContext, } = data;
        if (actionType === MicrosoftTeamsAlertActionType.AckAlert) {
            if (!actionValue) {
                await turnContext.sendActivity("Unable to acknowledge: missing alert id.");
                return;
            }
            await AlertService.acknowledgeAlert(new ObjectID(actionValue), oneUptimeUserId);
            await turnContext.sendActivity("✅ Alert acknowledged.");
            return;
        }
        if (actionType === MicrosoftTeamsAlertActionType.ResolveAlert) {
            if (!actionValue) {
                await turnContext.sendActivity("Unable to resolve: missing alert id.");
                return;
            }
            await AlertService.resolveAlert(new ObjectID(actionValue), oneUptimeUserId);
            await turnContext.sendActivity("✅ Alert resolved.");
            return;
        }
        if (actionType === MicrosoftTeamsAlertActionType.ViewAlert) {
            if (!actionValue) {
                await turnContext.sendActivity("Unable to view alert: missing alert id.");
                return;
            }
            const alert = await AlertService.findOneBy({
                query: {
                    _id: actionValue,
                    projectId: projectId,
                },
                select: {
                    _id: true,
                    title: true,
                    description: true,
                    currentAlertState: {
                        name: true,
                    },
                    alertSeverity: {
                        name: true,
                    },
                    createdAt: true,
                },
                props: {
                    isRoot: true,
                },
            });
            if (!alert) {
                await turnContext.sendActivity("Alert not found.");
                return;
            }
            const message = `**Alert Details**\n\n**Title:** ${alert.title}\n**Description:** ${alert.description || "No description"}\n**State:** ${((_a = alert.currentAlertState) === null || _a === void 0 ? void 0 : _a.name) || "Unknown"}\n**Severity:** ${((_b = alert.alertSeverity) === null || _b === void 0 ? void 0 : _b.name) || "Unknown"}\n**Created At:** ${alert.createdAt ? new Date(alert.createdAt).toLocaleString() : "Unknown"}`;
            await turnContext.sendActivity(message);
            return;
        }
        if (actionType === MicrosoftTeamsAlertActionType.ViewAddAlertNote) {
            if (!actionValue) {
                await turnContext.sendActivity("Unable to add note: missing alert id.");
                return;
            }
            // Send the input card
            const card = this.buildAddAlertNoteCard(actionValue);
            await turnContext.sendActivity({
                attachments: [
                    {
                        contentType: "application/vnd.microsoft.card.adaptive",
                        content: card,
                    },
                ],
            });
            return;
        }
        if (actionType === MicrosoftTeamsAlertActionType.SubmitAlertNote) {
            if (!actionValue) {
                await turnContext.sendActivity("Unable to add note: missing alert id.");
                return;
            }
            // Check if form data is provided
            const note = value["note"];
            if (note) {
                // Submit the note
                const alertId = new ObjectID(actionValue);
                await AlertInternalNoteService.addNote({
                    alertId: alertId,
                    note: note.toString(),
                    projectId: projectId,
                    userId: oneUptimeUserId,
                });
                await turnContext.sendActivity("✅ Note added successfully.");
                // Hide the form card by deleting it
                if (turnContext.activity.replyToId) {
                    await turnContext.deleteActivity(turnContext.activity.replyToId);
                }
                return;
            }
            await turnContext.sendActivity("Unable to add note: missing note data.");
            return;
        }
        if (actionType === MicrosoftTeamsAlertActionType.ViewExecuteAlertOnCallPolicy) {
            if (!actionValue) {
                await turnContext.sendActivity("Unable to execute on-call policy: missing alert id.");
                return;
            }
            // Send the input card
            const card = await this.buildExecuteAlertOnCallPolicyCard(actionValue, projectId);
            if (!card) {
                await turnContext.sendActivity("No on-call policies have been configured for this project yet. Please add an on-call policy in the OneUptime Dashboard under On-Call Duty > Policies to use this feature.");
                return;
            }
            await turnContext.sendActivity({
                attachments: [
                    {
                        contentType: "application/vnd.microsoft.card.adaptive",
                        content: card,
                    },
                ],
            });
            return;
        }
        if (actionType ===
            MicrosoftTeamsAlertActionType.SubmitExecuteAlertOnCallPolicy) {
            if (!actionValue) {
                await turnContext.sendActivity("Unable to execute on-call policy: missing alert id.");
                return;
            }
            // Check if form data is provided
            const onCallPolicyId = value["onCallPolicy"];
            if (onCallPolicyId) {
                // Execute the policy
                const alertId = new ObjectID(actionValue);
                await OnCallDutyPolicyService.executePolicy(new ObjectID(onCallPolicyId.toString()), {
                    triggeredByAlertId: alertId,
                    userNotificationEventType: UserNotificationEventType.AlertCreated,
                });
                await turnContext.sendActivity("✅ On-call policy executed successfully.");
                // Hide the form card by deleting it
                if (turnContext.activity.replyToId) {
                    await turnContext.deleteActivity(turnContext.activity.replyToId);
                }
                return;
            }
            await turnContext.sendActivity("Unable to execute on-call policy: missing policy id.");
            return;
        }
        if (actionType === MicrosoftTeamsAlertActionType.ViewChangeAlertState) {
            if (!actionValue) {
                await turnContext.sendActivity("Unable to change alert state: missing alert id.");
                return;
            }
            // Send the input card
            const card = await this.buildChangeAlertStateCard(actionValue, projectId);
            await turnContext.sendActivity({
                attachments: [
                    {
                        contentType: "application/vnd.microsoft.card.adaptive",
                        content: card,
                    },
                ],
            });
            return;
        }
        if (actionType === MicrosoftTeamsAlertActionType.SubmitChangeAlertState) {
            if (!actionValue) {
                await turnContext.sendActivity("Unable to change alert state: missing alert id.");
                return;
            }
            // Check if form data is provided
            const alertStateId = value["alertState"];
            if (alertStateId) {
                // Update the state
                const alertId = new ObjectID(actionValue);
                await AlertService.updateOneById({
                    id: alertId,
                    data: {
                        currentAlertStateId: new ObjectID(alertStateId.toString()),
                    },
                    props: {
                        isRoot: true,
                    },
                });
                await turnContext.sendActivity("✅ Alert state changed successfully.");
                // Hide the form card by deleting it
                if (turnContext.activity.replyToId) {
                    await turnContext.deleteActivity(turnContext.activity.replyToId);
                }
                return;
            }
            await turnContext.sendActivity("Unable to change alert state: missing state id.");
            return;
        }
        // Default fallback for unimplemented actions
        await turnContext.sendActivity("Sorry, but the action " +
            actionType +
            " you requested is not implemented yet.");
    }
    static buildAddAlertNoteCard(alertId) {
        return {
            type: "AdaptiveCard",
            $schema: "http://adaptivecards.io/schemas/adaptive-card.json",
            version: "1.5",
            body: [
                {
                    type: "TextBlock",
                    text: "Add Alert Note",
                    size: "Large",
                    weight: "Bolder",
                },
                {
                    type: "Input.Text",
                    id: "note",
                    label: "Note",
                    isMultiline: true,
                    placeholder: "Please type in plain text or markdown.",
                },
            ],
            actions: [
                {
                    type: "Action.Submit",
                    title: "Submit",
                    data: {
                        action: MicrosoftTeamsAlertActionType.SubmitAlertNote,
                        actionValue: alertId,
                    },
                },
            ],
        };
    }
    static async buildExecuteAlertOnCallPolicyCard(alertId, projectId) {
        const onCallPolicies = await OnCallDutyPolicyService.findBy({
            query: {
                projectId: projectId,
            },
            select: {
                name: true,
                _id: true,
            },
            props: {
                isRoot: true,
            },
            limit: 50,
            skip: 0,
        });
        const choices = onCallPolicies
            .map((policy) => {
            var _a;
            return {
                title: policy.name || "",
                value: ((_a = policy._id) === null || _a === void 0 ? void 0 : _a.toString()) || "",
            };
        })
            .filter((choice) => {
            return choice.title && choice.value;
        });
        if (choices.length === 0) {
            return null;
        }
        return {
            type: "AdaptiveCard",
            $schema: "http://adaptivecards.io/schemas/adaptive-card.json",
            version: "1.5",
            body: [
                {
                    type: "TextBlock",
                    text: "Execute On-Call Policy",
                    size: "Large",
                    weight: "Bolder",
                },
                {
                    type: "Input.ChoiceSet",
                    id: "onCallPolicy",
                    label: "On-Call Policy",
                    style: "compact",
                    choices: choices,
                },
            ],
            actions: [
                {
                    type: "Action.Submit",
                    title: "Execute",
                    data: {
                        action: MicrosoftTeamsAlertActionType.SubmitExecuteAlertOnCallPolicy,
                        actionValue: alertId,
                    },
                },
            ],
        };
    }
    static async buildChangeAlertStateCard(alertId, projectId) {
        const alertStates = await AlertStateService.getAllAlertStates({
            projectId: projectId,
            props: {
                isRoot: true,
            },
        });
        const choices = alertStates
            .map((state) => {
            var _a;
            return {
                title: state.name || "",
                value: ((_a = state._id) === null || _a === void 0 ? void 0 : _a.toString()) || "",
            };
        })
            .filter((choice) => {
            return choice.title && choice.value;
        });
        return {
            type: "AdaptiveCard",
            $schema: "http://adaptivecards.io/schemas/adaptive-card.json",
            version: "1.5",
            body: [
                {
                    type: "TextBlock",
                    text: "Change Alert State",
                    size: "Large",
                    weight: "Bolder",
                },
                {
                    type: "Input.ChoiceSet",
                    id: "alertState",
                    label: "Alert State",
                    style: "compact",
                    choices: choices,
                },
            ],
            actions: [
                {
                    type: "Action.Submit",
                    title: "Change",
                    data: {
                        action: MicrosoftTeamsAlertActionType.SubmitChangeAlertState,
                        actionValue: alertId,
                    },
                },
            ],
        };
    }
}
__decorate([
    CaptureSpan(),
    __metadata("design:type", Function),
    __metadata("design:paramtypes", [Object]),
    __metadata("design:returntype", Boolean)
], MicrosoftTeamsAlertActions, "isAlertAction", null);
__decorate([
    CaptureSpan(),
    __metadata("design:type", Function),
    __metadata("design:paramtypes", [Object]),
    __metadata("design:returntype", Promise)
], MicrosoftTeamsAlertActions, "handleAlertAction", null);
__decorate([
    CaptureSpan(),
    __metadata("design:type", Function),
    __metadata("design:paramtypes", [Object]),
    __metadata("design:returntype", Promise)
], MicrosoftTeamsAlertActions, "acknowledgeAlert", null);
__decorate([
    CaptureSpan(),
    __metadata("design:type", Function),
    __metadata("design:paramtypes", [Object]),
    __metadata("design:returntype", Promise)
], MicrosoftTeamsAlertActions, "resolveAlert", null);
__decorate([
    CaptureSpan(),
    __metadata("design:type", Function),
    __metadata("design:paramtypes", [Object]),
    __metadata("design:returntype", Promise)
], MicrosoftTeamsAlertActions, "handleBotAlertAction", null);
//# sourceMappingURL=Alert.js.map