interface Task {
  id: string;                           // UUID
  title: string;                        // Task title (sanitized)
  description?: string;                 // Optional description
  status: TaskStatus;                   // 'pending' | 'in_progress' | 'completed'
  priority: TaskPriority;               // 'urgent' | 'high' | 'medium' | 'low'
  dueDate?: string;                     // ISO date string
  isRecurring: boolean;                 // Recurring task flag
  recurringPattern?: RecurringPattern;  // Recurrence configuration
  pomodorosEstimated?: number;          // Estimated pomodoros
  pomodorosCompleted: number;           // Completed pomodoros
  createdAt: string;                    // ISO timestamp
  completedAt?: string;                 // ISO timestamp when completed
  subtasks: Subtask[];                  // Array of subtasks
}

interface Subtask {
  id: string;           // UUID
  title: string;        // Subtask title
  isCompleted: boolean; // Completion status
}

type TaskStatus = 'pending' | 'in_progress' | 'completed';

type TaskPriority = 'urgent' | 'high' | 'medium' | 'low';

interface RecurringPattern {
  frequency: 'daily' | 'weekly' | 'monthly';
  interval?: number;        // Every N days/weeks/months
  daysOfWeek?: number[];    // For weekly: [0-6] (Sunday=0)
  endDate?: string;         // ISO date string
}

import { useTaskStore } from '@/stores/useTaskStore';

// Fetch latest 50 tasks
await useTaskStore.getState().fetchTasks();

// Fetch specific limit
await useTaskStore.getState().fetchTasks(100);

SELECT tasks.*, subtasks.*
FROM tasks
LEFT JOIN subtasks ON subtasks.task_id = tasks.id
WHERE user_id = $1
ORDER BY created_at DESC
LIMIT $2;

// Simple task
await useTaskStore.getState().addTask('Complete Math homework');

// Task with options
await useTaskStore.getState().addTask('Study for exam', {
  priority: 'urgent',
  dueDate: '2026-03-15',
  isRecurring: false
});

// Recurring task
await useTaskStore.getState().addTask('Daily review', {
  priority: 'medium',
  isRecurring: true,
  recurringPattern: {
    frequency: 'daily',
    interval: 1
  }
});

await useTaskStore.getState().updateTask('task-uuid', {
  title: 'Updated title',
  priority: 'high',
  dueDate: '2026-03-20'
});

await useTaskStore.getState().deleteTask('task-uuid');

await useTaskStore.getState().toggleTaskStatus('task-uuid');

if (nextStatus === 'completed' && task.isRecurring && task.recurringPattern) {
  const nextDate = calculateNextDueDate(baseDate, task.recurringPattern);
  // Creates new task with:
  // - Same title, priority, pattern
  // - Status: 'pending'
  // - New UUID
  // - Reset subtasks (all uncompleted)
  // - New dueDate
}

await useTaskStore.getState().addSubtask('task-uuid', 'Read chapter 1');

await useTaskStore.getState().toggleSubtask('task-uuid', 'subtask-uuid');

await useTaskStore.getState().deleteSubtask('task-uuid', 'subtask-uuid');

useTaskStore.getState().setFilter('pending');    // Show only pending
useTaskStore.getState().setFilter('completed');  // Show only completed
useTaskStore.getState().setFilter('all');        // Show all tasks

useTaskStore.getState().setSortBy('priority');   // Sort by priority
useTaskStore.getState().setSortBy('dueDate');    // Sort by due date
useTaskStore.getState().setSortBy('createdAt');  // Sort by creation date

const PRIORITY_ORDER = {
  urgent: 0,
  high: 1,
  medium: 2,
  low: 3
};

const filteredTasks = useTaskStore.getState().getFilteredTasks();

const { tasks, filter, sortBy, isLoading } = useTaskStore();

console.log(`Showing ${tasks.length} tasks`);
console.log(`Filter: ${filter}, Sort: ${sortBy}`);

create table tasks (
  id uuid default gen_random_uuid() primary key,
  user_id uuid references profiles(id) on delete cascade not null,
  subject_id uuid references subjects(id) on delete set null,
  goal_id uuid references goals(id) on delete set null,
  
  title text not null,
  description text,
  status task_status default 'pending',
  priority task_priority default 'medium',
  due_date timestamp with time zone,
  
  is_recurring boolean default false,
  recurrence_pattern jsonb,
  
  pomodoros_estimated int default 0,
  pomodoros_completed int default 0,
  
  created_at timestamp with time zone default now(),
  updated_at timestamp with time zone default now(),
  completed_at timestamp with time zone
);

create table subtasks (
  id uuid default gen_random_uuid() primary key,
  task_id uuid references tasks(id) on delete cascade not null,
  title text not null,
  is_completed boolean default false
);

-- Users can only access their own tasks
create policy "Usuarios gestionan sus tareas" 
  on tasks for all 
  using ( auth.uid() = user_id );

-- Subtasks inherit task permissions
create policy "Usuarios gestionan sus subtareas" 
  on subtasks for all 
  using ( 
    exists (
      select 1 from tasks 
      where id = subtasks.task_id 
        and user_id = auth.uid()
    )
  );

// Increment completed pomodoros
const task = useTaskStore.getState().tasks.find(t => t.id === 'task-uuid');
if (task) {
  await useTaskStore.getState().updateTask(task.id, {
    pomodorosCompleted: task.pomodorosCompleted + 1
  });
}

SELECT increment_task_pomodoros('task-uuid');

if (nextStatus === 'completed') {
  const totalCompleted = tasks.filter(t => t.status === 'completed').length;
  
  // Dynamic import to avoid circular dependencies
  const { useAchievementsStore } = await import('./useAchievementsStore');
  useAchievementsStore.getState().checkAndUnlock('task_complete', { 
    count: totalCompleted 
  });
}

{
  name: 'focus-tasks-storage',
  storage: localStorage
}

import { useTaskStore } from '@/stores/useTaskStore';
import { useEffect } from 'react';

function TaskList() {
  const { fetchTasks, getFilteredTasks, toggleTaskStatus, isLoading } = useTaskStore();

  useEffect(() => {
    fetchTasks();
  }, [fetchTasks]);

  const tasks = getFilteredTasks();

  if (isLoading) return <div>Loading tasks...</div>;

  return (
    <ul>
      {tasks.map(task => (
        <li key={task.id}>
          <button onClick={() => toggleTaskStatus(task.id)}>
            {task.status === 'completed' ? '✓' : '○'}
          </button>
          <span>{task.title}</span>
          <span>Priority: {task.priority}</span>
          <span>Subtasks: {task.subtasks.filter(st => st.isCompleted).length}/{task.subtasks.length}</span>
        </li>
      ))}
    </ul>
  );
}