import { HttpClient } from './base/http-client';
import { Tag } from '@/lib/types';
import { generateRandomTagColor, isValidTagColor } from '@/lib/tag-colors';

// Types pour les requêtes (now only used for validation - CRUD operations moved to server actions)

export interface TagFilters {
  q?: string; // Recherche par nom
  popular?: boolean; // Tags les plus utilisés
  limit?: number; // Limite de résultats
}

// Types pour les réponses
export interface TagsResponse {
  data: Array<Tag & { usage: number }>;
  message: string;
}

export interface TagResponse {
  data: Tag;
  message: string;
}

export interface PopularTag extends Tag {
  usage: number;
}

export interface PopularTagsResponse {
  data: PopularTag[];
  message: string;
}

/**
 * Client HTTP pour la gestion des tags
 */
export class TagsClient extends HttpClient {
  constructor() {
    super('/api/tags');
  }

  /**
   * Récupère tous les tags
   */
  async getTags(filters?: TagFilters): Promise<TagsResponse> {
    const params: Record<string, string> = {};

    if (filters?.q) {
      params.q = filters.q;
    }

    if (filters?.popular) {
      params.popular = 'true';
    }

    if (filters?.limit) {
      params.limit = filters.limit.toString();
    }

    return this.get<TagsResponse>(
      '',
      Object.keys(params).length > 0 ? params : undefined
    );
  }

  /**
   * Récupère les tags populaires (les plus utilisés)
   */
  async getPopularTags(limit: number = 10): Promise<PopularTagsResponse> {
    return this.get<PopularTagsResponse>('', {
      popular: 'true',
      limit: limit.toString(),
    });
  }

  /**
   * Recherche des tags par nom (pour autocomplete)
   */
  async searchTags(query: string, limit: number = 10): Promise<TagsResponse> {
    return this.get<TagsResponse>('', { q: query, limit: limit.toString() });
  }

  /**
   * Récupère un tag par son ID
   */
  async getTagById(id: string): Promise<TagResponse> {
    return this.get<TagResponse>(`/${id}`);
  }

  // CRUD operations removed - now handled by server actions in /actions/tags.ts

  /**
   * Valide le format d'une couleur hexadécimale
   */
  static isValidColor(color: string): boolean {
    return isValidTagColor(color);
  }

  /**
   * Génère une couleur aléatoire pour un nouveau tag
   */
  static generateRandomColor(): string {
    return generateRandomTagColor();
  }

  /**
   * Valide les données d'un tag (utilisé par les formulaires avant server actions)
   */
  static validateTagData(data: { name?: string; color?: string }): string[] {
    const errors: string[] = [];

    if (!data.name || typeof data.name !== 'string') {
      errors.push('Le nom du tag est requis');
    } else if (data.name.trim().length === 0) {
      errors.push('Le nom du tag ne peut pas être vide');
    } else if (data.name.length > 50) {
      errors.push('Le nom du tag ne peut pas dépasser 50 caractères');
    }

    if (!data.color || typeof data.color !== 'string') {
      errors.push('La couleur du tag est requise');
    } else if (!this.isValidColor(data.color)) {
      errors.push('La couleur doit être au format hexadécimal (#RRGGBB)');
    }

    return errors;
  }
}

// Instance singleton
export const tagsClient = new TagsClient();
