package processor

import (
	"fmt"
	"github.com/slack-go/slack/slackevents"
	"github.com/slack-go/slack/socketmode"
	"houston/common/metrics"
	"houston/internal/processor/action"
	"houston/logger"
	"houston/model/incident"
	"houston/model/team"
	"houston/model/user"
	"houston/repository/severity"
	incidentServiceV2 "houston/service/incident/impl"
	userService "houston/service/user"
)

type eventsApiEventProcessor interface {
	ProcessCommand(event *slackevents.EventsAPIEvent, request *socketmode.Request)
}

type MemberJoinedCallbackEventProcessor struct {
	socketModeClient *socketmode.Client
	memberJoinAction *action.MemberJoinAction
}

func NewMemberJoinedCallbackEventProcessor(socketModeClient *socketmode.Client,
	incidentService *incident.Repository, teamService *team.Repository, severityService *severity.Repository) *MemberJoinedCallbackEventProcessor {
	return &MemberJoinedCallbackEventProcessor{
		socketModeClient: socketModeClient,
		memberJoinAction: action.NewMemberJoinAction(socketModeClient, incidentService, teamService, severityService),
	}
}

func (mjc *MemberJoinedCallbackEventProcessor) ProcessCommand(event *slackevents.MemberJoinedChannelEvent, request *socketmode.Request) {
	defer func() {
		if r := recover(); r != nil {
			logger.Error(fmt.Sprintf("[MJC] Exception occurred: %v", r.(error)))
		}
	}()

	mjc.memberJoinAction.PerformAction(event)
	var payload interface{}
	mjc.socketModeClient.Ack(*request, payload)
}

type UserChangeEventProcessor struct {
	socketModeClient *socketmode.Client
	userChangeAction *action.UserChangeEventAction
}

func NewUserChangeEventProcessor(socketModeClient *socketmode.Client, userRepository *user.Repository) *UserChangeEventProcessor {
	return &UserChangeEventProcessor{
		socketModeClient: socketModeClient,
		userChangeAction: action.NewUserChangeEventAction(userRepository),
	}
}

func (ucep *UserChangeEventProcessor) ProcessCommand(event slackevents.EventsAPIEvent, request *socketmode.Request) {
	defer func() {
		if r := recover(); r != nil {
			logger.Error(fmt.Sprintf("[UserChangeEventProcessor] Exception occurred: %v", r.(error)))
		}
	}()

	ucep.userChangeAction.PerformAction(event)
	var payload interface{}
	ucep.socketModeClient.Ack(*request, payload)
}

type MemberLeftChannelCallbackEventProcessor struct {
	socketModeClient        *socketmode.Client
	memberLeftChannelAction *action.MemberLeftChannelAction
}

func NewMemberLeftChannelCallbackEventProcessor(socketModeClient *socketmode.Client, incidentService incidentServiceV2.IncidentServiceV2, userService userService.UserService) *MemberLeftChannelCallbackEventProcessor {
	return &MemberLeftChannelCallbackEventProcessor{
		socketModeClient:        socketModeClient,
		memberLeftChannelAction: action.NewMemberLeftChannelAction(incidentService, userService),
	}
}

func (mlcc *MemberLeftChannelCallbackEventProcessor) ProcessCommand(event *slackevents.MemberLeftChannelEvent, request *socketmode.Request) {
	defer func() {
		if r := recover(); r != nil {
			logger.Error(fmt.Sprintf("[MLCC] Exception occurred: %v", r.(error)))
		}
	}()

	err := mlcc.memberLeftChannelAction.PerformAction(event)
	if err != nil {
		logger.Error(fmt.Sprintf("failed to perform action: %v", err))
		metrics.PublishHoustonFlowFailureMetrics(FLOW_NAME, err.Error())
	}
	var payload interface{}
	mlcc.socketModeClient.Ack(*request, payload)
}

const FLOW_NAME = "REMOVE_INCIDENT_USER_MAPPING"