todo-app-web/src/lib/api.ts

import type { 
  User, Project, Task, TaskCreate, TaskUpdate, 
  Label, Comment, Invite, Section 
} from '@/types';

const API_BASE = import.meta.env.PROD 
  ? 'https://api.todo.donovankelly.xyz/api' 
  : '/api';

const AUTH_BASE = import.meta.env.PROD
  ? 'https://api.todo.donovankelly.xyz'
  : '';

class ApiClient {
  private token: string | null = null;

  setToken(token: string | null) {
    this.token = token;
  }

  private async fetch<T>(
    path: string,
    options: RequestInit = {}
  ): Promise<T> {
    const headers: HeadersInit = {
      'Content-Type': 'application/json',
      ...options.headers,
    };

    if (this.token) {
      headers['Authorization'] = `Bearer ${this.token}`;
    }

    const response = await fetch(`${API_BASE}${path}`, {
      ...options,
      headers,
      credentials: 'include',
    });

    if (!response.ok) {
      const error = await response.json().catch(() => ({ error: 'Unknown error' }));
      throw new Error(error.error || error.details || 'Request failed');
    }

    return response.json();
  }

  // Auth
  async login(email: string, password: string) {
    const response = await fetch(`${AUTH_BASE}/api/auth/sign-in/email`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ email, password }),
      credentials: 'include',
    });
    
    if (!response.ok) {
      const error = await response.json().catch(() => ({ message: 'Login failed' }));
      throw new Error(error.message || 'Login failed');
    }
    
    return response.json();
  }

  async logout() {
    await fetch(`${AUTH_BASE}/api/auth/sign-out`, {
      method: 'POST',
      credentials: 'include',
    });
  }

  async getSession(): Promise<{ user: User } | null> {
    try {
      const response = await fetch(`${AUTH_BASE}/api/auth/get-session`, {
        credentials: 'include',
      });
      if (!response.ok) return null;
      return response.json();
    } catch {
      return null;
    }
  }

  // Invite validation (public)
  async validateInvite(token: string): Promise<{ email: string; name: string }> {
    const response = await fetch(`${AUTH_BASE}/auth/invite/${token}`);
    if (!response.ok) {
      const error = await response.json().catch(() => ({ error: 'Invalid invite' }));
      throw new Error(error.error);
    }
    return response.json();
  }

  async acceptInvite(token: string, password: string): Promise<void> {
    const response = await fetch(`${AUTH_BASE}/auth/invite/${token}/accept`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ password }),
    });
    if (!response.ok) {
      const error = await response.json().catch(() => ({ error: 'Failed to accept invite' }));
      throw new Error(error.error);
    }
  }

  // Projects
  async getProjects(): Promise<Project[]> {
    return this.fetch('/projects');
  }

  async getProject(id: string): Promise<Project> {
    return this.fetch(`/projects/${id}`);
  }

  async createProject(data: { name: string; color?: string; icon?: string }): Promise<Project> {
    return this.fetch('/projects', {
      method: 'POST',
      body: JSON.stringify(data),
    });
  }

  async updateProject(id: string, data: Partial<Project>): Promise<Project> {
    return this.fetch(`/projects/${id}`, {
      method: 'PATCH',
      body: JSON.stringify(data),
    });
  }

  async deleteProject(id: string): Promise<void> {
    await this.fetch(`/projects/${id}`, { method: 'DELETE' });
  }

  // Sections
  async createSection(projectId: string, data: { name: string; sortOrder?: number }): Promise<Section> {
    return this.fetch(`/projects/${projectId}/sections`, {
      method: 'POST',
      body: JSON.stringify(data),
    });
  }

  async updateSection(projectId: string, sectionId: string, data: Partial<Section>): Promise<Section> {
    return this.fetch(`/projects/${projectId}/sections/${sectionId}`, {
      method: 'PATCH',
      body: JSON.stringify(data),
    });
  }

  async deleteSection(projectId: string, sectionId: string): Promise<void> {
    await this.fetch(`/projects/${projectId}/sections/${sectionId}`, { method: 'DELETE' });
  }

  // Tasks
  async getTasks(params?: {
    projectId?: string;
    sectionId?: string;
    completed?: boolean;
    priority?: string;
    today?: boolean;
    upcoming?: boolean;
    overdue?: boolean;
    labelId?: string;
    includeSubtasks?: boolean;
  }): Promise<Task[]> {
    const searchParams = new URLSearchParams();
    if (params) {
      Object.entries(params).forEach(([key, value]) => {
        if (value !== undefined) {
          searchParams.set(key, String(value));
        }
      });
    }
    const query = searchParams.toString();
    return this.fetch(`/tasks${query ? `?${query}` : ''}`);
  }

  async getTask(id: string): Promise<Task> {
    return this.fetch(`/tasks/${id}`);
  }

  async createTask(data: TaskCreate): Promise<Task> {
    return this.fetch('/tasks', {
      method: 'POST',
      body: JSON.stringify(data),
    });
  }

  async updateTask(id: string, data: TaskUpdate): Promise<Task> {
    return this.fetch(`/tasks/${id}`, {
      method: 'PATCH',
      body: JSON.stringify(data),
    });
  }

  async deleteTask(id: string): Promise<void> {
    await this.fetch(`/tasks/${id}`, { method: 'DELETE' });
  }

  // Labels
  async getLabels(): Promise<Label[]> {
    return this.fetch('/labels');
  }

  async createLabel(data: { name: string; color?: string }): Promise<Label> {
    return this.fetch('/labels', {
      method: 'POST',
      body: JSON.stringify(data),
    });
  }

  async updateLabel(id: string, data: Partial<Label>): Promise<Label> {
    return this.fetch(`/labels/${id}`, {
      method: 'PATCH',
      body: JSON.stringify(data),
    });
  }

  async deleteLabel(id: string): Promise<void> {
    await this.fetch(`/labels/${id}`, { method: 'DELETE' });
  }

  // Comments
  async getComments(taskId: string): Promise<Comment[]> {
    return this.fetch(`/comments/task/${taskId}`);
  }

  async createComment(data: { taskId: string; content: string; attachments?: { name: string; url: string; type: string }[] }): Promise<Comment> {
    return this.fetch('/comments', {
      method: 'POST',
      body: JSON.stringify(data),
    });
  }

  async deleteComment(id: string): Promise<void> {
    await this.fetch(`/comments/${id}`, { method: 'DELETE' });
  }

  // Admin
  async getUsers(): Promise<User[]> {
    return this.fetch('/admin/users');
  }

  async updateUserRole(id: string, role: 'admin' | 'user' | 'service'): Promise<void> {
    await this.fetch(`/admin/users/${id}/role`, {
      method: 'PATCH',
      body: JSON.stringify({ role }),
    });
  }

  async deleteUser(id: string): Promise<void> {
    await this.fetch(`/admin/users/${id}`, { method: 'DELETE' });
  }

  async createInvite(data: { email: string; name: string; role?: 'admin' | 'user' }): Promise<Invite & { setupUrl: string }> {
    return this.fetch('/admin/invites', {
      method: 'POST',
      body: JSON.stringify(data),
    });
  }

  async getInvites(): Promise<Invite[]> {
    return this.fetch('/admin/invites');
  }

  async deleteInvite(id: string): Promise<void> {
    await this.fetch(`/admin/invites/${id}`, { method: 'DELETE' });
  }
}

export const api = new ApiClient();