package data

import (
	"database/sql"
	"log"
	"time"

	_ "modernc.org/sqlite" // Importiert den SQLite-Treiber
)

type DatabaseService struct {
	DB *sql.DB
}

func NewDatabaseService(dbPath string) (*DatabaseService, error) {
	db, err := sql.Open("sqlite", dbPath)
	if err != nil {
		return nil, err
	}

	if err = db.Ping(); err != nil {
		return nil, err
	}

	createTableSQL := `
	CREATE TABLE IF NOT EXISTS training (
		id INTEGER PRIMARY KEY AUTOINCREMENT,
		date TEXT NOT NULL,
		sets INTEGER,
		weightLeft REAL,
		weightRight REAL,
		repsPerSet INTEGER,
		duration INTEGER,
		program TEXT,
		blockDay INTEGER
	);`

	_, err = db.Exec(createTableSQL)
	if err != nil {
		log.Printf("Fehler beim Erstellen der Tabelle: %v", err)
		return nil, err
	}

	// Hier könnten wir auch komplexere Migrationen wie dein _onUpgrade handle,
	// aber für den Anfang reicht das Erstellen der Tabelle.

	log.Println("Datenbank erfolgreich initialisiert.")
	return &DatabaseService{DB: db}, nil
}

func (s *DatabaseService) SaveTraining(session *TrainingSession) error {
	dateStr := session.Date.Format(time.RFC3339)

	query := `
		INSERT INTO training (id, date, sets, weightLeft, weightRight, repsPerSet, duration, program, blockDay)
		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
		ON CONFLICT(id) DO UPDATE SET
			date = excluded.date,
			sets = excluded.sets,
			weightLeft = excluded.weightLeft,
			weightRight = excluded.weightRight,
			repsPerSet = excluded.repsPerSet,
			duration = excluded.duration,
			program = excluded.program,
			blockDay = excluded.blockDay;
	`
	var id any
	if session.ID != 0 {
		id = session.ID
	}

	_, err := s.DB.Exec(query, id, dateStr, session.Sets, session.WeightLeft, session.WeightRight, session.RepsPerSet, session.Duration, session.Program, session.BlockDay)
	return err
}

func (s *DatabaseService) GetTrainingCount() (int, error) {
	var count int
	query := "SELECT COUNT(*) FROM training;"
	err := s.DB.QueryRow(query).Scan(&count)
	if err != nil {
		if err == sql.ErrNoRows {
			return 0, nil
		}
		return 0, err
	}
	return count, nil
}

func (s *DatabaseService) GetHistory() ([]TrainingSession, error) {
	query := `SELECT id, date, sets, weightLeft, weightRight, repsPerSet, duration, program, blockDay FROM training ORDER BY date DESC LIMIT 20;`

	rows, err := s.DB.Query(query)
	if err != nil {
		return nil, err
	}
	defer rows.Close()

	var sessions []TrainingSession
	for rows.Next() {
		var s TrainingSession
		var dateStr string

		err := rows.Scan(&s.ID, &dateStr, &s.Sets, &s.WeightLeft, &s.WeightRight, &s.RepsPerSet, &s.Duration, &s.Program, &s.BlockDay)
		if err != nil {
			return nil, err
		}

		s.Date, err = time.Parse(time.RFC3339, dateStr)
		if err != nil {
			return nil, err
		}

		sessions = append(sessions, s)
	}

	return sessions, nil
}