main.go

package main

import (
	"database/sql"
	"flag"
	"fmt"
	"log"
	"os"
	"path/filepath"
	"time"

	_ "github.com/mattn/go-sqlite3"
)

const schema = `
CREATE TABLE IF NOT EXISTS tasks (
	id INTEGER PRIMARY KEY AUTOINCREMENT,
	title TEXT NOT NULL,
	note TEXT,
	done INTEGER NOT NULL DEFAULT 0,
	created_at DATETIME NOT NULL,
	due DATE
);
`

func dbPath() string {
	// default DB in user's home directory: ~/.todo.db
	home, err := os.UserHomeDir()
	if err != nil {
		return "todo.db"
	}
	return filepath.Join(home, ".todo.db")
}

func openDB(path string) (*sql.DB, error) {
	db, err := sql.Open("sqlite3", path+"?_busy_timeout=5000&_foreign_keys=1")
	if err != nil {
		return nil, err
	}
	if _, err := db.Exec(schema); err != nil {
		db.Close()
		return nil, err
	}
	return db, nil
}

func addCmd(db *sql.DB, args []string) {
	fs := flag.NewFlagSet("add", flag.ExitOnError)
	note := fs.String("note", "", "note/description")
	due := fs.String("due", "", "due date YYYY-MM-DD (optional)")
	fs.Parse(args)
	title := fs.Arg(0)
	if title == "" {
		fmt.Println("Usage: todo add [--note \"...\"] [--due YYYY-MM-DD] \"title\"")
		return
	}

	var dueNull interface{} = nil
	if *due != "" {
		if _, err := time.Parse("2006-01-02", *due); err != nil {
			log.Fatalf("invalid due date format: %v", err)
		}
		dueNull = *due
	}

	stmt, err := db.Prepare("INSERT INTO tasks(title,note,created_at,due) values(?,?,?,?)")
	if err != nil {
		log.Fatal(err)
	}
	defer stmt.Close()

	if _, err := stmt.Exec(title, *note, time.Now().UTC().Format(time.RFC3339), dueNull); err != nil {
		log.Fatal(err)
	}
	fmt.Println("Added:", title)
}

func listCmd(db *sql.DB, args []string) {
	fs := flag.NewFlagSet("list", flag.ExitOnError)
	show := fs.String("show", "pending", "show: pending|all|done")
	fs.Parse(args)

	var q string
	switch *show {
	case "pending":
		q = "SELECT id,title,note,done,created_at,due FROM tasks WHERE done = 0 ORDER BY created_at"
	case "done":
		q = "SELECT id,title,note,done,created_at,due FROM tasks WHERE done = 1 ORDER BY created_at DESC"
	case "all":
		q = "SELECT id,title,note,done,created_at,due FROM tasks ORDER BY done, created_at"
	default:
		log.Fatalf("unknown show option: %s", *show)
	}

	rows, err := db.Query(q)
	if err != nil {
		log.Fatal(err)
	}
	defer rows.Close()

	for rows.Next() {
		var id int
		var title, note, createdAt, due sql.NullString
		var done int
		if err := rows.Scan(&id, &title, &note, &done, &createdAt, &due); err != nil {
			log.Fatal(err)
		}
		status := "[ ]"
		if done != 0 {
			status = "[x]"
		}
		created := createdAt.String
		_ = created
		dueStr := ""
		if due.Valid && due.String != "" {
			dueStr = " due:" + due.String
		}
		if note.Valid && note.String != "" {
			fmt.Printf("%3d %s %s%s\n    %s\n", id, status, title.String, dueStr, note.String)
		} else {
			fmt.Printf("%3d %s %s%s\n", id, status, title.String, dueStr)
		}
	}
}

func doneCmd(db *sql.DB, args []string) {
	fs := flag.NewFlagSet("done", flag.ExitOnError)
	fs.Parse(args)
	if fs.NArg() < 1 {
		fmt.Println("Usage: todo done <id>")
		return
	}
	var id = fs.Arg(0)
	res, err := db.Exec("UPDATE tasks SET done = 1 WHERE id = ?", id)
	if err != nil {
		log.Fatal(err)
	}
	n, _ := res.RowsAffected()
	if n == 0 {
		fmt.Println("No task updated (check id).")
	} else {
		fmt.Println("Marked done:", id)
	}
}

func rmCmd(db *sql.DB, args []string) {
	fs := flag.NewFlagSet("rm", flag.ExitOnError)
	fs.Parse(args)
	if fs.NArg() < 1 {
		fmt.Println("Usage: todo rm <id>")
		return
	}
	id := fs.Arg(0)
	res, err := db.Exec("DELETE FROM tasks WHERE id = ?", id)
	if err != nil {
		log.Fatal(err)
	}
	n, _ := res.RowsAffected()
	if n == 0 {
		fmt.Println("No task removed (check id).")
	} else {
		fmt.Println("Removed:", id)
	}
}

func editCmd(db *sql.DB, args []string) {
	fs := flag.NewFlagSet("edit", flag.ExitOnError)
	title := fs.String("title", "", "new title")
	note := fs.String("note", "", "new note")
	due := fs.String("due", "", "new due YYYY-MM-DD (empty to clear)")
	fs.Parse(args)
	if fs.NArg() < 1 {
		fmt.Println("Usage: todo edit <id> [--title \"...\"] [--note \"...\"] [--due YYYY-MM-DD]")
		return
	}
	id := fs.Arg(0)

	// Build update set dynamically
	updates := []string{}
	params := []interface{}{}
	if *title != "" {
		updates = append(updates, "title = ?")
		params = append(params, *title)
	}
	if *note != "" {
		updates = append(updates, "note = ?")
		params = append(params, *note)
	}
	if fs.Lookup("due").Value.String() != "" {
		// user provided due flag (maybe empty string to clear)
		if *due != "" {
			if _, err := time.Parse("2006-01-02", *due); err != nil {
				log.Fatalf("invalid due date format: %v", err)
			}
			updates = append(updates, "due = ?")
			params = append(params, *due)
		} else {
			updates = append(updates, "due = NULL")
		}
	}
	if len(updates) == 0 {
		fmt.Println("No changes specified.")
		return
	}
	query := "UPDATE tasks SET " + joinComma(updates) + " WHERE id = ?"
	params = append(params, id)
	res, err := db.Exec(query, params...)
	if err != nil {
		log.Fatal(err)
	}
	n, _ := res.RowsAffected()
	if n == 0 {
		fmt.Println("No task updated (check id).")
	} else {
		fmt.Println("Updated:", id)
	}
}

func statsCmd(db *sql.DB, args []string) {
	var total, done int
	if err := db.QueryRow("SELECT COUNT(*) FROM tasks").Scan(&total); err != nil {
		log.Fatal(err)
	}
	if err := db.QueryRow("SELECT COUNT(*) FROM tasks WHERE done = 1").Scan(&done); err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Total: %d   Done: %d   Pending: %d\n", total, done, total-done)
}

func joinComma(parts []string) string {
	out := ""
	for i, p := range parts {
		if i != 0 {
			out += ", "
		}
		out += p
	}
	return out
}

func usage() {
	fmt.Println(`todo - simple sqlite-backed todo CLI

Usage:
  todo <command> [options] ...

Commands:
  add    [--note "..."] [--due YYYY-MM-DD] "title"   Add a new task
  list   [--show pending|all|done]                     List tasks (default: pending)
  done   <id>                                          Mark task done
  rm     <id>                                          Remove a task
  edit   <id> [--title "..."] [--note "..."] [--due YYYY-MM-DD]  Edit a task
  stats                                                 Show counts

DB location by default: ~/.todo.db
`)
}

func main() {
	if len(os.Args) < 2 {
		usage()
		return
	}
	dbp := dbPath()
	db, err := openDB(dbp)
	if err != nil {
		log.Fatalf("open db: %v", err)
	}
	defer db.Close()

	cmd := os.Args[1]
	args := os.Args[2:]

	switch cmd {
	case "add":
		addCmd(db, args)
	case "list":
		listCmd(db, args)
	case "done":
		doneCmd(db, args)
	case "rm":
		rmCmd(db, args)
	case "edit":
		editCmd(db, args)
	case "stats":
		statsCmd(db, args)
	case "help", "--help", "-h":
		usage()
	default:
		fmt.Println("Unknown command:", cmd)
		usage()
	}
}