package dependencies

import (
	"cybertron/configs"
	"cybertron/internal/client/aws"
	"cybertron/internal/client/document"
	"cybertron/internal/client/elastic"
	"cybertron/internal/database"
	"cybertron/internal/transport/handler"
	inPodCache "cybertron/pkg/cache"
	"cybertron/pkg/db"
	"cybertron/pkg/houstonClient"
	httpclient "cybertron/pkg/httpClient"
	"cybertron/pkg/kafka/producer"
	"cybertron/pkg/log"
	"cybertron/pkg/mjolnirClient"
	"cybertron/service"

	"go.uber.org/zap"
	"gorm.io/gorm"
)

type Dependencies struct {
	Service      *Service
	DBClient     *gorm.DB
	Logger       *zap.Logger
	Handler      *Handler
	Repositories *Repositories
}

type Service struct {
	DocumentService  *document.HttpClient
	ProjectService   *service.ProjectCreator
	SourceMapService *service.SourceMapService
	ReleaseService   *service.ReleaseService
	ExceptionService *service.ExceptionService
	AuthService      *service.AuthService
	SearchService    *service.SearchService
	S3Client         *aws.Actions

	// Add your service here
}

type Handler struct {
	ProjectHandler   *handler.ProjectHandler
	SourceMapHandler *handler.SourceMapHandler
	ReleaseHandler   *handler.ReleasesHandler
	ExceptionHandler *handler.ExceptionHandler
	SearchHandler    *handler.SearchHandler
	HoustonHandler   *handler.HoustonHandler
}

type Repositories struct {
	ProjectRepository   *gorm.DB
	ReleaseRepository   *gorm.DB
	SourceMapRepository *gorm.DB
	HoustonRepository   *gorm.DB
}

func InitDependencies() *Dependencies {
	dbClient := db.NewDBClient()
	repositories := initRepositories(dbClient)
	logger := log.Log
	httpClient := httpclient.NewHttpClient(*configs.GetHttpConfig())
	s3Client := aws.NewS3client(*configs.GetAWSConfig())
	kafkaProducer := initKafkaProducer()
	elasticSearch, _ := elastic.NewElasticClient(*configs.GetElasticConfig())
	mjolnirClient := mjolnirClient.NewMjolnirClient(*configs.GetMjolnirConfig())
	houstonClient := houstonClient.NewHoustonClient(*configs.GetHoustonConfig())
	cacheClient := inPodCache.NewCache()

	documentServiceClient := document.NewDocumentServiceHttpClient(httpClient, logger, configs.GetDocumentServiceHttpClientConfigs())
	projectServiceClient := service.NewProjectCreator(logger, dbClient, s3Client, kafkaProducer)
	sourceMapServiceClient := service.NewSourceMapService(dbClient, s3Client, configs.GetAWSConfig(), logger)
	releaseServiceClient := service.NewReleaseService(logger, dbClient)
	exceptionServiceClient := service.NewExceptionService(logger, dbClient, kafkaProducer, cacheClient, *configs.GetKafkaConfig())
	searchServiceClient := service.NewSearchService(logger, elasticSearch)
	authService := service.NewAuthService(mjolnirClient)
	houstonService := service.NewHoustonService(logger, dbClient, kafkaProducer, houstonClient)

	services := initServices(documentServiceClient, projectServiceClient, sourceMapServiceClient, releaseServiceClient, exceptionServiceClient, searchServiceClient, authService)
	handlers := initHandlers(projectServiceClient, sourceMapServiceClient, releaseServiceClient, exceptionServiceClient, searchServiceClient, houstonService)

	return &Dependencies{
		Service:      services,
		DBClient:     dbClient,
		Logger:       logger.GetLog(),
		Handler:      handlers,
		Repositories: repositories,
	}
}

func initServices(documentService *document.HttpClient, projectService *service.ProjectCreator, sourceMapService *service.SourceMapService, releaseService *service.ReleaseService, exceptionService *service.ExceptionService, searchService *service.SearchService, authService *service.AuthService) *Service {
	return &Service{
		DocumentService:  documentService,
		ProjectService:   projectService,
		SourceMapService: sourceMapService,
		ReleaseService:   releaseService,
		ExceptionService: exceptionService,
		SearchService:    searchService,
		AuthService:      authService,
	}
}

func initRepositories(dbClient *gorm.DB) *Repositories {
	return &Repositories{
		ProjectRepository:   database.InitProjectRepository(dbClient),
		ReleaseRepository:   database.InitReleaseRepository(dbClient),
		SourceMapRepository: database.InitSourceMapRepository(dbClient),
		HoustonRepository:   database.InitHoustonRepository(dbClient),
	}
}

func initHandlers(projectService *service.ProjectCreator, sourceMapService *service.SourceMapService, releaseService *service.ReleaseService, exceotionService *service.ExceptionService, searchService *service.SearchService, houstonService *service.HoustonService) *Handler {
	projectHandler := handler.NewProjectHandler(projectService)
	sourceMapHandler := handler.NewSourceMapHandler(sourceMapService)
	releaseHandler := handler.NewReleaseHandler(releaseService)
	exceptionHandler := handler.NewExceptionHandler(exceotionService)
	searchHandler := handler.NewSearchHandler(searchService)
	houstonHandler := handler.NewHoustonHandler(houstonService)
	return &Handler{
		ProjectHandler:   projectHandler,
		SourceMapHandler: sourceMapHandler,
		ReleaseHandler:   releaseHandler,
		ExceptionHandler: exceptionHandler,
		SearchHandler:    searchHandler,
		HoustonHandler:   houstonHandler,
	}
}

func initKafkaProducer() producer.KProducer {
	kafkaProducer := producer.NewKProducer(configs.GetEnv(), configs.GetKafkaConfig())
	return kafkaProducer
}