package database

import (
	"fmt"
)

// GetArtistSettings retrieves an artist_settings row by ID.
// Returns sql.ErrNoRows if the artist is not found.
func GetArtistSettings(db *DB, id string) (*ArtistSettings, error) {
	var s ArtistSettings
	err := db.Conn().QueryRow(
		"SELECT id, name, ignore_singles, ignore_compilations, monitored FROM artist_settings WHERE id = ?",
		id,
	).Scan(&s.ID, &s.Name, &s.IgnoreSingles, &s.IgnoreCompilations, &s.Monitored)
	if err != nil {
		return nil, err
	}
	return &s, nil
}

// SaveArtistSettings inserts or replaces an artist_settings row.
func SaveArtistSettings(db *DB, settings *ArtistSettings) error {
	_, err := db.Conn().Exec(
		"INSERT OR REPLACE INTO artist_settings (id, name, ignore_singles, ignore_compilations, monitored) VALUES (?, ?, ?, ?, ?)",
		settings.ID, settings.Name, settings.IgnoreSingles, settings.IgnoreCompilations, settings.Monitored,
	)
	if err != nil {
		return fmt.Errorf("save artist settings: %w", err)
	}
	return nil
}

// GetAllArtistSettings returns all rows from artist_settings.
func GetAllArtistSettings(db *DB) ([]ArtistSettings, error) {
	rows, err := db.Conn().Query(
		"SELECT id, name, ignore_singles, ignore_compilations, monitored FROM artist_settings",
	)
	if err != nil {
		return nil, fmt.Errorf("query all artist settings: %w", err)
	}
	defer rows.Close()

	var results []ArtistSettings
	for rows.Next() {
		var s ArtistSettings
		if err := rows.Scan(&s.ID, &s.Name, &s.IgnoreSingles, &s.IgnoreCompilations, &s.Monitored); err != nil {
			return nil, fmt.Errorf("scan artist settings: %w", err)
		}
		results = append(results, s)
	}
	if err := rows.Err(); err != nil {
		return nil, fmt.Errorf("iterate artist settings: %w", err)
	}
	return results, nil
}

// UpdateArtistSettings updates specific fields of an artist_settings row by ID.
// The updates map keys must match column names: "name", "ignore_singles", "ignore_compilations", "monitored".
func UpdateArtistSettings(db *DB, id string, updates map[string]interface{}) error {
	// Build the SET clause dynamically from the provided updates.
	allowed := map[string]bool{
		"name":                true,
		"ignore_singles":      true,
		"ignore_compilations": true,
		"monitored":           true,
	}

	var args []interface{}
	setClause := ""
	for col, val := range updates {
		if !allowed[col] {
			return fmt.Errorf("unknown column: %s", col)
		}
		if setClause != "" {
			setClause += ", "
		}
		setClause += col + " = ?"
		args = append(args, val)
	}

	if len(args) == 0 {
		return fmt.Errorf("no updates provided")
	}

	args = append(args, id)
	query := fmt.Sprintf("UPDATE artist_settings SET %s WHERE id = ?", setClause)
	result, err := db.Conn().Exec(query, args...)
	if err != nil {
		return fmt.Errorf("update artist settings: %w", err)
	}

	rowsAffected, err := result.RowsAffected()
	if err != nil {
		return fmt.Errorf("rows affected: %w", err)
	}
	if rowsAffected == 0 {
		return fmt.Errorf("artist not found: %s", id)
	}

	return nil
}