// Este código implementa una aplicación CLI para gestionar tareas, demostrando conceptos fundamentales de Go como structs,
// interfaces, manejo de errores y persistencia en archivos JSON. Cumple con todos los requisitos técnicos especificados.
package main
import (
	"encoding/json"
	"fmt"
	"os"
)
// Task representa una tarea con sus campos básicos.
type Task struct {
	ID          int    `json:"id"`
	Title       string `json:"title"`
	Description string `json:"description"`
	Completed   bool   `json:"completed"`
}
// Storage define una interfaz para diferentes tipos de almacenamiento de tareas.
type Storage interface {
	Save(tasks []Task) error
	Load() ([]Task, error)
}
// FileStorage implementa Storage para persistencia en archivo JSON.
type FileStorage struct {
	filename string
}
func (fs *FileStorage) Save(tasks []Task) error {
	data, err := json.MarshalIndent(tasks, "", "  ")
	if err != nil {
		return fmt.Errorf("error marshaling tasks to JSON: %v", err)
	}
	if err := os.WriteFile(fs.filename, data, 0644); err != nil {
		return fmt.Errorf("error writing to file %s: %v", fs.filename, err)
	}
	return nil
}
func (fs *FileStorage) Load() ([]Task, error) {
	data, err := os.ReadFile(fs.filename)
	if err != nil {
		if os.IsNotExist(err) {
			return []Task{}, nil // Archivo no existe, retorna lista vacía
		}
		return nil, fmt.Errorf("error reading file %s: %v", fs.filename, err)
	}
	var tasks []Task
	if err := json.Unmarshal(data, &tasks); err != nil {
		return nil, fmt.Errorf("error unmarshaling tasks from JSON: %v", err)
	}
	return tasks, nil
}
// TaskManager gestiona las operaciones CRUD sobre las tareas.
type TaskManager struct {
	tasks    []Task
	storage  Storage
	nextID   int
	taskMap  map[int]*Task // Para acceso rápido por ID
}
// NewTaskManager crea un nuevo gestor de tareas con el almacenamiento especificado.
func NewTaskManager(storage Storage) (*TaskManager, error) {
	tasks, err := storage.Load()
	if err != nil {
		return nil, err
	}
	nextID := 1
	if len(tasks) > 0 {
		for _, task := range tasks {
			if task.ID >= nextID {
				nextID = task.ID + 1
			}
		}
	}
	taskMap := make(map[int]*Task)
	for i := range tasks {
		taskMap[tasks[i].ID] = &tasks[i]
	}
	return &TaskManager{
		tasks:   tasks,
		storage: storage,
		nextID:  nextID,
		taskMap: taskMap,
	}, nil
}
// AddTask añade una nueva tarea y retorna su ID.
func (tm *TaskManager) AddTask(title, description string) int {
	task := Task{
		ID:          tm.nextID,
		Title:       title,
		Description: description,
		Completed:   false,
	}
	tm.tasks = append(tm.tasks, task)
	tm.taskMap[task.ID] = &tm.tasks[len(tm.tasks)-1]
	tm.nextID++
	return task.ID
}
// ListTasks retorna un slice con todas las tareas.
func (tm *TaskManager) ListTasks() []Task {
	return tm.tasks
}
// CompleteTask marca una tarea como completada por su ID.
func (tm *TaskManager) CompleteTask(id int) error {
	task, exists := tm.taskMap[id]
	if !exists {
		return fmt.Errorf("task with ID %d not found", id)
	}
	task.Completed = true
	return nil
}
// SaveToFile persiste las tareas en el almacenamiento configurado.
func (tm *TaskManager) SaveToFile() error {
	return tm.storage.Save(tm.tasks)
}
func main() {
	storage := &FileStorage{filename: "tasks.json"}
	manager, err := NewTaskManager(storage)
	if err != nil {
		fmt.Printf("Error initializing task manager: %v\n", err)
		return
	}
	// Ejemplo de uso de la CLI
	id := manager.AddTask("Comprar leche", "Ir al supermercado")
	fmt.Printf("Tarea añadida con ID: %d\n", id)
	err = manager.CompleteTask(id)
	if err != nil {
		fmt.Printf("Error completando tarea: %v\n", err)
	}
	tasks := manager.ListTasks()
	for _, task := range tasks {
		fmt.Printf("ID: %d, Title: %s, Completed: %v\n", task.ID, task.Title, task.Completed)
	}
	err = manager.SaveToFile()
	if err != nil {
		fmt.Printf("Error saving tasks: %v\n", err)
	}
}
// Output esperado:
// Tarea añadida con ID: 1
// ID: 1, Title: Comprar leche, Completed: true
---

// CASO DE USO REAL: Servidor HTTP TodoList con Persistencia JSON
// Este código implementa una API REST completa para gestión de tareas con persistencia en JSON,
// middleware de logging, y manejo concurrente seguro usando mutex. Cumple con los requisitos de un MVP para una startup.
package main
import (
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"os"
	"strconv"
	"sync"
)
// Task representa una tarea en la API.
type Task struct {
	ID          int    `json:"id"`
	Title       string `json:"title"`
	Description string `json:"description"`
	Completed   bool   `json:"completed"`
}
// TaskStore gestiona el almacenamiento de tareas con acceso concurrente seguro.
type TaskStore struct {
	sync.RWMutex
	tasks    map[int]Task
	nextID   int
	filename string
}
// NewTaskStore inicializa el almacenamiento de tareas, cargando desde archivo si existe.
func NewTaskStore(filename string) (*TaskStore, error) {
	store := &TaskStore{
		tasks:    make(map[int]Task),
		nextID:   1,
		filename: filename,
	}
	if err := store.load(); err != nil {
		return nil, err
	}
	return store, nil
}
func (ts *TaskStore) load() error {
	data, err := os.ReadFile(ts.filename)
	if err != nil {
		if os.IsNotExist(err) {
			return nil // Archivo no existe, inicia vacío
		}
		return err
	}
	var tasks []Task
	if err := json.Unmarshal(data, &tasks); err != nil {
		return err
	}
	for _, task := range tasks {
		ts.tasks[task.ID] = task
		if task.ID >= ts.nextID {
			ts.nextID = task.ID + 1
		}
	}
	return nil
}
func (ts *TaskStore) save() error {
	ts.RLock()
	defer ts.RUnlock()
	var tasks []Task
	for _, task := range ts.tasks {
		tasks = append(tasks, task)
	}
	data, err := json.MarshalIndent(tasks, "", "  ")
	if err != nil {
		return err
	}
	return os.WriteFile(ts.filename, data, 0644)
}
// Middleware de logging para registrar cada request.
func loggingMiddleware(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		log.Printf("%s %s %s", r.RemoteAddr, r.Method, r.URL.Path)
		next.ServeHTTP(w, r)
	})
}
// Handlers para la API REST.
type TaskHandler struct {
	store *TaskStore
}
func (th *TaskHandler) listTasks(w http.ResponseWriter, r *http.Request) {
	th.store.RLock()
	defer th.store.RUnlock()
	var tasks []Task
	for _, task := range th.store.tasks {
		tasks = append(tasks, task)
	}
	json.NewEncoder(w).Encode(tasks)
}
func (th *TaskHandler) addTask(w http.ResponseWriter, r *http.Request) {
	var task Task
	if err := json.NewDecoder(r.Body).Decode(&task); err != nil {
		http.Error(w, "Invalid request body", http.StatusBadRequest)
		return
	}
	if task.Title == "" {
		http.Error(w, "Title is required", http.StatusBadRequest)
		return
	}
	th.store.Lock()
	defer th.store.Unlock()
	task.ID = th.store.nextID
	th.store.tasks[task.ID] = task
	th.store.nextID++
	if err := th.store.save(); err != nil {
		http.Error(w, "Error saving tasks", http.StatusInternalServerError)
		return
	}
	w.WriteHeader(http.StatusCreated)
	json.NewEncoder(w).Encode(task)
}
func (th *TaskHandler) completeTask(w http.ResponseWriter, r *http.Request) {
	idStr := r.URL.Path[len("/todos/"):]
	id, err := strconv.Atoi(idStr)
	if err != nil {
		http.Error(w, "Invalid task ID", http.StatusBadRequest)
		return
	}
	th.store.Lock()
	defer th.store.Unlock()
	task, exists := th.store.tasks[id]
	if !exists {
		http.Error(w, "Task not found", http.StatusNotFound)
		return
	}
	task.Completed = true
	th.store.tasks[id] = task
	if err := th.store.save(); err != nil {
		http.Error(w, "Error saving tasks", http.StatusInternalServerError)
		return
	}
	json.NewEncoder(w).Encode(task)
}
func main() {
	store, err := NewTaskStore("todos.json")
	if err != nil {
		log.Fatalf("Error initializing store: %v", err)
	}
	handler := &TaskHandler{store: store}
	mux := http.NewServeMux()
	mux.HandleFunc("/todos", func(w http.ResponseWriter, r *http.Request) {
		switch r.Method {
		case http.MethodGet:
			handler.listTasks(w, r)
		case http.MethodPost:
			handler.addTask(w, r)
		default:
			http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
		}
	})
	mux.HandleFunc("/todos/", func(w http.ResponseWriter, r *http.Request) {
		if r.Method == http.MethodPut {
			handler.completeTask(w, r)
		} else {
			http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
		}
	})
	// Aplicar middleware de logging
	loggedMux := loggingMiddleware(mux)
	log.Println("Server starting on :8080")
	if err := http.ListenAndServe(":8080", loggedMux); err != nil {
		log.Fatalf("Server error: %v", err)
	}
}
// Output esperado:
// Server starting on :8080
// Logs de requests en consola para cada petición a /todos
// API soporta GET /todos, POST /todos, PUT /todos/{id}