towercontrol/services/user-preferences.ts

import { TaskStatus, KanbanFilters, ViewPreferences, ColumnVisibility, UserPreferences } from '@/lib/types';
import { prisma } from './database';

// Valeurs par défaut
const DEFAULT_PREFERENCES: UserPreferences = {
  kanbanFilters: {
    search: '',
    tags: [],
    priorities: [],
    showCompleted: true,
    sortBy: ''
  },
  viewPreferences: {
    compactView: false,
    swimlanesByTags: false,
    swimlanesMode: 'tags',
    showObjectives: true,
    showFilters: true,
    objectivesCollapsed: false,
    theme: 'dark'
  },
  columnVisibility: {
    hiddenStatuses: []
  }
};

/**
 * Service pour gérer les préférences utilisateur en base de données
 */
class UserPreferencesService {
  private readonly USER_ID = 'default'; // Pour l'instant, un seul utilisateur

  /**
   * Récupère ou crée l'entrée user preferences (avec upsert pour éviter les doublons)
   */
  private async getOrCreateUserPreferences() {
    // Utiliser upsert pour éviter les conditions de course
    const userPrefs = await prisma.userPreferences.upsert({
      where: { id: 'default' }, // ID fixe pour l'utilisateur unique
      update: {}, // Ne rien mettre à jour si existe
      create: {
        id: 'default',
        kanbanFilters: DEFAULT_PREFERENCES.kanbanFilters,
        viewPreferences: DEFAULT_PREFERENCES.viewPreferences,
        columnVisibility: DEFAULT_PREFERENCES.columnVisibility,
      }
    });
    
    return userPrefs;
  }

  // === FILTRES KANBAN ===
  
  /**
   * Sauvegarde les filtres Kanban
   */
  async saveKanbanFilters(filters: KanbanFilters): Promise<void> {
    try {
      const userPrefs = await this.getOrCreateUserPreferences();
      await prisma.userPreferences.update({
        where: { id: userPrefs.id },
        data: { kanbanFilters: filters }
      });
    } catch (error) {
      console.warn('Erreur lors de la sauvegarde des filtres Kanban:', error);
      throw error;
    }
  }

  /**
   * Récupère les filtres Kanban
   */
  async getKanbanFilters(): Promise<KanbanFilters> {
    try {
      const userPrefs = await this.getOrCreateUserPreferences();
      const filters = userPrefs.kanbanFilters as KanbanFilters | null;
      return { ...DEFAULT_PREFERENCES.kanbanFilters, ...(filters || {}) };
    } catch (error) {
      console.warn('Erreur lors de la récupération des filtres Kanban:', error);
      return DEFAULT_PREFERENCES.kanbanFilters;
    }
  }

  // === PRÉFÉRENCES DE VUE ===

  /**
   * Sauvegarde les préférences de vue
   */
  async saveViewPreferences(preferences: ViewPreferences): Promise<void> {
    try {
      const userPrefs = await this.getOrCreateUserPreferences();
      await prisma.userPreferences.update({
        where: { id: userPrefs.id },
        data: { viewPreferences: preferences }
      });
    } catch (error) {
      console.warn('Erreur lors de la sauvegarde des préférences de vue:', error);
      throw error;
    }
  }

  /**
   * Récupère les préférences de vue
   */
  async getViewPreferences(): Promise<ViewPreferences> {
    try {
      const userPrefs = await this.getOrCreateUserPreferences();
      const preferences = userPrefs.viewPreferences as ViewPreferences | null;
      return { ...DEFAULT_PREFERENCES.viewPreferences, ...(preferences || {}) };
    } catch (error) {
      console.warn('Erreur lors de la récupération des préférences de vue:', error);
      return DEFAULT_PREFERENCES.viewPreferences;
    }
  }

  // === VISIBILITÉ DES COLONNES ===

  /**
   * Sauvegarde la visibilité des colonnes
   */
  async saveColumnVisibility(visibility: ColumnVisibility): Promise<void> {
    try {
      const userPrefs = await this.getOrCreateUserPreferences();
      await prisma.userPreferences.update({
        where: { id: userPrefs.id },
        data: { columnVisibility: visibility }
      });
    } catch (error) {
      console.warn('Erreur lors de la sauvegarde de la visibilité des colonnes:', error);
      throw error;
    }
  }

  /**
   * Récupère la visibilité des colonnes
   */
  async getColumnVisibility(): Promise<ColumnVisibility> {
    try {
      const userPrefs = await this.getOrCreateUserPreferences();
      const visibility = userPrefs.columnVisibility as ColumnVisibility | null;
      return { ...DEFAULT_PREFERENCES.columnVisibility, ...(visibility || {}) };
    } catch (error) {
      console.warn('Erreur lors de la récupération de la visibilité des colonnes:', error);
      return DEFAULT_PREFERENCES.columnVisibility;
    }
  }

  // === MÉTHODES GLOBALES ===

  /**
   * Récupère toutes les préférences utilisateur
   */
  async getAllPreferences(): Promise<UserPreferences> {
    const [kanbanFilters, viewPreferences, columnVisibility] = await Promise.all([
      this.getKanbanFilters(),
      this.getViewPreferences(),
      this.getColumnVisibility()
    ]);

    return {
      kanbanFilters,
      viewPreferences,
      columnVisibility
    };
  }

  /**
   * Sauvegarde toutes les préférences utilisateur
   */
  async saveAllPreferences(preferences: UserPreferences): Promise<void> {
    await Promise.all([
      this.saveKanbanFilters(preferences.kanbanFilters),
      this.saveViewPreferences(preferences.viewPreferences),
      this.saveColumnVisibility(preferences.columnVisibility)
    ]);
  }

  /**
   * Remet à zéro toutes les préférences
   */
  async resetAllPreferences(): Promise<void> {
    try {
      const userPrefs = await this.getOrCreateUserPreferences();
      await prisma.userPreferences.update({
        where: { id: userPrefs.id },
        data: {
          kanbanFilters: DEFAULT_PREFERENCES.kanbanFilters,
          viewPreferences: DEFAULT_PREFERENCES.viewPreferences,
          columnVisibility: DEFAULT_PREFERENCES.columnVisibility,
        }
      });
    } catch (error) {
      console.warn('Erreur lors de la remise à zéro des préférences:', error);
      throw error;
    }
  }

  // === MÉTHODES UTILITAIRES ===

  /**
   * Met à jour partiellement les filtres Kanban
   */
  async updateKanbanFilters(updates: Partial<KanbanFilters>): Promise<void> {
    const current = await this.getKanbanFilters();
    await this.saveKanbanFilters({ ...current, ...updates });
  }

  /**
   * Met à jour partiellement les préférences de vue
   */
  async updateViewPreferences(updates: Partial<ViewPreferences>): Promise<void> {
    const current = await this.getViewPreferences();
    await this.saveViewPreferences({ ...current, ...updates });
  }

  /**
   * Met à jour la visibilité d'une colonne spécifique
   */
  async toggleColumnVisibility(status: TaskStatus): Promise<void> {
    const current = await this.getColumnVisibility();
    const hiddenStatuses = new Set(current.hiddenStatuses);
    
    if (hiddenStatuses.has(status)) {
      hiddenStatuses.delete(status);
    } else {
      hiddenStatuses.add(status);
    }
    
    await this.saveColumnVisibility({
      hiddenStatuses: Array.from(hiddenStatuses)
    });
  }
}

// Export de l'instance singleton
export const userPreferencesService = new UserPreferencesService();