Referencia de API

interface Task {
  id: string; // Identificador único
  text: string; // Descripción de la tarea
  completed: boolean; // Estado de finalización
  dueDate?: string; // Fecha límite opcional (formato ISO)
  priority: "low" | "medium" | "high"; // Nivel de prioridad
  createdAt: Date; // Marca de tiempo de creación
  completedAt?: Date; // Marca de tiempo de finalización (si está completada)
}

interface HistoryRecord {
  id: string; // Identificador único
  action: "created" | "completed" | "deleted" | "updated";
  description: string; // Descripción legible
  timestamp: Date; // Marca de tiempo de la acción
}

// Guardar tareas en almacenamiento local
localStorage.setItem("todo-tasks", JSON.stringify(tasks));

// Cargar tareas desde almacenamiento local
const tasks = JSON.parse(localStorage.getItem("todo-tasks") || "[]");

// Guardar historial en almacenamiento local
localStorage.setItem("todo-history", JSON.stringify(history));

// Cargar historial desde almacenamiento local
const history = JSON.parse(localStorage.getItem("todo-history") || "[]");

{
  "tasks": [
    {
      "id": "abc123",
      "text": "Complete project",
      "completed": false,
      "dueDate": "2024-02-15",
      "priority": "high",
      "createdAt": "2024-02-01T10:00:00.000Z",
      "completedAt": null
    }
  ],
  "exportDate": "2024-02-01T10:00:00.000Z"
}

function validateImportData(data) {
  if (!data.tasks || !Array.isArray(data.tasks)) {
    throw new Error("Invalid data format: tasks array required");
  }

  data.tasks.forEach((task) => {
    if (!task.id || !task.text || typeof task.completed !== "boolean") {
      throw new Error("Invalid task format");
    }
  });

  return true;
}

// Tarea creada
window.dispatchEvent(
  new CustomEvent("taskCreated", {
    detail: { task: newTask },
  }),
);

// Tarea completada
window.dispatchEvent(
  new CustomEvent("taskCompleted", {
    detail: { task: completedTask },
  }),
);

// Tarea actualizada
window.dispatchEvent(
  new CustomEvent("taskUpdated", {
    detail: { task: updatedTask },
  }),
);

// Tarea eliminada
window.dispatchEvent(
  new CustomEvent("taskDeleted", {
    detail: { taskId: deletedTaskId },
  }),
);

// Registro de historial añadido
window.dispatchEvent(
  new CustomEvent("historyAdded", {
    detail: { record: newRecord },
  }),
);

function generateId() {
  return Math.random().toString(36).substr(2, 9);
}

function getTomorrow() {
  const tomorrow = new Date();
  tomorrow.setDate(tomorrow.getDate() + 1);
  return tomorrow.toISOString().split("T")[0];
}

function isOverdue(dueDate) {
  return new Date(dueDate) < new Date();
}

function formatDate(date) {
  return new Intl.DateTimeFormat("en-US", {
    year: "numeric",
    month: "short",
    day: "numeric",
  }).format(new Date(date));
}

function formatTimeAgo(date) {
  const now = new Date();
  const diff = now.getTime() - date.getTime();
  const minutes = Math.floor(diff / 60000);
  const hours = Math.floor(diff / 3600000);
  const days = Math.floor(diff / 86400000);

  if (days > 0) return `${days} days ago`;
  if (hours > 0) return `${hours} hours ago`;
  if (minutes > 0) return `${minutes} minutes ago`;
  return "Just now";
}

function sortTasks(tasks) {
  return tasks.sort((a, b) => {
    // Nivel de prioridadソート
    const priorityOrder = { high: 3, medium: 2, low: 1 };
    const priorityDiff = priorityOrder[b.priority] - priorityOrder[a.priority];
    if (priorityDiff !== 0) return priorityDiff;

    // Ordenación por fecha límite
    if (a.dueDate && b.dueDate) {
      return new Date(a.dueDate).getTime() - new Date(b.dueDate).getTime();
    }
    if (a.dueDate) return -1;
    if (b.dueDate) return 1;

    // Ordenación por fecha de creación
    return b.createdAt.getTime() - a.createdAt.getTime();
  });
}

try {
  const tasks = JSON.parse(localStorage.getItem("todo-tasks"));
} catch (error) {
  console.error("Failed to load tasks:", error);
  // Fallback a array vacío
  tasks = [];
}

function validateTask(task) {
  const errors = [];

  if (!task.text || task.text.trim().length === 0) {
    errors.push("Task text is required");
  }

  if (!["low", "medium", "high"].includes(task.priority)) {
    errors.push("Invalid priority level");
  }

  if (task.dueDate && isNaN(Date.parse(task.dueDate))) {
    errors.push("Invalid due date format");
  }

  return errors;
}

// Paginación para listas grandes
function getTasksPage(tasks, page = 1, pageSize = 50) {
  const start = (page - 1) * pageSize;
  const end = start + pageSize;
  return tasks.slice(start, end);
}

// Soporte de desplazamiento virtual
function getVisibleTasks(tasks, scrollTop, viewportHeight, itemHeight) {
  const startIndex = Math.floor(scrollTop / itemHeight);
  const visibleCount = Math.ceil(viewportHeight / itemHeight);
  return tasks.slice(startIndex, startIndex + visibleCount);
}

// Limitar registros de historial
function addHistoryRecord(history, record, maxRecords = 100) {
  history.unshift(record);
  if (history.length > maxRecords) {
    history = history.slice(0, maxRecords);
  }
  return history;
}

// Limpiar tareas completadas antiguas
function cleanupOldTasks(tasks, daysToKeep = 30) {
  const cutoff = new Date();
  cutoff.setDate(cutoff.getDate() - daysToKeep);

  return tasks.filter((task) => !task.completed || task.completedAt > cutoff);
}

// Exportar a calendario externo
function exportToCalendar(tasks) {
  const calendarEvents = tasks
    .filter((task) => task.dueDate && !task.completed)
    .map((task) => ({
      title: task.text,
      start: task.dueDate,
      priority: task.priority,
    }));

  // Generar archivo de calendario o enviar a API
  return calendarEvents;
}

// Importar desde fuente externa
async function importFromExternal(source) {
  try {
    const response = await fetch(source);
    const data = await response.json();

    if (validateImportData(data)) {
      return data.tasks;
    }
  } catch (error) {
    console.error("Import failed:", error);
    throw error;
  }
}

// Tarea completada時に Webhook を送信
async function sendWebhook(task, webhookUrl) {
  try {
    await fetch(webhookUrl, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        event: "taskCompleted",
        task: task,
        timestamp: new Date().toISOString(),
      }),
    });
  } catch (error) {
    console.error("Webhook failed:", error);
  }
}