package appcontext

import (
	"github.com/slack-go/slack/socketmode"
	"github.com/spf13/viper"
	"gorm.io/gorm"
	"houston/model/incident"
	incidentJiraModel "houston/model/incident_jira"
	"houston/model/incident_products"
	"houston/model/log"
	productModel "houston/model/product"
	"houston/model/products_teams"
	"houston/model/team"
	"houston/model/user"
	conferenceActions "houston/pkg/conference"
	"houston/pkg/google/googleDrive"
	"houston/pkg/postgres"
	"houston/pkg/rest"
	"houston/repository/externalTeamRepo"
	incidentStatusRepo "houston/repository/incidentStatus"
	incidentUserRepo "houston/repository/incidentUser"
	rcaRepository "houston/repository/rca/impl"
	"houston/repository/rcaInput"
	requestStatusRepo "houston/repository/requestStatus"
	"houston/repository/severity"
	"houston/repository/tag"
	tagValueRepo "houston/repository/tagValue"
	teamSeverityRepo "houston/repository/teamSeverity"
	teamUserRepo "houston/repository/teamUser"
	teamUserSeverityRepo "houston/repository/teamUserSeverity"
	"houston/service/conference"
	"houston/service/documentService"
	"houston/service/externalTeam"
	"houston/service/google"
	incidentService "houston/service/incident/impl"
	"houston/service/incidentProducts"
	"houston/service/incidentStatus"
	"houston/service/incidentUser"
	"houston/service/incident_jira"
	"houston/service/products"
	"houston/service/productsTeams"
	rcaService "houston/service/rca/impl"
	"houston/service/reminder"
	"houston/service/requestStatus"
	severityService "houston/service/severity"
	severityServiceImpl "houston/service/severity/impl"
	"houston/service/slack"
	tagService "houston/service/tag"
	"houston/service/tagValue"
	"houston/service/teamService"
	"houston/service/teamSeverity"
	teamSeverityServiceImpl "houston/service/teamSeverity/impl"
	"houston/service/teamUser"
	teamUserServiceImpl "houston/service/teamUser/impl"
	"houston/service/teamUserSeverity"
	teamUserSeverityServiceImpl "houston/service/teamUserSeverity/impl"
	userService "houston/service/user"
)

type applicationContext struct {
	db *gorm.DB
}

// todo: all the repo objects to be cleaned uo from here. appContext will only have services
type houstonServices struct {
	logRepo                 *log.Repository
	teamRepo                *team.Repository
	severityRepo            *severity.Repository
	incidentRepo            *incident.Repository
	slackService            *slack.SlackService
	incidentService         *incidentService.IncidentServiceV2
	tagRepo                 *tag.Repository
	rcaRepository           *rcaRepository.Repository
	rcaInputRepository      *rcaInput.Repository
	userRepository          *user.Repository
	rcaService              *rcaService.RcaService
	driveService            google.IDriveService
	calendarService         *conference.CalendarService
	tagService              *tagService.TagService
	productsService         products.ProductService
	incidentProductsService incidentProducts.IncidentProductsService
	productTeamsService     productsTeams.ProductTeamsService
	severityService         severityService.ISeverityService
	teamSeverityService     teamSeverity.ITeamSeverityService
	userService             userService.UserService
	teamUserService         teamUser.ITeamUserService
	teamUserSeverityService teamUserSeverity.ITeamUserSeverityService
	teamService             teamService.ITeamServiceV2
	reminderService         reminder.ReminderService
	incidentStatusService   incidentStatus.IncidentStatusService
	incidentUserService     incidentUser.IncidentUserService
	requestStatusService    requestStatus.RequestStatusService
	tagValueService         tagValue.TagValueService
	incidentJiraService     incident_jira.IncidentJiraService
	externalTeamService     externalTeam.ExternalTeamService
}

var appContext *applicationContext
var services *houstonServices

func InitiateContext() {
	appContext = &applicationContext{
		db: initDB(),
	}
}

func InitializeServices() {
	logRepo := initLogRepo()
	severityRepo := initSeverityRepo()
	teamRepo := initTeamRepo(logRepo)
	slaService := initSlackService()
	severityService := initSeverityService()
	incidentStatusService := initIncidentStatusService()
	teamUserService := initTeamUserService()
	requestStatusService := initRequestStatusService()
	externalTeamService := initExternalTeamService()
	incidentJiraService := initIncidentJiraService(externalTeamService)
	tagService := initTagService()
	services = &houstonServices{
		logRepo:                 logRepo,
		teamRepo:                teamRepo,
		severityRepo:            severityRepo,
		incidentRepo:            initIncidentRepo(severityService, incidentStatusService, logRepo, teamRepo, slaService.SocketModeClientWrapper.GetClient()),
		slackService:            slaService,
		incidentService:         initIncidentService(),
		tagRepo:                 initTagRepo(),
		rcaRepository:           initRCARepo(),
		rcaInputRepository:      initRCAInputRepo(),
		userRepository:          initUserRepo(),
		rcaService:              initRCAService(),
		driveService:            initDriveService(),
		calendarService:         initCalendarService(),
		tagService:              tagService,
		productsService:         initProductsService(),
		incidentProductsService: initIncidentProductsService(),
		productTeamsService:     initProductTeamsService(),
		severityService:         severityService,
		teamSeverityService:     initTeamSeverityService(),
		teamUserService:         teamUserService,
		teamUserSeverityService: initTeamUserSeverityService(),
		incidentStatusService:   incidentStatusService,
		requestStatusService:    requestStatusService,
		tagValueService:         initTagValueService(tagService),
		externalTeamService:     externalTeamService,
		incidentJiraService:     incidentJiraService,
	}
	services.userService = initUserService()
	services.teamService = initTeamService()
	services.reminderService = initReminderService()
	services.incidentUserService = initIncidentUserService(services.teamUserService, services.userService, services.requestStatusService)
}

func initDB() *gorm.DB {
	return postgres.NewGormClient(
		viper.GetString("postgres.dsn"),
		viper.GetString("postgres.connection.max.idle.time"),
		viper.GetString("postgres.connection.max.lifetime"),
		viper.GetInt("postgres.connections.max.idle"),
		viper.GetInt("postgres.connections.max.open"),
	)
}

func GetDB() *gorm.DB {
	return appContext.db
}

func initLogRepo() *log.Repository {
	return log.NewLogRepository(GetDB())
}

func GetLogRepo() *log.Repository {
	return services.logRepo
}

func initTeamRepo(logRepo *log.Repository) *team.Repository {
	return team.NewTeamRepository(GetDB(), logRepo)
}

func GetTeamRepo() *team.Repository {
	return services.teamRepo
}

func initSeverityRepo() *severity.Repository {
	return severity.NewSeverityRepository(GetDB())
}

func GetSeverityRepo() *severity.Repository {
	return services.severityRepo
}

func initIncidentRepo(
	severityService severityService.ISeverityService,
	incidentStatusService incidentStatus.IncidentStatusService,
	logRepo *log.Repository,
	teamRepo *team.Repository,
	socketModeClient *socketmode.Client,
) *incident.Repository {
	return incident.NewIncidentRepository(GetDB(), severityService, incidentStatusService, logRepo, teamRepo, socketModeClient)
}

func GetIncidentRepo() *incident.Repository {
	return services.incidentRepo
}

func initSlackService() *slack.SlackService {
	return slack.NewSlackService()
}

func getRestClient() *rest.HttpRestClientImpl {
	return rest.NewHttpRestClient()
}

func initDocumentService() *documentService.ActionsImpl {
	return documentService.NewActionsImpl(getRestClient())
}

func initCalendarService() *conference.CalendarService {
	calendarActions := conferenceActions.GetCalendarActions()
	calendarService := conference.NewCalendarService(calendarActions)
	return calendarService
}

func initTeamService() teamService.ITeamServiceV2 {
	return teamService.NewTeamServiceV2(
		initTeamRepo(initLogRepo()),
		initUserRepo(),
		initSlackService(),
		externalTeamRepo.NewExternalTeamRepository(GetDB()),
		initTeamSeverityService(),
		initUserService(),
		initTeamUserService(),
		initTeamUserSeverityService(),
	)
}

func GetTeamService() teamService.ITeamServiceV2 {
	return services.teamService
}

func initTagService() *tagService.TagService {
	return tagService.NewTagService(GetDB())
}

func GetTagService() *tagService.TagService {
	return services.tagService
}

func initProductsService() products.ProductService {
	return products.NewProductService(productModel.NewProductRepo(GetDB()))
}

func GetProductsService() products.ProductService {
	return services.productsService
}

func initIncidentProductsService() incidentProducts.IncidentProductsService {
	return incidentProducts.NewIncidentProductsService(incident_products.NewIncidentProductsRepo(GetDB()))
}

func initIncidentStatusService() incidentStatus.IncidentStatusService {
	return incidentStatus.NewIncidentStatusService(incidentStatusRepo.NewIncidentStatusRepository(GetDB()))
}

func GetIncidentStatusService() incidentStatus.IncidentStatusService {
	return services.incidentStatusService
}

func GetIncidentProductsService() incidentProducts.IncidentProductsService {
	return services.incidentProductsService
}

func initProductTeamsService() productsTeams.ProductTeamsService {
	return productsTeams.NewProductTeamsService(products_teams.NewProductsTeamsRepo(GetDB()))
}

func GetProductTeamsService() productsTeams.ProductTeamsService {
	return services.productTeamsService
}

func GetCalendarService() *conference.CalendarService {
	return services.calendarService
}

func GetDocumentService() *documentService.ActionsImpl {
	return initDocumentService()
}

func initRCAService() *rcaService.RcaService {
	rcaService := rcaService.NewRcaService(
		initIncidentService(), initSlackService(), initDocumentService(),
		initRCARepo(), initRCAInputRepo(), initUserRepo(), initDriveService(), initIncidentJiraService(initExternalTeamService()),
	)
	return rcaService
}

func GetSlackService() *slack.SlackService {
	return services.slackService
}

func initIncidentService() *incidentService.IncidentServiceV2 {
	return incidentService.NewIncidentServiceV2(GetDB())
}

func GetIncidentService() *incidentService.IncidentServiceV2 {
	if services.incidentService == nil {
		services.incidentService = initIncidentService()
	}
	return services.incidentService
}

func GetRCAService() *rcaService.RcaService {
	return services.rcaService
}
func initTagRepo() *tag.Repository {
	return tag.NewTagRepository(GetDB())
}

func GetTagRepo() *tag.Repository {
	return services.tagRepo
}

func initRCARepo() *rcaRepository.Repository {
	return rcaRepository.NewRcaRepository(GetDB())
}

func GetRCARepo() *rcaRepository.Repository {
	return services.rcaRepository
}

func initRCAInputRepo() *rcaInput.Repository {
	return rcaInput.NewRcaInputRepository(GetDB())
}

func GetRCAInputRepo() *rcaInput.Repository {
	return services.rcaInputRepository
}

func initUserRepo() *user.Repository {
	return user.NewUserRepository(GetDB())
}

func initSeverityService() severityService.ISeverityService {
	return severityServiceImpl.NewSeverityService(severity.NewSeverityRepository(GetDB()))
}

func GetSeverityService() severityService.ISeverityService {
	return services.severityService
}

func initTeamSeverityService() teamSeverity.ITeamSeverityService {
	return teamSeverityServiceImpl.NewTeamSeverityService(
		teamSeverityRepo.NewTeamSeverityRepository(GetDB()), initSeverityService(),
	)
}

func GetTeamSeverityService() teamSeverity.ITeamSeverityService {
	return services.teamSeverityService
}

func initUserService() userService.UserService {
	return userService.NewUserService(user.NewUserRepository(GetDB()), GetSlackService())
}

func GetUserService() userService.UserService {
	return services.userService
}

func initTeamUserService() teamUser.ITeamUserService {
	return teamUserServiceImpl.NewTeamUserService(teamUserRepo.NewTeamUserRepository(GetDB()))
}

func GetTeamUserService() teamUser.ITeamUserService {
	return services.teamUserService
}

func initTeamUserSeverityService() teamUserSeverity.ITeamUserSeverityService {
	return teamUserSeverityServiceImpl.NewTeamUserSeverityService(teamUserSeverityRepo.NewTeamUserSeverityRepository(GetDB()))
}

func GetTeamUserSeverityService() teamUserSeverity.ITeamUserSeverityService {
	return services.teamUserSeverityService
}

func initDriveService() google.IDriveService {
	driveAction, err := googleDrive.NewGoogleDriveActions()
	if err != nil {
		return nil
	}
	return google.NewDriveService(driveAction)
}

func GetDriveService() google.IDriveService {
	return services.driveService
}

func initReminderService() reminder.ReminderService {
	return reminder.NewReminderService(GetIncidentService(), GetTeamService(), GetTeamUserService(), GetSlackService(), GetSeverityService())
}

func GetReminderService() reminder.ReminderService {
	return services.reminderService
}

func initRequestStatusService() requestStatus.RequestStatusService {
	return requestStatus.NewRequestStatusService(requestStatusRepo.NewRequestStatusRepository(GetDB()))
}

func GetRequestStatusService() requestStatus.RequestStatusService {
	return initRequestStatusService()
}

func initIncidentUserService(
	teamUserService teamUser.ITeamUserService, userService userService.UserService, requestStatusService requestStatus.RequestStatusService) incidentUser.IncidentUserService {
	return incidentUser.NewIncidentUserService(
		incidentUserRepo.NewIncidentUserRepository(GetDB()),
		teamUserService,
		userService,
		GetIncidentService(),
		GetSlackService(),
		requestStatusService,
	)
}

func GetIncidentUserService() incidentUser.IncidentUserService {
	return services.incidentUserService
}

func initTagValueService(tagService tagService.ITagService) tagValue.TagValueService {
	return tagValue.NewTagValueService(tagValueRepo.NewTagValueRepository(GetDB()), tagService)
}

func GetTagValueService() tagValue.TagValueService {
	return services.tagValueService
}

func initIncidentJiraService(externalTeamService externalTeam.ExternalTeamService) incident_jira.IncidentJiraService {
	return incident_jira.NewIncidentJiraService(incidentJiraModel.NewIncidentJiraRepo(GetDB()), externalTeamService)
}

func GetIncidentJiraService() incident_jira.IncidentJiraService {
	return services.incidentJiraService
}

func initExternalTeamService() externalTeam.ExternalTeamService {
	return externalTeam.NewExternalTeamService(externalTeamRepo.NewExternalTeamRepository(GetDB()))
}

func GetExternalTeamService() externalTeam.ExternalTeamService {
	return services.externalTeamService
}