import { create } from 'zustand';
import { invoke } from '@tauri-apps/api/core';
import { useTimerStore } from './timerStore';

export interface Task {
  id: string;
  name: string;
  total_sessions: number;
  remaining_sessions: number;
  completed: boolean;
  created_at: string;
}

interface TaskStore {
  tasks: Task[];
  loading: boolean;
  fetchTasks: () => Promise<void>;
  addTask: (name: string, totalSessions: number) => Promise<void>;
  updateTask: (id: string, remainingSessions?: number, completed?: boolean) => Promise<void>;
  deleteTask: (id: string) => Promise<void>;
  setCurrentTask: (id: string | null) => Promise<void>;
}

export const useTaskStore = create<TaskStore>((set) => ({
  tasks: [],
  loading: false,

  fetchTasks: async () => {
    set({ loading: true });
    try {
      const tasks = await invoke<Task[]>('get_tasks');
      set({ tasks, loading: false });
    } catch (e) {
      console.error('fetchTasks error:', e);
      set({ loading: false });
    }
  },

  addTask: async (name, totalSessions) => {
    try {
      const task = await invoke<Task>('add_task', {
        name,
        totalSessions,
      });
      set((state) => ({ tasks: [...state.tasks, task] }));
    } catch (e) {
      console.error('addTask error:', e);
      throw e;
    }
  },

  updateTask: async (id, remainingSessions, completed) => {
    await invoke('update_task', {
      id,
      remainingSessions: remainingSessions ?? null,
      completed: completed ?? null,
    });
    set((state) => ({
      tasks: state.tasks.map((t) =>
        t.id === id
          ? {
              ...t,
              remaining_sessions: remainingSessions ?? t.remaining_sessions,
              completed: completed ?? t.completed,
            }
          : t,
      ),
    }));
  },

  deleteTask: async (id) => {
    try {
      await invoke('delete_task', { id });
      set((state) => ({ tasks: state.tasks.filter((t) => t.id !== id) }));
    } catch (e) {
      console.error('deleteTask error:', e);
      throw e;
    }
  },

  setCurrentTask: async (id) => {
    await invoke('set_current_task', { taskId: id });
    useTimerStore.getState().setCurrentTaskId(id);
    try {
      await useTimerStore.getState().syncFromBackend();
    } catch (e) {
      console.error('syncFromBackend after set_current_task error:', e);
    }
  },
}));