package db

import (
	"database/sql"
	"fmt"

	"github.com/timetracker/backend/internal/domain/repositories"
	"github.com/timetracker/backend/internal/infrastructure/persistence/db/ds"
	"gorm.io/driver/postgres"
	"gorm.io/gorm"
)

// DatabaseConfig enthält die Konfigurationsinformationen für die Datenbankverbindung
type DatabaseConfig struct {
	Host     string
	Port     int
	User     string
	Password string
	DBName   string
	SSLMode  string
}

// DatasourceContainer enthält alle Repository-Instanzen
type DatasourceContainer struct {
	ActivityDatasource  repositories.ActivityRepository
	CompanyDatasource   repositories.CompanyRepository
	CustomerDatasource  repositories.CustomerRepository
	ProjectDatasource   repositories.ProjectRepository
	TimeEntryDatasource repositories.TimeEntryRepository
	UserDatasource      repositories.UserRepository
}

// NewDatasourceContainer erstellt und initialisiert alle Repository-Instanzen
func NewDatasourceContainer(config DatabaseConfig) (*DatasourceContainer, error) {
	// Erstelle DSN (Data Source Name) für die Datenbankverbindung
	dsn := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s sslmode=%s",
		config.Host, config.Port, config.User, config.Password, config.DBName, config.SSLMode)

	// Erstelle SQL-Datenbankverbindung
	sqlDB, err := sql.Open("pgx", dsn)
	if err != nil {
		return nil, fmt.Errorf("fehler beim Öffnen der SQL-Verbindung: %w", err)
	}

	// Konfiguriere Verbindungspool
	sqlDB.SetMaxIdleConns(10)
	sqlDB.SetMaxOpenConns(100)

	// Initialisiere GORM mit der SQL-Verbindung
	gormDB, err := gorm.Open(postgres.New(postgres.Config{
		Conn: sqlDB,
	}), &gorm.Config{})
	if err != nil {
		return nil, fmt.Errorf("fehler beim Initialisieren von GORM: %w", err)
	}

	// Erstelle alle Repository-Instanzen
	return &DatasourceContainer{
		ActivityDatasource:  ds.NewActivityDatasource(gormDB),
		CompanyDatasource:   ds.NewCompanyDatasource(gormDB),
		CustomerDatasource:  ds.NewCustomerDatasource(gormDB),
		ProjectDatasource:   ds.NewProjectDatasource(gormDB),
		TimeEntryDatasource: ds.NewTimeEntryDatasource(gormDB),
		UserDatasource:      ds.NewUserDatasource(gormDB),
	}, nil
}

// Close schließt die Datenbankverbindung
func (r *DatasourceContainer) Close() error {
	db, err := r.getGormDB()
	if err != nil {
		return err
	}

	sqlDB, err := db.DB()
	if err != nil {
		return err
	}

	return sqlDB.Close()
}

// Helper-Methode, um die GORM-DB aus einem der Repositories zu extrahieren
func (r *DatasourceContainer) getGormDB() (*gorm.DB, error) {
	// Wir nehmen an, dass alle Repositories das gleiche DB-Handle verwenden
	// Deshalb können wir einfach eines der Repositories nehmen
	// Dies funktioniert nur, wenn wir Zugriff auf die interne DB haben oder eine Methode hinzufügen
	// Hier müsste angepasst werden, wie Sie Zugriff auf die GORM-DB bekommen

	// Beispiel (müsste angepasst werden):
	// activityDS, ok := r.ActivityRepository.(*ds.ActivityDatasource)
	// if !ok {
	//     return nil, fmt.Errorf("Konnte GORM-DB nicht aus ActivityRepository extrahieren")
	// }
	// return activityDS.GetDB(), nil

	// Placeholder für die tatsächliche Implementierung:
	return nil, fmt.Errorf("getGormDB() muss implementiert werden")
}