package main

import (
	"log/slog"
	"net"
	"strconv"

	"api.qobiltu.id/config"
	academy_controller "api.qobiltu.id/controller/academy"
	cv_controller "api.qobiltu.id/controller/cv"
	email_controller "api.qobiltu.id/controller/email"
	marriage_readiness_profile_controller "api.qobiltu.id/controller/marriage_readiness_profile"
	options_controller "api.qobiltu.id/controller/options"
	partner_criteria_controller "api.qobiltu.id/controller/partner_criteria"
	quiz_controller "api.qobiltu.id/controller/quiz"
	region_controller "api.qobiltu.id/controller/region"
	"api.qobiltu.id/pkg/mail"
	"api.qobiltu.id/pkg/storage"
	"api.qobiltu.id/pkg/validation"
	"api.qobiltu.id/pkg/worker"
	"api.qobiltu.id/repositories"
	"api.qobiltu.id/router"
	"api.qobiltu.id/services"
	"api.qobiltu.id/utils"
	"github.com/hibiken/asynq"
)

func main() {

	// load config
	err := config.LoadConfig()
	utils.FatalIfErr("failed to load config", err)

	// setup validator for validation request
	validator, err := validation.New(config.DB)
	utils.FatalIfErr("failed to setup validator", err)

	// setup storage for saving files
	localStorage := storage.NewLocalStorage("uploads", config.GlobalConfig.App.AppURL+"/storage/")

	// setup smtp for sending email
	emailSender, err := mail.New(&mail.Config{
		Host:     config.GlobalConfig.SMTP.Host,
		Port:     config.GlobalConfig.SMTP.Port,
		From:     config.GlobalConfig.SMTP.SenderEmail,
		Username: config.GlobalConfig.SMTP.SenderEmail,
		Password: config.GlobalConfig.SMTP.Password,
	})
	utils.FatalIfErr("failed to setup email sender", err)
	mail.EmailSender = emailSender

	// setup task distributor and processor for async task
	asynqRedisOpt := asynq.RedisClientOpt{
		Addr:     net.JoinHostPort(config.GlobalConfig.Redis.Host, strconv.Itoa(config.GlobalConfig.Redis.Port)),
		Password: config.GlobalConfig.Redis.Password,
		DB:       config.GlobalConfig.Redis.DB,
	}

	taskDistributor := worker.NewRedisTaskDistributor(asynqRedisOpt)
	taskProcessor := worker.NewRedisTaskProcessor(asynqRedisOpt, emailSender)
	worker.AsyncTaskDistributor = taskDistributor

	// setup repo, service, and controller
	regionRepository := repositories.NewRegionRepository(config.DB)
	regionService := services.NewRegionService(regionRepository)
	regionController := region_controller.NewRegionController(regionService)

	optionRepository := repositories.NewOptionRepository(config.DB)
	optionService := services.NewOptionsService(optionRepository)
	optionController := options_controller.NewOptionsController(optionService)

	emailRepository := repositories.NewEmailRepository(config.DB)
	emailService := services.NewEmailService(emailRepository, taskDistributor)
	emailController := email_controller.NewEmailController(emailService)

	academyRepository := repositories.NewAcademyRepository(config.DB)
	academyService := services.NewAcademyService(academyRepository, validator)
	academyController := academy_controller.NewAcademyController(academyService)

	quizRepository := repositories.NewQuizRepository()
	quizService := services.NewQuizService(config.DB, quizRepository, academyRepository, validator)
	quizController := quiz_controller.NewQuizController(quizService)

	cvRepository := repositories.NewCVRepository(config.DB)
	cvService := services.NewCVService(cvRepository, localStorage, validator)
	cvController := cv_controller.NewCVController(cvService)

	marriageReadinessProfileRepository := repositories.NewMarriageReadinessProfileRepository(config.DB)
	marriageReadinessProfileService := services.NewMarriageReadinessProfileService(marriageReadinessProfileRepository, validator)
	marriageReadinessProfileController := marriage_readiness_profile_controller.NewMarriageReadinessProfileController(marriageReadinessProfileService)

	partnerCriteriaRepository := repositories.NewPartnerCriteriaRepository(config.DB)
	partnerCriteriaService := services.NewPartnerCriteriaService(partnerCriteriaRepository, validator)
	partnerCriteriaController := partner_criteria_controller.NewPartnerCriteriaController(partnerCriteriaService)

	// start task processor
	err = taskProcessor.Start()
	utils.FatalIfErr("failed to start task processor", err)
	slog.Info("Task processor started")

	// create server
	s, err := router.NewServer(
		regionController,
		optionController,
		emailController,
		academyController,
		quizController,
		cvController,
		marriageReadinessProfileController,
		partnerCriteriaController,
	)
	utils.FatalIfErr("failed to create server", err)

	// run server
	slog.Info("Starting server", "address", config.GlobalConfig.App.HostAddress, "port", config.GlobalConfig.App.HostPort)
	err = s.Start(config.GlobalConfig.App.TCPAddress)
	utils.FatalIfErr("failed to start server", err)
}