package main

import (
	"fmt"

	"github.com/aykhans/oh-my-chat/internal/adapter/auth/jwt"
	"github.com/aykhans/oh-my-chat/internal/adapter/config"
	httpHandlers "github.com/aykhans/oh-my-chat/internal/adapter/handlers/http"
	middlewares "github.com/aykhans/oh-my-chat/internal/adapter/handlers/http/middlewares"
	"github.com/aykhans/oh-my-chat/internal/adapter/logger"
	"github.com/aykhans/oh-my-chat/internal/adapter/storages/postgres"
	postgresRepo "github.com/aykhans/oh-my-chat/internal/adapter/storages/postgres/repository"
	"github.com/aykhans/oh-my-chat/internal/adapter/storages/scylla"
	scyllaRepo "github.com/aykhans/oh-my-chat/internal/adapter/storages/scylla/repository"
	kafkaConsumer "github.com/aykhans/oh-my-chat/internal/adapter/streamers/kafka/consumer"
	kafkaProducer "github.com/aykhans/oh-my-chat/internal/adapter/streamers/kafka/producer"
	"github.com/aykhans/oh-my-chat/internal/core/service"
	"github.com/aykhans/oh-my-chat/internal/core/utils"
)

var log = logger.NewStdLogger()

func main() {
	containerConfig := config.NewContainerConfig()

	postgresDB, err := postgres.NewDB(containerConfig.PostgresConfig)
	if err != nil {
		log.Error("Error postgres connection", "error", err)
		utils.ExitErr()
	}

	userRepository := postgresRepo.NewUserRepository(postgresDB)
	userService := service.NewUserService(userRepository)
	validator := httpHandlers.NewValidator()
	userHandler := httpHandlers.NewUserHandler(userService, validator)

	jwtService := jwt.NewJWTService(
		*containerConfig.AppConfig.JWTDuration,
		containerConfig.AppConfig.SecretKey,
	)
	authService := service.NewAuthService(userRepository, jwtService)
	authHandler := httpHandlers.NewAuthHandler(authService, validator)

	messageProducer, err := kafkaProducer.NewMessageProducer(containerConfig.KafkaConfig.KafkaProducerConfig)
	if err != nil {
		log.Error("Error kafka producer connection", "error", err)
		utils.ExitErr()
	}

	messageConsumer := kafkaConsumer.NewMessageConsumer(containerConfig.KafkaConfig.KafkaConsumerConfig)
	scyllaDB, err := scylla.NewDB(containerConfig.ScyllaConfig)
	if err != nil {
		log.Error("Error scylla connection", "error", err)
		utils.ExitErr()
	}

	messageRepository := scyllaRepo.NewMessageRepository(scyllaDB)
	messageService := service.NewMessageService(messageProducer, messageConsumer, messageRepository)
	chatHandler := httpHandlers.NewChatHandler(messageService, validator)

	authMiddleware := middlewares.NewAuthMiddleware(jwtService)
	wsMiddleware := middlewares.NewWSMiddleware()

	app := httpHandlers.NewApp(
		// configs
		containerConfig.AppConfig.IsDev,
		containerConfig.CORSAllowedOrigins,
		// middlewares
		authMiddleware, wsMiddleware,
		// handlers
		userHandler, authHandler, chatHandler,
	)

	err = app.Listen(
		fmt.Sprintf(
			":%d", containerConfig.AppConfig.ListenerPort,
		),
	)
	if err != nil {
		log.Error("Error starting app", "error", err)
		utils.ExitErr()
	}
}