// Sistema de Migración Programática con golang-migrate
// Implementación completa de un sistema de migraciones que se ejecuta automáticamente al iniciar una aplicación Go
package main
import (
	"context"
	"database/sql"
	"fmt"
	"log"
	"os"
	"time"
	"github.com/golang-migrate/migrate/v4"
	"github.com/golang-migrate/migrate/v4/database/postgres"
	_ "github.com/golang-migrate/migrate/v4/source/file"
	_ "github.com/lib/pq"
)
// Migrator representa el sistema de migraciones con configuración flexible.
type Migrator struct {
	m *migrate.Migrate
}
// NewMigrator inicializa el sistema de migraciones con configuración.
// Utiliza variables de entorno para flexibilidad en diferentes entornos.
// Por qué: Permite configuración dinámica sin hardcoding, ideal para prod/dev.
func NewMigrator(ctx context.Context) (*Migrator, error) {
	dsn := os.Getenv("DATABASE_URL")
	if dsn == "" {
		return nil, fmt.Errorf("DATABASE_URL not set")
	}
	// Abrir conexión a la DB para validación y migración.
	db, err := sql.Open("postgres", dsn)
	if err != nil {
		return nil, fmt.Errorf("failed to open database: %w", err)
	}
	// Crear driver para migrate.
	driver, err := postgres.WithInstance(db, &postgres.Config{})
	if err != nil {
		return nil, fmt.Errorf("failed to create postgres driver: %w", err)
	}
	// Asumir migraciones en filesystem; en prod, usar embed o similar.
	m, err := migrate.NewWithDatabaseInstance(
		"file://migrations", // Ruta a archivos de migración (ejemplo).
		"postgres", driver)
	if err != nil {
		return nil, fmt.Errorf("failed to create migrator: %w", err)
	}
	return &Migrator{m: m}, nil
}
// ValidateConnection verifica conectividad antes de migrar.
// Por qué: Evita aplicar migraciones en DB no accesible, manejando edge cases como timeouts.
func (m *Migrator) ValidateConnection(ctx context.Context) error {
	ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
	defer cancel()
	// Usar ping con context para validación robusta.
	if err := m.m.Ping(ctx); err != nil { // Nota: migrate no tiene Ping directo, simular con versión.
		_, _, err := m.m.Version()
		if err != nil {
			return fmt.Errorf("database connection validation failed: %w", err)
		}
	}
	log.Println("Database connection validated successfully")
	return nil
}
// ApplyMigrations ejecuta migraciones pendientes con logging.
// Por qué: Logging detallado ayuda en debugging y monitoring durante startup.
func (m *Migrator) ApplyMigrations(ctx context.Context) error {
	if err := m.ValidateConnection(ctx); err != nil {
		return err
	}
	log.Println("Starting migration application")
	err := m.m.Up()
	if err != nil {
		if err == migrate.ErrNoChange {
			log.Println("No migrations to apply")
			return nil
		}
		return fmt.Errorf("failed to apply migrations: %w", err)
	}
	log.Println("Migrations applied successfully")
	return nil
}
// GetCurrentVersion obtiene la versión actual del esquema.
// Por qué: Útil para verificación post-migración o reporting.
func (m *Migrator) GetCurrentVersion() (uint, bool, error) {
	return m.m.Version()
}
func main() {
	ctx := context.Background()
	migrator, err := NewMigrator(ctx)
	if err != nil {
		log.Fatalf("Failed to initialize migrator: %v", err)
	}
	if err := migrator.ApplyMigrations(ctx); err != nil {
		log.Fatalf("Failed to apply migrations: %v", err)
	}
	version, dirty, err := migrator.GetCurrentVersion()
	if err != nil {
		log.Fatalf("Failed to get version: %v", err)
	}
	fmt.Printf("Current schema version: %d (dirty: %v)\n", version, dirty)
	// Output esperado:
	// Starting migration application
	// Database connection validated successfully
	// Migrations applied successfully (o No migrations to apply)
	// Current schema version: X (dirty: false)
	// Sistema que aplica migraciones automáticamente, muestra progreso detallado y maneja errores gracefully
}

// Pipeline de Deployment con Migraciones Multi-Base de Datos
// Sistema enterprise que coordina migraciones across múltiples microservicios con diferentes bases de datos
package main
import (
	"context"
	"fmt"
	"log"
	"os"
	"sync"
	"time"
	"github.com/golang-migrate/migrate/v4"
	"github.com/golang-migrate/migrate/v4/database/mongodb"
	"github.com/golang-migrate/migrate/v4/database/postgres"
	_ "github.com/golang-migrate/migrate/v4/source/file"
	_ "github.com/lib/pq"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
)
// MigrationConfig representa config para una DB específica.
type MigrationConfig struct {
	Name       string
	DSN        string
	DriverType string // "postgres" o "mongodb"
	MigPath    string
}
// MultiMigrator maneja migraciones paralelas con métricas.
type MultiMigrator struct {
	configs []MigrationConfig
}
// NewMultiMigrator crea migrator con configs de env vars.
// Por qué: Configuración centralizada via environment variables para entornos enterprise.
func NewMultiMigrator() *MultiMigrator {
	// Ejemplo: Leer de env vars; en prod, parsear múltiples.
	configs := []MigrationConfig{
		{Name: "service1-postgres", DSN: os.Getenv("DB1_URL"), DriverType: "postgres", MigPath: "file://migrations/service1"},
		{Name: "service2-mongo", DSN: os.Getenv("MONGO_URL"), DriverType: "mongodb", MigPath: "file://migrations/service2"},
		// Agregar más para 5 microservicios...
	}
	return &MultiMigrator{configs: configs}
}
// ApplyAll ejecuta migraciones en paralelo con métricas y rollback.
// Por qué: Paralelismo para performance en deployments; rollback coordinado para safety.
func (mm *MultiMigrator) ApplyAll(ctx context.Context) error {
	var wg sync.WaitGroup
	errChan := make(chan error, len(mm.configs))
	metrics := make(map[string]time.Duration)
	for _, cfg := range mm.configs {
		wg.Add(1)
		go func(c MigrationConfig) {
			defer wg.Done()
			start := time.Now()
			m, err := mm.createMigrateInstance(c)
			if err != nil {
				errChan <- fmt.Errorf("%s: failed to create migrator: %w", c.Name, err)
				return
			}
			log.Printf("%s: Starting migration", c.Name)
			if err := m.Up(); err != nil && err != migrate.ErrNoChange {
				// Rollback en error.
				log.Printf("%s: Migration failed, rolling back: %v", c.Name, err)
				if rbErr := m.Down(); rbErr != nil {
					errChan <- fmt.Errorf("%s: rollback failed: %w", c.Name, rbErr)
					return
				}
				errChan <- fmt.Errorf("%s: migration failed after rollback: %w", c.Name, err)
				return
			}
			metrics[c.Name] = time.Since(start)
			log.Printf("%s: Migration completed in %v", c.Name, metrics[c.Name])
			// Health check post-migración.
			if err := mm.healthCheck(m); err != nil {
				errChan <- fmt.Errorf("%s: health check failed: %w", c.Name, err)
			}
		}(cfg)
	}
	wg.Wait()
	close(errChan)
	for err := range errChan {
		if err != nil {
			return err // Retornar primer error; en prod, recolectar todos.
		}
	}
	// Reportar métricas.
	for name, dur := range metrics {
		fmt.Printf("Metric: %s duration %v\n", name, dur)
	}
	return nil
}
// createMigrateInstance crea instancia de migrate basada en driver.
// Por qué: Soporte para múltiples DB types en microservicios.
func (mm *MultiMigrator) createMigrateInstance(cfg MigrationConfig) (*migrate.Migrate, error) {
	switch cfg.DriverType {
	case "postgres":
		db, err := sql.Open("postgres", cfg.DSN)
		if err != nil {
			return nil, err
		}
		driver, err := postgres.WithInstance(db, &postgres.Config{})
		if err != nil {
			return nil, err
		}
		return migrate.NewWithDatabaseInstance(cfg.MigPath, "postgres", driver)
	case "mongodb":
		client, err := mongo.Connect(context.Background(), options.Client().ApplyURI(cfg.DSN))
		if err != nil {
			return nil, err
		}
		driver, err := mongodb.WithInstance(client, &mongodb.Config{DatabaseName: "mydb"})
		if err != nil {
			return nil, err
		}
		return migrate.NewWithDatabaseInstance(cfg.MigPath, "mongodb", driver)
	default:
		return nil, fmt.Errorf("unsupported driver: %s", cfg.DriverType)
	}
}
// healthCheck realiza check post-migración.
// Por qué: Asegura DB healthy después de cambios.
func (mm *MultiMigrator) healthCheck(m *migrate.Migrate) error {
	_, _, err := m.Version()
	return err
}
func main() {
	ctx := context.Background()
	mm := NewMultiMigrator()
	if err := mm.ApplyAll(ctx); err != nil {
		log.Fatalf("Migrations failed: %v", err)
	}
	fmt.Println("All migrations completed successfully")
	// Output esperado:
	// service1-postgres: Starting migration
	// service2-mongo: Starting migration
	// ... completados con tiempos
	// Metric: service1-postgres duration Xms
	// All migrations completed successfully
	// Sistema que migra múltiples bases de datos en paralelo, reporta métricas y permite rollback coordinado
}

// Ejemplos de Errores Comunes en Migraciones
// Error 1: Migración no idempotente
// Descripción: CREATE TABLE sin IF NOT EXISTS que falla en re-ejecuciones
// Consecuencias: Fallos en pipelines de CI/CD y deployments
// Código que demuestra el error (migración up defectuosa):
// -- up.sql (ejemplo de archivo de migración)
// CREATE TABLE users (id SERIAL PRIMARY KEY);  // Falla si tabla ya existe
// Explicación del problema:
// Esta migración no es idempotente; si se ejecuta dos veces, falla con "table already exists".
// Por qué: En deployments repetidos o tests, causa errores innecesarios.
// Implementación corregida:
// -- up.sql corregido
// CREATE TABLE IF NOT EXISTS users (id SERIAL PRIMARY KEY);  // Idempotente, no falla si existe
// Solución: Usar IF NOT EXISTS y validar estado antes de cambios
// En código Go, siempre verificar versión antes de aplicar para evitar re-ejecuciones innecesarias.
// Error 2: Migración down incompleta
// Descripción: Migración up sin implementar correctamente la reversión
// Consecuencias: Imposibilidad de rollback durante emergencias
// Código que demuestra el error (migración down incompleta):
// -- up.sql
// CREATE TABLE users (id SERIAL PRIMARY KEY);
// INSERT INTO users (id) VALUES (1);
// -- down.sql (defectuoso)
// DROP TABLE users;  // Olvida limpiar datos o dependencias, pero en este caso simple, asume incompleto si hay FKs
// Explicación del problema:
// Si up inserta datos o crea dependencias, down debe revertir todo; de lo contrario, rollback falla o deja DB inconsistente.
// Por qué: En emergencias, no se puede revertir cambios, causando downtime.
// Implementación corregida:
// -- down.sql corregido
// DELETE FROM users;  // Limpiar datos si necesario
// DROP TABLE IF EXISTS users;  // Completo y seguro
// Solución: Implementar y testear migraciones down siempre
// En código Go, probar rollback en tests:
// m := NewMigrator()  // Asumir setup
// err := m.Up()
// if err != nil { t.Fatal(err) }
// err = m.Down()  // Testear que revierte correctamente
// if err != nil { t.Fatal("Rollback failed") }
// Nota: Estos son ejemplos de archivos de migración; en código Go, integrate con migrate para ejecutar y testear.