package db

import (
	"database/sql"
	"fmt"
	"gestion/models"
	"log"
	"time"
)

func (d *Database) CreateUser(user *models.User) error {
	query := `INSERT INTO users (username, password, role, created_at, updated_at) 
	          VALUES ($1, $2, $3, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP) 
	          RETURNING id, created_at, updated_at`

	var createdAt, updatedAt time.Time
	err := d.QueryRow(query, user.Username, user.Password, user.Role).Scan(
		&user.ID,
		&createdAt,
		&updatedAt,
	)
	if err != nil {
		return fmt.Errorf("erreur lors de la création de l'utilisateur: %w", err)
	}

	return nil
}

// GetAllUsers récupère tous les utilisateurs
func (d *Database) GetAllUsers() ([]*models.User, error) {
	query := `SELECT id, username, password, role, created_at, updated_at 
	          FROM users ORDER BY created_at DESC`

	rows, err := d.Query(query)
	if err != nil {
		return nil, fmt.Errorf("erreur lors de la récupération des utilisateurs: %w", err)
	}
	defer rows.Close()

	var users []*models.User
	for rows.Next() {
		user := &models.User{}
		var createdAt, updatedAt time.Time
		err := rows.Scan(
			&user.ID,
			&user.Username,
			&user.Password,
			&user.Role,
			&createdAt,
			&updatedAt,
		)
		if err != nil {
			return nil, fmt.Errorf("erreur lors du scan de l'utilisateur: %w", err)
		}
		users = append(users, user)
	}

	if err = rows.Err(); err != nil {
		return nil, fmt.Errorf("erreur lors de l'itération des résultats: %w", err)
	}

	return users, nil
}

func (d *Database) GetAllDeliveryMen() ([]*models.User, error) {
	query := `
		SELECT id, username, password, role
		FROM users
		WHERE role = 'livreur'
	`

	rows, err := d.Query(query)
	if err != nil {
		return nil, fmt.Errorf("erreur lors de la récupération des utilisateurs: %w", err)
	}
	defer rows.Close()

	var users []*models.User

	for rows.Next() {
		user := &models.User{}
		err := rows.Scan(
			&user.ID,
			&user.Username,
			&user.Password,
			&user.Role,
		)
		if err != nil {
			return nil, fmt.Errorf("erreur lors du scan de l'utilisateur: %w", err)
		}
		users = append(users, user)
	}

	if err = rows.Err(); err != nil {
		return nil, fmt.Errorf("erreur lors de l'itération des résultats: %w", err)
	}

	return users, nil
}

// UpdateUser met à jour un utilisateur existant
func (d *Database) UpdateUser(user *models.User) error {
	query := `UPDATE users 
	          SET username = $1, password = $2, role = $3, updated_at = CURRENT_TIMESTAMP 
	          WHERE id = $4`

	result, err := d.Exec(query, user.Username, user.Password, user.Role, user.ID)
	if err != nil {
		return fmt.Errorf("erreur lors de la mise à jour de l'utilisateur: %w", err)
	}

	rowsAffected, err := result.RowsAffected()
	if err != nil {
		return fmt.Errorf("erreur lors de la vérification des lignes affectées: %w", err)
	}

	if rowsAffected == 0 {
		return fmt.Errorf("utilisateur non trouvé")
	}

	return nil
}

// DeleteUser supprime un utilisateur
func (d *Database) DeleteUser(id int) error {
	// Récupérer le rôle de l'utilisateur avant de le supprimer
	var role string
	err := d.QueryRow(`SELECT role FROM users WHERE id = $1`, id).Scan(&role)
	if err != nil {
		if err == sql.ErrNoRows {
			return fmt.Errorf("utilisateur non trouvé")
		}
		return fmt.Errorf("erreur lors de la récupération du rôle: %w", err)
	}

	// ✅ MODIFIÉ : Supprimer tous les tokens de l'utilisateur
	_ = d.RevokeAllUserTokens(id, role)

	query := `DELETE FROM users WHERE id = $1`

	result, err := d.Exec(query, id)
	if err != nil {
		return fmt.Errorf("erreur lors de la suppression de l'utilisateur: %w", err)
	}

	rowsAffected, err := result.RowsAffected()
	if err != nil {
		return fmt.Errorf("erreur lors de la vérification des lignes affectées: %w", err)
	}

	if rowsAffected == 0 {
		return fmt.Errorf("utilisateur non trouvé")
	}

	log.Printf("✅ Utilisateur supprimé (ID: %d, Role: %s)", id, role)
	return nil
}

// GetUserByID récupère un utilisateur par son ID
func (d *Database) GetUserByID(id int) (*models.User, error) {
	user := &models.User{}
	query := `SELECT id, username, password, role, created_at, updated_at 
	          FROM users WHERE id = $1`

	var createdAt, updatedAt time.Time
	err := d.QueryRow(query, id).Scan(
		&user.ID,
		&user.Username,
		&user.Password,
		&user.Role,
		&createdAt,
		&updatedAt,
	)

	if err == sql.ErrNoRows {
		return nil, fmt.Errorf("utilisateur non trouvé")
	}
	if err != nil {
		return nil, fmt.Errorf("erreur lors de la récupération de l'utilisateur: %w", err)
	}

	return user, nil
}

func (d *Database) GetUserByUsername(username string) (*models.User, error) {
	user := &models.User{}
	query := `SELECT id, username, password, role 
	          FROM users WHERE username = $1`

	err := d.QueryRow(query, username).Scan(
		&user.ID,
		&user.Username,
		&user.Password,
		&user.Role,
	)

	// ✅ Vérifier sql.ErrNoRows et retourner une erreur
	if err == sql.ErrNoRows {
		return nil, fmt.Errorf("utilisateur non trouvé")
	}

	// Autres erreurs
	if err != nil {
		return nil, fmt.Errorf("erreur lors de la récupération de l'utilisateur: %w", err)
	}

	return user, nil
}