Cloudtopiaa_Reseller_Frontend/src/services/knowledgeService.ts

import {
  KnowledgeArticle,
  KnowledgeCategory,
  KnowledgeSearchParams,
  KnowledgeSearchResponse,
  CreateArticleData,
  UpdateArticleData,
  CreateCategoryData,
  FeedbackData
} from '../types/knowledge';

const API_BASE_URL = process.env.REACT_APP_API_URL || 'http://localhost:5000/api';

class KnowledgeService {
  private baseUrl = `${API_BASE_URL}/knowledge`;

  private async request<T>(endpoint: string, options: RequestInit = {}): Promise<T> {
    const url = `${this.baseUrl}${endpoint}`;
    
    const config: RequestInit = {
      headers: {
        'Content-Type': 'application/json',
        ...options.headers,
      },
      ...options,
    };

    // Add auth token if available
    const token = localStorage.getItem('accessToken');
    if (token) {
      config.headers = {
        ...config.headers,
        Authorization: `Bearer ${token}`,
      };
    }

    try {
      const response = await fetch(url, config);
      const data = await response.json();

      if (!response.ok) {
        throw new Error(data.message || 'API request failed');
      }

      return data;
    } catch (error) {
      console.error('API request failed:', error);
      throw error;
    }
  }

  // Articles
  async getArticles(params: KnowledgeSearchParams = {}): Promise<KnowledgeSearchResponse> {
    const searchParams = new URLSearchParams();
    
    Object.entries(params).forEach(([key, value]) => {
      if (value !== undefined && value !== null) {
        if (Array.isArray(value)) {
          value.forEach(v => searchParams.append(key, v));
        } else {
          searchParams.append(key, String(value));
        }
      }
    });

    const response = await this.request<KnowledgeSearchResponse>(`/articles?${searchParams.toString()}`);
    return response;
  }

  async getArticleBySlug(slug: string): Promise<{ data: KnowledgeArticle }> {
    const response = await this.request<{ data: KnowledgeArticle }>(`/articles/${slug}`);
    return response;
  }

  async createArticle(data: CreateArticleData): Promise<{ data: KnowledgeArticle; message: string }> {
    const response = await this.request<{ data: KnowledgeArticle; message: string }>('/articles', {
      method: 'POST',
      body: JSON.stringify(data)
    });
    return response;
  }

  async updateArticle(id: number, data: UpdateArticleData): Promise<{ data: KnowledgeArticle; message: string }> {
    const response = await this.request<{ data: KnowledgeArticle; message: string }>(`/articles/${id}`, {
      method: 'PUT',
      body: JSON.stringify(data)
    });
    return response;
  }

  async deleteArticle(id: number): Promise<{ message: string }> {
    const response = await this.request<{ message: string }>(`/articles/${id}`, {
      method: 'DELETE'
    });
    return response;
  }

  async publishArticle(id: number): Promise<{ data: KnowledgeArticle; message: string }> {
    const response = await this.request<{ data: KnowledgeArticle; message: string }>(`/articles/${id}/publish`, {
      method: 'PATCH'
    });
    return response;
  }

  // Categories
  async getCategories(params: { parentId?: number; visibility?: string } = {}): Promise<{ data: KnowledgeCategory[] }> {
    const searchParams = new URLSearchParams();
    
    Object.entries(params).forEach(([key, value]) => {
      if (value !== undefined && value !== null) {
        searchParams.append(key, String(value));
      }
    });

    const response = await this.request<{ data: KnowledgeCategory[] }>(`/categories?${searchParams.toString()}`);
    return response;
  }

  async createCategory(data: CreateCategoryData): Promise<{ data: KnowledgeCategory; message: string }> {
    const response = await this.request<{ data: KnowledgeCategory; message: string }>('/categories', {
      method: 'POST',
      body: JSON.stringify(data)
    });
    return response;
  }

  // Search
  async searchArticles(query: string, page: number = 1, limit: number = 10): Promise<KnowledgeSearchResponse> {
    const response = await this.request<KnowledgeSearchResponse>(`/articles/search?q=${encodeURIComponent(query)}&page=${page}&limit=${limit}`);
    return response;
  }

  // Feedback
  async submitFeedback(articleId: number, data: FeedbackData): Promise<{ message: string }> {
    const response = await this.request<{ message: string }>(`/articles/${articleId}/feedback`, {
      method: 'POST',
      body: JSON.stringify(data)
    });
    return response;
  }
}

export const knowledgeService = new KnowledgeService();
export default knowledgeService;