noteflow/src/services/NotesService.ts

import AuthService from "./AuthService";
import { showError, showSuccess } from "@/utils/toast";

interface Todo {
  id?: number;
  text: string;
  completed: boolean;
  position?: number;
  due_date?: string;
  parent_id?: number;
  level?: number;
}

interface Image {
  id?: number;
  filename: string;
  original_name?: string;
}

interface NoteFile {
  id?: number;
  filename: string;
  original_name?: string;
  size?: number;
}

export interface Note {
  id?: number;
  title: string;
  content: string;
  archived?: boolean;
  created_via?: 'web' | 'api';
  created_at?: string;
  updated_at?: string;
  todos: Todo[];
  images: Image[];
  files?: NoteFile[];
  tags?: Array<{ id: number; name: string }>;
  priority?: boolean;
}

class NotesService {
  async getNotes(archived: boolean = false): Promise<Note[]> {
    try {
      const response = await fetch(`/api/notes?archived=${archived}`, {
        headers: AuthService.getHeaders()
      });

      if (!response.ok) {
        throw new Error("Erreur lors de la récupération des notes");
      }

      const notes = await response.json();

      // Ensure todos and images are always arrays
      return notes.map((note: Note) => ({
        ...note,
        todos: note.todos || [],
        images: note.images || []
      }));
    } catch (error) {
      showError(error instanceof Error ? error.message : "Erreur serveur");
      return [];
    }
  }

  async getCounts(): Promise<{ active: number; archived: number }> {
    try {
      const response = await fetch("/api/notes/counts", {
        headers: AuthService.getHeaders()
      });

      if (!response.ok) {
        throw new Error("Erreur lors de la récupération des compteurs");
      }

      return await response.json();
    } catch (error) {
      console.error("Erreur compteur:", error);
      return { active: 0, archived: 0 };
    }
  }

  async createNote(title: string, content: string = ""): Promise<Note | null> {
    try {
      const response = await fetch("/api/notes", {
        method: "POST",
        headers: AuthService.getHeaders(),
        body: JSON.stringify({ title, content, todos: [] })
      });

      if (!response.ok) {
        throw new Error("Erreur lors de la création de la note");
      }

      showSuccess("Note créée avec succès");
      const note = await response.json();
      return {
        ...note,
        todos: note.todos || [],
        images: note.images || []
      };
    } catch (error) {
      showError(error instanceof Error ? error.message : "Erreur serveur");
      return null;
    }
  }

  async updateNote(note: Note): Promise<Note | null> {
    if (!note.id) return null;

    try {
      const response = await fetch(`/api/notes/${note.id}`, {
        method: "PUT",
        headers: AuthService.getHeaders(),
        body: JSON.stringify({
          ...note,
          todos: note.todos || [],
          images: note.images || []
        })
      });

      if (!response.ok) {
        throw new Error("Erreur lors de la mise à jour de la note");
      }

      const result = await response.json();
      // Le backend retourne { message, note } avec la note mise à jour incluant updated_at
      if (result.note) {
        return {
          ...note, // Garder les todos et images de l'état local
          ...result.note // Écraser avec les données du serveur (updated_at, etc.)
        };
      }

      return note; // Fallback si le backend ne retourne pas la note
    } catch (error) {
      showError(error instanceof Error ? error.message : "Erreur serveur");
      return null;
    }
  }

  async deleteNote(noteId: number): Promise<boolean> {
    try {
      const response = await fetch(`/api/notes/${noteId}`, {
        method: "DELETE",
        headers: AuthService.getHeaders()
      });

      if (!response.ok) {
        throw new Error("Erreur lors de la suppression de la note");
      }

      showSuccess("Note supprimée avec succès");
      return true;
    } catch (error) {
      showError(error instanceof Error ? error.message : "Erreur serveur");
      return false;
    }
  }

  async uploadImage(noteId: number, file: File): Promise<Image | null> {
    const formData = new FormData();
    formData.append("image", file);

    try {
      const response = await fetch(`/api/notes/${noteId}/images`, {
        method: "POST",
        headers: {
          "Authorization": AuthService.getHeaders().Authorization
        },
        body: formData
      });

      if (!response.ok) {
        throw new Error("Erreur lors de l'upload de l'image");
      }

      const result = await response.json();
      return result.image || result;
    } catch (error) {
      showError(error instanceof Error ? error.message : "Erreur serveur");
      return null;
    }
  }

  async deleteImage(noteId: number, imageId: number): Promise<boolean> {
    try {
      const response = await fetch(`/api/notes/${noteId}/images/${imageId}`, {
        method: "DELETE",
        headers: AuthService.getHeaders()
      });

      if (!response.ok) {
        throw new Error("Erreur lors de la suppression de l'image");
      }

      return true;
    } catch (error) {
      showError(error instanceof Error ? error.message : "Erreur serveur");
      return false;
    }
  }

  async togglePriority(noteId: number, priority: boolean): Promise<boolean> {
    try {
      const response = await fetch(`/api/notes/${noteId}/priority`, {
        method: "PATCH",
        headers: AuthService.getHeaders(),
        body: JSON.stringify({ priority })
      });

      if (!response.ok) {
        throw new Error("Erreur lors de la mise à jour de la priorité");
      }

      return true;
    } catch (error) {
      showError(error instanceof Error ? error.message : "Erreur serveur");
      return false;
    }
  }

  async archiveNote(noteId: number, archived: boolean): Promise<boolean> {
    try {
      const response = await fetch(`/api/notes/${noteId}/archive`, {
        method: "PUT",
        headers: AuthService.getHeaders(),
        body: JSON.stringify({ archived })
      });

      if (!response.ok) {
        throw new Error("Erreur lors de l'archivage de la note");
      }

      showSuccess(archived ? "Note archivée" : "Note désarchivée");
      return true;
    } catch (error) {
      showError(error instanceof Error ? error.message : "Erreur serveur");
      return false;
    }
  }

  // Todo management methods
  async addTodo(noteId: number, text: string, dueDate?: string): Promise<Todo | null> {
    try {
      const payload: any = { text };
      if (dueDate) {
        payload.due_date = dueDate;
      }

      const response = await fetch(`/api/notes/${noteId}/todos`, {
        method: "POST",
        headers: AuthService.getHeaders(),
        body: JSON.stringify(payload)
      });

      if (!response.ok) {
        throw new Error("Erreur lors de l'ajout de la tâche");
      }

      const result = await response.json();
      showSuccess("Tâche ajoutée");
      return result.todo || result;
    } catch (error) {
      showError(error instanceof Error ? error.message : "Erreur serveur");
      return null;
    }
  }

  async updateTodo(todoId: number, updates: Partial<Todo>): Promise<Todo | null> {
    try {
      const response = await fetch(`/api/notes/todos/${todoId}`, {
        method: "PUT",
        headers: AuthService.getHeaders(),
        body: JSON.stringify(updates)
      });

      if (!response.ok) {
        throw new Error("Erreur lors de la mise à jour de la tâche");
      }

      const result = await response.json();
      return result.todo || result;
    } catch (error) {
      showError(error instanceof Error ? error.message : "Erreur serveur");
      return null;
    }
  }

  async toggleTodo(todoId: number, completed: boolean): Promise<boolean> {
    try {
      const response = await fetch(`/api/notes/todos/${todoId}`, {
        method: "PUT",
        headers: AuthService.getHeaders(),
        body: JSON.stringify({ completed })
      });

      if (!response.ok) {
        throw new Error("Erreur lors de la mise à jour de la tâche");
      }

      return true;
    } catch (error) {
      showError(error instanceof Error ? error.message : "Erreur serveur");
      return false;
    }
  }

  async deleteTodo(todoId: number): Promise<boolean> {
    try {
      const response = await fetch(`/api/notes/todos/${todoId}`, {
        method: "DELETE",
        headers: AuthService.getHeaders()
      });

      if (!response.ok) {
        throw new Error("Erreur lors de la suppression de la tâche");
      }

      return true;
    } catch (error) {
      showError(error instanceof Error ? error.message : "Erreur serveur");
      return false;
    }
  }

  /**
   * Créer une note complète avec titre, contenu, tâches et tags en une seule requête
   */
  async createNoteFull(data: {
    title: string;
    content?: string;
    todos?: Array<{
      text: string;
      completed?: boolean;
      priority?: boolean;
      subtasks?: Array<{ text: string; completed?: boolean; priority?: boolean }>;
    }>;
    tags?: string[];
  }): Promise<Note | null> {
    try {
      const response = await fetch("/api/notes/full", {
        method: "POST",
        headers: AuthService.getHeaders(),
        body: JSON.stringify(data)
      });

      if (!response.ok) {
        const error = await response.json();
        throw new Error(error.error || "Erreur lors de la création de la note");
      }

      showSuccess("Note créée avec succès");
      const note = await response.json();
      return {
        ...note,
        todos: note.todos || [],
        images: note.images || [],
        tags: note.tags || []
      };
    } catch (error) {
      showError(error instanceof Error ? error.message : "Erreur serveur");
      return null;
    }
  }

  /**
   * Mettre à jour une note complète avec titre, contenu, tâches et tags
   * @param replace_todos - Si true, remplace toutes les tâches existantes
   * @param replace_tags - Si true, remplace tous les tags existants
   */
  async updateNoteFull(
    noteId: number,
    data: {
      title?: string;
      content?: string;
      todos?: Array<{
        text: string;
        completed?: boolean;
        priority?: boolean;
        subtasks?: Array<{ text: string; completed?: boolean; priority?: boolean }>;
      }>;
      tags?: string[];
      replace_todos?: boolean;
      replace_tags?: boolean;
    }
  ): Promise<Note | null> {
    try {
      const response = await fetch(`/api/notes/${noteId}/full`, {
        method: "PUT",
        headers: AuthService.getHeaders(),
        body: JSON.stringify(data)
      });

      if (!response.ok) {
        const error = await response.json();
        throw new Error(error.error || "Erreur lors de la mise à jour de la note");
      }

      const result = await response.json();
      showSuccess("Note mise à jour avec succès");

      if (result.note) {
        return {
          ...result.note,
          todos: result.note.todos || [],
          images: result.note.images || [],
          tags: result.note.tags || []
        };
      }
      return null;
    } catch (error) {
      showError(error instanceof Error ? error.message : "Erreur serveur");
      return null;
    }
  }

  /**
   * Ajouter plusieurs tâches à une note en une seule requête
   */
  async addTodosBatch(
    noteId: number,
    todos: Array<{
      text: string;
      completed?: boolean;
      priority?: boolean;
      subtasks?: Array<{ text: string; completed?: boolean; priority?: boolean }>;
    }>
  ): Promise<Todo[] | null> {
    try {
      const response = await fetch(`/api/notes/${noteId}/todos/batch`, {
        method: "POST",
        headers: AuthService.getHeaders(),
        body: JSON.stringify({ todos })
      });

      if (!response.ok) {
        const error = await response.json();
        throw new Error(error.error || "Erreur lors de l'ajout des tâches");
      }

      const result = await response.json();
      showSuccess(`${result.todos?.length || 0} tâche(s) ajoutée(s)`);
      return result.todos || [];
    } catch (error) {
      showError(error instanceof Error ? error.message : "Erreur serveur");
      return null;
    }
  }
}

export default new NotesService();