package main

import (
    "context"
    "log"
    "net/http"
    "os"
    
    "github.com/gin-gonic/gin"
    "github.com/seu-usuario/cgi/initializers/auth"
    "github.com/seu-usuario/cgi/initializers/postgres"
    "github.com/seu-usuario/cgi/initializers/formatter"
    "github.com/seu-usuario/cgi/initializers/validator"
    "github.com/seu-usuario/cgi/initializers/opentelemetry"
)

func main() {
    ctx := context.Background()
    
    // Inicializar OpenTelemetry para observabilidade
    otelConfig := opentelemetry.Initialize(ctx, opentelemetry.Config{
        ServiceName:    "minha-api",
        ServiceVersion: "1.0.0",
        Environment:    "production",
    })
    defer otelConfig.Shutdown(ctx)
    
    // Inicializar banco de dados
    dbConfig := postgres.Config{
        Host:     os.Getenv("DB_HOST"),
        Port:     os.Getenv("DB_PORT"),
        User:     os.Getenv("DB_USER"),
        Password: os.Getenv("DB_PASSWORD"),
        Database: os.Getenv("DB_NAME"),
    }
    
    db, err := postgres.Initialize(dbConfig)
    if err != nil {
        log.Fatal("Erro ao conectar com banco:", err)
    }
    defer db.Close()
    
    // Inicializar autenticação
    authConfig := auth.Config{
        SecretKey:       os.Getenv("JWT_SECRET"),
        TokenExpiration: "24h",
        Issuer:          "minha-api",
    }
    
    authService, err := auth.Initialize(authConfig)
    if err != nil {
        log.Fatal("Erro ao inicializar auth:", err)
    }
    
    // Inicializar validador
    validatorConfig := validator.Initialize(validator.Config{
        Language: "pt-BR",
    })
    
    // Configurar Gin
    r := gin.Default()
    
    // Middleware de observabilidade
    r.Use(opentelemetry.GinMiddleware())
    
    // Middleware de autenticação
    r.Use(auth.GinMiddleware(authService))
    
    // Rotas da API
    api := r.Group("/api/v1")
    {
        api.POST("/login", loginHandler(authService))
        api.GET("/users", getUsersHandler(db))
        api.POST("/users", createUserHandler(db, validatorConfig))
    }
    
    // Iniciar servidor
    log.Println("Servidor iniciado na porta 8080")
    log.Fatal(http.ListenAndServe(":8080", r))
}

func loginHandler(authService *auth.AuthService) gin.HandlerFunc {
    return func(c *gin.Context) {
        var loginData struct {
            Email    string `json:"email" validate:"required,email"`
            Password string `json:"password" validate:"required,min=6"`
        }
        
        if err := c.ShouldBindJSON(&loginData); err != nil {
            c.JSON(400, formatter.ErrorResponse{
                Error: formatter.FormattedError{
                    Code:    "INVALID_INPUT",
                    Message: "Dados de entrada inválidos",
                    Details: err.Error(),
                },
            })
            return
        }
        
        // Lógica de autenticação...
        token, err := authService.GenerateToken("user123", map[string]interface{}{
            "email": loginData.Email,
        })
        
        if err != nil {
            c.JSON(500, formatter.ErrorResponse{
                Error: formatter.FormattedError{
                    Code:    "AUTH_ERROR",
                    Message: "Erro na autenticação",
                },
            })
            return
        }
        
        c.JSON(200, gin.H{
            "token": token,
            "user": gin.H{
                "email": loginData.Email,
            },
        })
    }
}

func getUsersHandler(db *postgres.Database) gin.HandlerFunc {
    return func(c *gin.Context) {
        // Lógica para buscar usuários...
        users := []map[string]interface{}{
            {"id": 1, "name": "João", "email": "[email protected]"},
            {"id": 2, "name": "Maria", "email": "[email protected]"},
        }
        
        c.JSON(200, gin.H{
            "users": users,
            "total": len(users),
        })
    }
}

func createUserHandler(db *postgres.Database, validator *validator.ValidatorConfig) gin.HandlerFunc {
    return func(c *gin.Context) {
        var userData struct {
            Name     string `json:"name" validate:"required,min=2"`
            Email    string `json:"email" validate:"required,email"`
            Password string `json:"password" validate:"required,min=8"`
        }
        
        if err := c.ShouldBindJSON(&userData); err != nil {
            c.JSON(400, formatter.ErrorResponse{
                Error: formatter.FormattedError{
                    Code:    "INVALID_INPUT",
                    Message: "Dados de entrada inválidos",
                },
            })
            return
        }
        
        // Validar dados
        if err := validator.ValidateStruct(userData); err != nil {
            c.JSON(400, formatter.ErrorResponse{
                Error: formatter.FormattedError{
                    Code:    "VALIDATION_ERROR",
                    Message: "Erro de validação",
                    Details: err.Error(),
                },
            })
            return
        }
        
        // Lógica para criar usuário...
        c.JSON(201, gin.H{
            "message": "Usuário criado com sucesso",
            "user": gin.H{
                "name":  userData.Name,
                "email": userData.Email,
            },
        })
    }
}

// tests/integration_test.go
//go:build integration

package tests

import (
    "context"
    "testing"
    "time"
    
    "github.com/stretchr/testify/assert"
    "github.com/seu-usuario/cgi/initializers/postgres"
    "github.com/seu-usuario/cgi/initializers/auth"
)

func TestFullIntegration(t *testing.T) {
    ctx := context.Background()
    
    // Setup banco de dados de teste
    dbConfig := postgres.Config{
        Host:     "localhost",
        Port:     "5432",
        User:     "postgres",
        Password: "senha123",
        Database: "test_db",
    }
    
    db, err := postgres.Initialize(dbConfig)
    assert.NoError(t, err)
    defer db.Close()
    
    // Setup autenticação
    authConfig := auth.Config{
        SecretKey:       "test-secret-key",
        TokenExpiration: "1h",
        Issuer:          "test-api",
    }
    
    authService, err := auth.Initialize(authConfig)
    assert.NoError(t, err)
    
    // Teste de geração de token
    token, err := authService.GenerateToken("user123", map[string]interface{}{
        "email": "[email protected]",
    })
    assert.NoError(t, err)
    assert.NotEmpty(t, token)
    
    // Teste de validação de token
    claims, err := authService.ValidateToken(token)
    assert.NoError(t, err)
    assert.Equal(t, "user123", claims.Subject)
}