package main

import (
	"context"
	"log"
	"os"

	"gitea.d3m0k1d.ru/d3m0k1d/HellreigN/backend/docs"
	"gitea.d3m0k1d.ru/d3m0k1d/HellreigN/backend/internal/config"
	"gitea.d3m0k1d.ru/d3m0k1d/HellreigN/backend/internal/handlers"
	"gitea.d3m0k1d.ru/d3m0k1d/HellreigN/backend/internal/repository"
	"gitea.d3m0k1d.ru/d3m0k1d/HellreigN/backend/internal/storage"
	"github.com/gin-gonic/gin"
	swaggerFiles "github.com/swaggo/files"
	ginSwagger "github.com/swaggo/gin-swagger"
)

// @securityDefinitions.apikey Bearer
// @in header
// @name Authorization
// @description Type "Bearer" followed by a space and the JWT token.

func main() {
	cfg_path, ok := os.LookupEnv("CONFIG_FILE")
	if !ok {
		cfg_path = "/etc/hellreign/config.yml"
	}
	cfg, err := config.ImportSettings(cfg_path)
	if err != nil {
		log.Fatalf("Err loading config: %v", err)
	}

	db, err := storage.Open(cfg.Database.Token_db)
	if err != nil {
		log.Fatalf("Err opening database: %v", err)
	}
	defer db.Close()

	h := handlers.New(db)
	agents := handlers.AgentsGroup{Handlers: h}
	auth := handlers.AuthGroup{Handlers: h}

	// Create admin user from config if not exists
	if cfg.Admin.Admin_login != "" && cfg.Admin.Admin_password != "" {
		if !h.Repo.ExistsByLogin(cfg.Admin.Admin_login) {
			_, err := h.Repo.CreateToken(repository.TokenCreate{
				Name:            cfg.Admin.Admin_name,
				LastName:        cfg.Admin.Admin_last_name,
				Login:           cfg.Admin.Admin_login,
				Password:        cfg.Admin.Admin_password,
				PermissionView:  true,
				PermissionAdmin: true,
			})
			if err != nil {
				log.Printf("Warning: failed to create admin user: %v", err)
			} else {
				log.Println("Admin user created from config")
			}
		}
	}

	router := gin.Default()
	docs.SwaggerInfo.BasePath = "/api/v1"
	docs.SwaggerInfo.Title = "HellreigN"
	docs.SwaggerInfo.Version = "1.0"
	docs.SwaggerInfo.Description = "API for HellreigN"
	docs.SwaggerInfo.Schemes = []string{"http"}
	router.GET("/swagger/*any", ginSwagger.WrapHandler(swaggerFiles.Handler))

	v1 := router.Group("/api/v1")
	{
		// Auth routes (public)
		authGroup := v1.Group("/auth")
		{
			authGroup.POST("/login", auth.Login)
		}

		// Auth token management (requires auth)
		authTokenGroup := v1.Group("/auth")
		authTokenGroup.Use(auth.AuthMiddleware())
		{
			authTokenGroup.POST("/token", handlers.RequireAdmin(), auth.CreateToken)
			authTokenGroup.GET("/validate", auth.ValidateToken)
			authTokenGroup.GET("/tokens", handlers.RequireAdmin(), auth.ListTokens)
			authTokenGroup.DELETE("/token", auth.DeleteMyToken)
			authTokenGroup.DELETE("/tokens/:login", handlers.RequireAdmin(), auth.DeleteToken)
		}

		// Agents (requires manage_agent permission)
		agentsGroup := v1.Group("/agents")
		agentsGroup.Use(auth.AuthMiddleware(), handlers.RequireManageAgent())
		{
			agentsGroup.GET("", agents.List)
		}

		// Logs (requires view permission)
		logsGroup := v1.Group("/logs")
		logsGroup.Use(auth.AuthMiddleware(), handlers.RequireView())
		{
			if cfg.Database.Clickhouse_host != "" {
				chConn, err := storage.OpenClickHouse(storage.ClickHouseConfig{
					Host:     cfg.Database.Clickhouse_host,
					User:     cfg.Database.Clickhouse_user,
					Password: cfg.Database.Clickhouse_password,
					Database: cfg.Database.Clickhouse_database,
				})
				if err != nil {
					log.Printf("Warning: ClickHouse connection failed: %v", err)
				} else {
					defer chConn.Close()

					logRepo := repository.NewLogRepository(chConn)
					if err := logRepo.Init(context.Background()); err != nil {
						log.Printf("Warning: Failed to initialize logs table: %v", err)
					}

					logHandlers := handlers.NewLogHandlers(logRepo)
					logsGroup.POST("", logHandlers.Insert)
					logsGroup.POST("/batch", logHandlers.InsertBatch)
					logsGroup.GET("", logHandlers.Search)
					logsGroup.GET("/services", logHandlers.GetServices)
					logsGroup.GET("/agents", logHandlers.GetAgents)
					logsGroup.GET("/levels", logHandlers.GetLevels)
				}
			}
		}
	}

	log.Fatal(router.Run(":8080"))
}