// ============================================
// db/commands_history.go
// ============================================
// Fonctions pour l'historique des commandes terminées

package db

import (
	"fmt"
	"log"
	"maps"
	"strconv"
)

// GetCompletedCommandsByUsername récupère toutes les commandes terminées (approved) d'un utilisateur
func (d *Database) GetCompletedCommandsByUsername(username string) ([]map[string]any, error) {
	query := `
		SELECT
			id,
			client_order_id AS client_order_number,
			username,
			status,
			adresse,
			total_prix::float8 as total_prix,
			livreur_assign,
			created_at,
			updated_at
		FROM commandes
		WHERE username = ? AND status = 'approved'
		ORDER BY created_at DESC
	`

	var commands []map[string]any
	if err := d.GDB.Raw(query, username).Scan(&commands).Error; err != nil {
		log.Printf("❌ [GetCompletedCommands] Erreur query: %v", err)
		return nil, fmt.Errorf("erreur lors de la récupération des commandes terminées: %w", err)
	}
	return commands, nil
}

// GetCompletedCommandsWithItems récupère les commandes terminées avec leurs items
func (d *Database) GetCompletedCommandsWithItems(username string) ([]map[string]any, error) {
	commands, err := d.GetCompletedCommandsByUsername(username)
	if err != nil {
		return nil, err
	}

	var enrichedCommands []map[string]any

	for _, command := range commands {
		commandID, _ := strconv.Atoi(fmt.Sprintf("%v", command["id"]))
		if commandID == 0 {
			continue
		}

		items, err := d.GetCommandItems(commandID)
		if err != nil {
			log.Printf("⚠️ [GetCompletedWithItems] Erreur items pour cmd %d: %v", commandID, err)
			items = []map[string]any{}
		}

		enrichedCommand := make(map[string]any)
		maps.Copy(enrichedCommand, command)
		enrichedCommand["items"] = items
		enrichedCommand["items_count"] = len(items)

		enrichedCommands = append(enrichedCommands, enrichedCommand)
	}

	return enrichedCommands, nil
}

// GetCommandsStatsByUsername récupère les statistiques des commandes d'un utilisateur
func (d *Database) GetCommandsStatsByUsername(username string) (map[string]any, error) {
	query := `
		SELECT
			COUNT(*) FILTER (WHERE status = 'approved') as approved_count,
			COUNT(*) FILTER (WHERE status = 'pending') as pending_count,
			COUNT(*) FILTER (WHERE status = 'assigned') as assigned_count,
			COUNT(*) FILTER (WHERE status = 'en_route') as en_route_count,
			COUNT(*) FILTER (WHERE status = 'livre') as livre_count,
			COUNT(*) FILTER (WHERE status = 'cancelled') as cancelled_count,
			COUNT(*) as total_count,
			COALESCE(SUM(total_prix) FILTER (WHERE status = 'approved'), 0) as total_spent
		FROM commandes
		WHERE username = ?
	`

	var result map[string]any
	if err := d.GDB.Raw(query, username).Scan(&result).Error; err != nil {
		log.Printf("❌ [GetCommandsStats] Erreur: %v", err)
		return nil, fmt.Errorf("erreur lors de la récupération des statistiques: %w", err)
	}

	return result, nil
}

// GetCommandsByStatus récupère les commandes d'un utilisateur par statut
func (d *Database) GetCommandsByStatus(username, status string) ([]map[string]any, error) {
	log.Printf("📋 [GetCommandsByStatus] START - username=%s, status=%s", username, status)

	query := `
		SELECT
			id,
			client_order_id AS client_order_number,
			username,
			status,
			adresse,
			total_prix::float8 as total_prix,
			livreur_assign,
			created_at,
			updated_at
		FROM commandes
		WHERE username = ? AND status = ?
		ORDER BY created_at DESC
	`

	var commands []map[string]any
	if err := d.GDB.Raw(query, username, status).Scan(&commands).Error; err != nil {
		return nil, fmt.Errorf("erreur lors de la récupération des commandes: %w", err)
	}
	return commands, nil
}

// GetRecentCompletedOrders récupère les N dernières commandes terminées d'un utilisateur
func (d *Database) GetRecentCompletedOrders(username string, limit int) ([]map[string]any, error) {
	query := `
		SELECT
			id,
			client_order_id AS client_order_number,
			username,
			status,
			adresse,
			total_prix::float8 as total_prix,
			livreur_assign,
			created_at,
			updated_at
		FROM commandes
		WHERE username = ? AND status = 'approved'
		ORDER BY created_at DESC
		LIMIT ?
	`

	var commands []map[string]any
	if err := d.GDB.Raw(query, username, limit).Scan(&commands).Error; err != nil {
		log.Printf("❌ [GetRecentCompleted] Erreur query: %v", err)
		return nil, fmt.Errorf("erreur lors de la récupération: %w", err)
	}
	return commands, nil
}