track-gopher/db/operations.go

package db

import (
	"database/sql"
	"fmt"
	"time"

	"track-gopher/models"
)

// Group operations

// CreateGroup creates a new group
func (db *DB) CreateGroup(name, description string) (int64, error) {
	result, err := db.Exec(
		"INSERT INTO groups (name, description) VALUES (?, ?)",
		name, description,
	)
	if err != nil {
		return 0, fmt.Errorf("failed to create group: %w", err)
	}

	id, err := result.LastInsertId()
	if err != nil {
		return 0, fmt.Errorf("failed to get last insert ID: %w", err)
	}

	return id, nil
}

// GetGroups returns all groups
func (db *DB) GetGroups() ([]models.Group, error) {
	rows, err := db.Query("SELECT id, name, description, created_at FROM groups ORDER BY name")
	if err != nil {
		return nil, fmt.Errorf("failed to query groups: %w", err)
	}
	defer rows.Close()

	var groups []models.Group
	for rows.Next() {
		var g models.Group
		var createdAt string
		if err := rows.Scan(&g.ID, &g.Name, &g.Description, &createdAt); err != nil {
			return nil, fmt.Errorf("failed to scan group row: %w", err)
		}
		g.CreatedAt, _ = time.Parse("2006-01-02 15:04:05", createdAt)
		groups = append(groups, g)
	}

	if err := rows.Err(); err != nil {
		return nil, fmt.Errorf("error iterating group rows: %w", err)
	}

	return groups, nil
}

// GetGroup returns a group by ID
func (db *DB) GetGroup(id int64) (*models.Group, error) {
	var g models.Group
	var createdAt string
	err := db.QueryRow(
		"SELECT id, name, description, created_at FROM groups WHERE id = ?",
		id,
	).Scan(&g.ID, &g.Name, &g.Description, &createdAt)
	if err != nil {
		if err == sql.ErrNoRows {
			return nil, nil
		}
		return nil, fmt.Errorf("failed to query group: %w", err)
	}

	g.CreatedAt, _ = time.Parse("2006-01-02 15:04:05", createdAt)
	return &g, nil
}

// UpdateGroup updates a group
func (db *DB) UpdateGroup(id int64, name, description string) error {
	_, err := db.Exec(
		"UPDATE groups SET name = ?, description = ? WHERE id = ?",
		name, description, id,
	)
	if err != nil {
		return fmt.Errorf("failed to update group: %w", err)
	}
	return nil
}

// DeleteGroup deletes a group
func (db *DB) DeleteGroup(id int64) error {
	_, err := db.Exec("DELETE FROM groups WHERE id = ?", id)
	if err != nil {
		return fmt.Errorf("failed to delete group: %w", err)
	}
	return nil
}

// Racer operations

// CreateRacer creates a new racer
func (db *DB) CreateRacer(firstName, lastName, carNumber string, carWeight float64, groupID int64) (int64, error) {
	result, err := db.Exec(
		"INSERT INTO racers (first_name, last_name, car_number, car_weight, group_id) VALUES (?, ?, ?, ?, ?)",
		firstName, lastName, carNumber, carWeight, groupID,
	)
	if err != nil {
		return 0, fmt.Errorf("failed to create racer: %w", err)
	}

	id, err := result.LastInsertId()
	if err != nil {
		return 0, fmt.Errorf("failed to get last insert ID: %w", err)
	}

	return id, nil
}

// GetRacers returns all racers
func (db *DB) GetRacers() ([]models.Racer, error) {
	rows, err := db.Query(`
		SELECT r.id, r.first_name, r.last_name, r.car_number, r.car_weight, 
		       r.group_id, g.name as group_name, r.created_at 
		FROM racers r
		JOIN groups g ON r.group_id = g.id
		ORDER BY r.last_name, r.first_name
	`)
	if err != nil {
		return nil, fmt.Errorf("failed to query racers: %w", err)
	}
	defer rows.Close()

	var racers []models.Racer
	for rows.Next() {
		var r models.Racer
		var createdAt string
		if err := rows.Scan(
			&r.ID, &r.FirstName, &r.LastName, &r.CarNumber, &r.CarWeight,
			&r.GroupID, &r.GroupName, &createdAt,
		); err != nil {
			return nil, fmt.Errorf("failed to scan racer row: %w", err)
		}
		r.CreatedAt, _ = time.Parse("2006-01-02 15:04:05", createdAt)
		racers = append(racers, r)
	}

	if err := rows.Err(); err != nil {
		return nil, fmt.Errorf("error iterating racer rows: %w", err)
	}

	return racers, nil
}

// IsCarNumberUnique checks if a car number is already in use
func (db *DB) IsCarNumberUnique(carNumber string) (bool, error) {
	var count int
	err := db.QueryRow("SELECT COUNT(*) FROM racers WHERE car_number = ?", carNumber).Scan(&count)
	if err != nil {
		return false, err
	}
	return count == 0, nil
}

// GetRacersByGroup returns racers in a specific group
func (db *DB) GetRacersByGroup(groupID int64) ([]models.Racer, error) {
	rows, err := db.Query(`
		SELECT r.id, r.first_name, r.last_name, r.car_number, r.car_weight, 
		       r.group_id, g.name as group_name, r.created_at 
		FROM racers r
		JOIN groups g ON r.group_id = g.id
		WHERE r.group_id = ?
		ORDER BY r.last_name, r.first_name
	`, groupID)
	if err != nil {
		return nil, fmt.Errorf("failed to query racers by group: %w", err)
	}
	defer rows.Close()

	var racers []models.Racer
	for rows.Next() {
		var r models.Racer
		var createdAt string
		if err := rows.Scan(
			&r.ID, &r.FirstName, &r.LastName, &r.CarNumber, &r.CarWeight,
			&r.GroupID, &r.GroupName, &createdAt,
		); err != nil {
			return nil, fmt.Errorf("failed to scan racer row: %w", err)
		}
		r.CreatedAt, _ = time.Parse("2006-01-02 15:04:05", createdAt)
		racers = append(racers, r)
	}

	if err := rows.Err(); err != nil {
		return nil, fmt.Errorf("error iterating racer rows: %w", err)
	}

	return racers, nil
}

// GetRacer returns a racer by ID
func (db *DB) GetRacer(id int64) (*models.Racer, error) {
	var r models.Racer
	var createdAt string
	err := db.QueryRow(`
		SELECT r.id, r.first_name, r.last_name, r.car_number, r.car_weight, 
		       r.group_id, g.name as group_name, r.created_at 
		FROM racers r
		JOIN groups g ON r.group_id = g.id
		WHERE r.id = ?
	`, id).Scan(
		&r.ID, &r.FirstName, &r.LastName, &r.CarNumber, &r.CarWeight,
		&r.GroupID, &r.GroupName, &createdAt,
	)
	if err != nil {
		if err == sql.ErrNoRows {
			return nil, nil
		}
		return nil, fmt.Errorf("failed to query racer: %w", err)
	}

	r.CreatedAt, _ = time.Parse("2006-01-02 15:04:05", createdAt)
	return &r, nil
}

// UpdateRacer updates a racer
func (db *DB) UpdateRacer(id int64, firstName, lastName, carNumber string, carWeight float64, groupID int64) error {
	_, err := db.Exec(
		"UPDATE racers SET first_name = ?, last_name = ?, car_number = ?, car_weight = ?, group_id = ? WHERE id = ?",
		firstName, lastName, carNumber, carWeight, groupID, id,
	)
	if err != nil {
		return fmt.Errorf("failed to update racer: %w", err)
	}
	return nil
}

// DeleteRacer deletes a racer
func (db *DB) DeleteRacer(id int64) error {
	_, err := db.Exec("DELETE FROM racers WHERE id = ?", id)
	if err != nil {
		return fmt.Errorf("failed to delete racer: %w", err)
	}
	return nil
}