package main

import (
    "log"
    "net/http"
    
    "github.com/alexalmadav/go-multitenant"
    "github.com/gin-gonic/gin"
)

func main() {
    // Create configuration
    config := multitenant.DefaultConfig()
    config.Database.DSN = "postgres://user:pass@localhost/mydb?sslmode=disable"
    config.Resolver.Strategy = multitenant.ResolverSubdomain
    config.Resolver.Domain = "myapp.com"

    // Initialize multi-tenant system
    mt, err := multitenant.New(config)
    if err != nil {
        log.Fatal(err)
    }
    defer mt.Close()

    // Setup Gin with multi-tenant middleware
    r := gin.Default()
    
    // Apply tenant middleware
    api := r.Group("/api")
    api.Use(mt.GinMiddleware.ResolveTenant())
    api.Use(mt.GinMiddleware.ValidateTenant())
    api.Use(mt.GinMiddleware.EnforceLimits())
    
    // Your tenant-aware routes
    api.GET("/dashboard", func(c *gin.Context) {
        tenant, _ := multitenant.GetTenantFromContext(c.Request.Context())
        c.JSON(http.StatusOK, gin.H{
            "message": "Welcome to " + tenant.Subdomain,
            "plan": tenant.PlanType,
        })
    })

    log.Fatal(http.ListenAndServe(":8080", r))
}

// Configure custom plan limits
config.Limits.PlanLimits = map[string]*multitenant.Limits{
    multitenant.PlanBasic: {
        MaxUsers:     5,
        MaxProjects:  10,
        MaxStorageGB: 1,
    },
    multitenant.PlanPro: {
        MaxUsers:     25,
        MaxProjects:  100,
        MaxStorageGB: 10,
    },
}

// Create middleware with custom error handling
ginConfig := ginmiddleware.Config{
    SkipPaths: []string{"/health", "/billing/"},
    RequireAuthentication: true,
    ErrorHandler: func(c *gin.Context, err error) {
        if tenantErr, ok := err.(*multitenant.TenantError); ok {
            if tenantErr.Code == "PLAN_LIMIT_EXCEEDED" {
                c.JSON(http.StatusPaymentRequired, gin.H{
                    "error": tenantErr.Message,
                    "upgrade_url": "/billing/upgrade",
                })
                return
            }
        }
        // Default error handling...
    },
}

config.Resolver.Strategy = multitenant.ResolverSubdomain
config.Resolver.Domain = "myapp.com"

// tenant1.myapp.com -> resolves to "tenant1"
// tenant2.myapp.com -> resolves to "tenant2"

config.Resolver.Strategy = multitenant.ResolverPath
config.Resolver.PathPrefix = "/tenant/"

// myapp.com/tenant/tenant1/api -> resolves to "tenant1"
// myapp.com/tenant/tenant2/api -> resolves to "tenant2"

config.Resolver.Strategy = multitenant.ResolverHeader
config.Resolver.HeaderName = "X-Tenant-ID"

// X-Tenant-ID: tenant1 -> resolves to "tenant1"

config.Database = multitenant.DatabaseConfig{
    Driver:              "postgres",
    DSN:                "postgres://user:pass@localhost/db?sslmode=disable",
    MaxOpenConns:        100,
    MaxIdleConns:        50,
    ConnMaxLifetime:     15 * time.Minute,
    SchemaPrefix:        "tenant_",     // Schema naming: tenant_{uuid}
    MigrationsTable:     "tenant_migrations",
}

config.Resolver = multitenant.ResolverConfig{
    Strategy:          multitenant.ResolverSubdomain,
    Domain:            "myapp.com",
    ReservedSubdomain: []string{"www", "api", "admin"},
}

config.Limits = multitenant.LimitsConfig{
    EnforceLimits: true,
    PlanLimits: map[string]*multitenant.Limits{
        multitenant.PlanBasic: {
            MaxUsers:     5,
            MaxProjects:  10,
            MaxStorageGB: 1,
        },
        // ... more plans
    },
}

// Core middleware
mt.GinMiddleware.ResolveTenant()     // Resolves tenant from request
mt.GinMiddleware.ValidateTenant()    // Validates tenant status
mt.GinMiddleware.EnforceLimits()     // Enforces plan limits
mt.GinMiddleware.SetTenantDB()       // Sets up tenant database context

// Additional middleware
mt.GinMiddleware.RequireAdmin()      // Requires admin privileges
mt.GinMiddleware.LogAccess()         // Logs tenant access

api := r.Group("/api")
api.Use(authMiddleware())                    // Your auth middleware
api.Use(mt.GinMiddleware.ResolveTenant())    // Resolve tenant
api.Use(mt.GinMiddleware.ValidateTenant())   // Validate tenant status
api.Use(mt.GinMiddleware.EnforceLimits())    // Check limits
api.Use(mt.GinMiddleware.SetTenantDB())      // Set database context
api.Use(mt.GinMiddleware.LogAccess())        // Log access

// Admin-only routes
admin := api.Group("/admin")
admin.Use(mt.GinMiddleware.RequireAdmin())

// In your handlers, the database context is automatically set
func getProjects(c *gin.Context) {
    // Database queries are automatically scoped to the tenant
    db, _ := ginmiddleware.GetTenantDBFromContext(c)
    
    // This query only returns projects for the current tenant
    rows, err := db.Query("SELECT * FROM projects WHERE status = $1", "active")
    // ...
}

// For background jobs or non-HTTP contexts
ctx := mt.Manager.WithTenantContext(context.Background(), tenantID)
db, err := mt.Manager.GetTenantDB(ctx, tenantID)

tenant := &multitenant.Tenant{
    ID:        uuid.New(),
    Name:      "Acme Corporation",
    Subdomain: "acme",
    PlanType:  multitenant.PlanPro,
    Status:    multitenant.StatusPending,
}

// Create tenant record
err := mt.Manager.CreateTenant(ctx, tenant)

// Provision tenant schema
err = mt.Manager.ProvisionTenant(ctx, tenant.ID)

// Suspend a tenant
err := mt.Manager.SuspendTenant(ctx, tenantID)

// Activate a tenant
err := mt.Manager.ActivateTenant(ctx, tenantID)

// Get tenant statistics
stats, err := mt.Manager.GetStats(ctx, tenantID)

// Update tenant plan
tenant.PlanType = multitenant.PlanEnterprise
err := mt.Manager.UpdateTenant(ctx, tenant)

// Check current limits
limits, err := mt.Manager.CheckLimits(ctx, tenantID)

// Validate user access to tenant
err := mt.Manager.ValidateAccess(ctx, userID, tenantID)

// Admin-only operations
api.Use(mt.GinMiddleware.RequireAdmin())

// Automatic subdomain validation
// - Length requirements (3-50 characters)
// - Character restrictions (alphanumeric + hyphens)
// - Reserved subdomain protection
// - Format validation

// All operations include tenant context in logs
{
  "level": "info",
  "msg": "Tenant access",
  "tenant_id": "123e4567-e89b-12d3-a456-426614174000",
  "subdomain": "acme",
  "user_id": "user-456",
  "method": "GET",
  "path": "/api/projects"
}

stats, err := mt.Manager.GetStats(ctx, tenantID)
// Returns: UserCount, ProjectCount, StorageUsedGB, LastActivity