ax/db/node.go

package db

import (
	"axolotl/models"
	"axolotl/parse"
	"database/sql"
	"fmt"
	"math/rand"
	"strings"
	"time"
)

func genID() string {
	b := make([]byte, 5)
	for i := range b {
		b[i] = "abcdefghijklmnopqrstuvwxyz"[rand.Intn(26)]
	}
	return string(b)
}

func ParseRelFlag(s string) (models.RelType, string, error) {
	if p := strings.SplitN(s, ":", 2); len(p) == 2 {
		return models.RelType(p[0]), p[1], nil
	}
	return "", "", fmt.Errorf("invalid relation format: %s (expected type:id)", s)
}

func (db *DB) generateUniqueID() string {
	for {
		id := genID()
		e, _ := db.NodeExists(id)
		if !e {
			return id
		}
	}
}

func (db *DB) ensureUser(tx *sql.Tx, username string) (string, error) {
	var existingID string
	err := tx.QueryRow(`
		SELECT n.id FROM nodes n
		JOIN tags t ON n.id = t.node_id
		WHERE n.title = ? AND t.tag = '_type::user'`, username).Scan(&existingID)
	if err == nil {
		return existingID, nil
	}
	if err != sql.ErrNoRows {
		return "", err
	}

	id := db.generateUniqueID()
	now := time.Now().UTC().Format(time.RFC3339)
	if _, err := tx.Exec("INSERT INTO nodes (id, title, created_at, updated_at) VALUES (?, ?, ?, ?)",
		id, username, now, now); err != nil {
		return "", err
	}
	if _, err := tx.Exec("INSERT INTO tags (node_id, tag) VALUES (?, '_type::user')", id); err != nil {
		return "", err
	}
	return id, nil
}

func (db *DB) resolveUserRef(tx *sql.Tx, ref string) (string, error) {
	if exists, _ := db.NodeExists(ref); exists {
		return ref, nil
	}
	return db.ensureUser(tx, ref)
}

func (db *DB) GetUserByUsername(username string) (string, error) {
	var id string
	err := db.QueryRow(`
		SELECT n.id FROM nodes n
		JOIN tags t ON n.id = t.node_id
		WHERE n.title = ? AND t.tag = '_type::user'`, username).Scan(&id)
	if err == sql.ErrNoRows {
		return "", nil
	}
	return id, err
}

func (db *DB) ensureNamespace(tx *sql.Tx, name string) (string, error) {
	var existingID string
	err := tx.QueryRow(`
		SELECT n.id FROM nodes n
		JOIN tags t ON n.id = t.node_id
		WHERE n.title = ? AND t.tag = '_type::namespace'`, name).Scan(&existingID)
	if err == nil {
		return existingID, nil
	}
	if err != sql.ErrNoRows {
		return "", err
	}

	id := db.generateUniqueID()
	now := time.Now().UTC().Format(time.RFC3339)
	if _, err := tx.Exec("INSERT INTO nodes (id, title, created_at, updated_at) VALUES (?, ?, ?, ?)",
		id, name, now, now); err != nil {
		return "", err
	}
	if _, err := tx.Exec("INSERT INTO tags (node_id, tag) VALUES (?, '_type::namespace')", id); err != nil {
		return "", err
	}
	if _, err := tx.Exec("INSERT INTO rels (from_id, to_id, rel_type) VALUES (?, ?, ?)",
		id, id, models.RelInNamespace); err != nil {
		return "", err
	}
	userID, err := db.resolveUserRef(tx, GetCurrentUser())
	if err != nil {
		return "", err
	}
	if _, err := tx.Exec("INSERT INTO rels (from_id, to_id, rel_type) VALUES (?, ?, ?)",
		id, userID, models.RelCreated); err != nil {
		return "", err
	}
	return id, nil
}

func (db *DB) resolveNamespaceRef(tx *sql.Tx, ref string) (string, error) {
	if exists, _ := db.NodeExists(ref); exists {
		return ref, nil
	}
	return db.ensureNamespace(tx, ref)
}

type CreateParams struct {
	Title, Content, DueDate string
	Tags                    []string
	Rels                    map[models.RelType][]string
}
type UpdateParams struct {
	Title, Content, DueDate *string
	ClearDue                bool
	AddTags, RemoveTags     []string
	AddRels, RemoveRels     map[models.RelType][]string
}
type ListFilter struct {
	TagPrefixes  []string
	Assignee     string
	MentionsUser string
}

func (db *DB) CreateNode(p CreateParams) (*models.Node, error) {
	tx, err := db.Begin()
	if err != nil {
		return nil, err
	}
	defer tx.Rollback()
	now, id := time.Now().UTC().Format(time.RFC3339), db.generateUniqueID()

	_, err = tx.Exec("INSERT INTO nodes (id, title, content, due_date, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)",
		id, p.Title, p.Content, p.DueDate, now, now)
	if err != nil {
		return nil, err
	}

	for _, m := range parse.Mentions(p.Title + " " + p.Content) {
		userID, err := db.resolveUserRef(tx, m)
		if err != nil {
			return nil, err
		}
		if _, err := tx.Exec("INSERT INTO rels (from_id, to_id, rel_type) VALUES (?, ?, ?)", id, userID, models.RelMentions); err != nil {
			return nil, err
		}
	}

	for _, t := range p.Tags {
		if _, err := tx.Exec("INSERT INTO tags (node_id, tag) VALUES (?, ?)", id, t); err != nil {
			return nil, err
		}
	}
	for rt, tgts := range p.Rels {
		for _, tgt := range tgts {
			if rt == models.RelAssignee || rt == models.RelCreated {
				var err error
				if tgt, err = db.resolveUserRef(tx, tgt); err != nil {
					return nil, err
				}
			}
			if rt == models.RelInNamespace {
				var err error
				if tgt, err = db.resolveNamespaceRef(tx, tgt); err != nil {
					return nil, err
				}
			}
			if _, err := tx.Exec("INSERT INTO rels (from_id, to_id, rel_type) VALUES (?, ?, ?)", id, tgt, rt); err != nil {
				return nil, err
			}
		}
	}
	if err := tx.Commit(); err != nil {
		return nil, err
	}
	return db.NodeByID(id)
}

func (db *DB) UpdateNode(id string, p UpdateParams) error {
	tx, err := db.Begin()
	if err != nil {
		return err
	}
	defer tx.Rollback()

	var currentTitle, currentContent string
	err = tx.QueryRow("SELECT title, COALESCE(content, '') FROM nodes WHERE id = ?", id).Scan(&currentTitle, &currentContent)
	if err != nil {
		return err
	}

	upd := func(col, val string) error {
		_, err := tx.Exec("UPDATE nodes SET "+col+" = ? WHERE id = ?", val, id)
		return err
	}
	newTitle, newContent := currentTitle, currentContent
	if p.Title != nil {
		if err := upd("title", *p.Title); err != nil {
			return err
		}
		newTitle = *p.Title
	}
	if p.Content != nil {
		if err := upd("content", *p.Content); err != nil {
			return err
		}
		newContent = *p.Content
	}
	if p.DueDate != nil {
		if err := upd("due_date", *p.DueDate); err != nil {
			return err
		}
	}
	if p.ClearDue {
		if _, err := tx.Exec("UPDATE nodes SET due_date = NULL WHERE id = ?", id); err != nil {
			return err
		}
	}

	if p.Title != nil || p.Content != nil {
		newMentions := parse.Mentions(newTitle + " " + newContent)
		rows, err := tx.Query("SELECT to_id FROM rels WHERE from_id = ? AND rel_type = ?", id, models.RelMentions)
		if err != nil {
			return err
		}
		existingMentionIDs := make(map[string]bool)
		for rows.Next() {
			var uid string
			if err := rows.Scan(&uid); err != nil {
				rows.Close()
				return err
			}
			existingMentionIDs[uid] = true
		}
		rows.Close()

		mentionedUserIDs := make(map[string]bool)
		for _, m := range newMentions {
			userID, err := db.resolveUserRef(tx, m)
			if err != nil {
				return err
			}
			mentionedUserIDs[userID] = true
			if !existingMentionIDs[userID] {
				if _, err := tx.Exec("INSERT INTO rels (from_id, to_id, rel_type) VALUES (?, ?, ?)", id, userID, models.RelMentions); err != nil {
					return err
				}
			}
		}

		for uid := range existingMentionIDs {
			if !mentionedUserIDs[uid] {
				if _, err := tx.Exec("DELETE FROM rels WHERE from_id = ? AND to_id = ? AND rel_type = ?", id, uid, models.RelMentions); err != nil {
					return err
				}
			}
		}
	}

	for _, t := range p.RemoveTags {
		tx.Exec("DELETE FROM tags WHERE node_id = ? AND tag = ?", id, t)
	}
	for _, t := range p.AddTags {
		tx.Exec("INSERT OR IGNORE INTO tags (node_id, tag) VALUES (?, ?)", id, t)
	}
	for rt, tgts := range p.RemoveRels {
		for _, tgt := range tgts {
			tx.Exec("DELETE FROM rels WHERE from_id = ? AND to_id = ? AND rel_type = ?", id, tgt, rt)
		}
	}
	for rt, tgts := range p.AddRels {
		for _, tgt := range tgts {
			if rt == models.RelAssignee || rt == models.RelCreated {
				var err error
				if tgt, err = db.resolveUserRef(tx, tgt); err != nil {
					return err
				}
			}
			if rt == models.RelInNamespace {
				var err error
				if tgt, err = db.resolveNamespaceRef(tx, tgt); err != nil {
					return err
				}
			}
			tx.Exec("INSERT OR IGNORE INTO rels (from_id, to_id, rel_type) VALUES (?, ?, ?)", id, tgt, rt)
		}
	}

	if _, err = tx.Exec("UPDATE nodes SET updated_at = ? WHERE id = ?", time.Now().UTC().Format(time.RFC3339), id); err != nil {
		return err
	}
	return tx.Commit()
}

func (db *DB) DeleteNode(id string) error {
	_, err := db.Exec("DELETE FROM nodes WHERE id = ?", id)
	return err
}

func (db *DB) NodeExists(id string) (bool, error) {
	var e bool
	err := db.QueryRow("SELECT EXISTS(SELECT 1 FROM nodes WHERE id = ?)", id).Scan(&e)
	return e, err
}

func (db *DB) NodeByID(id string) (*models.Node, error) {
	n := &models.Node{Relations: make(map[string][]string)}
	q := db.QueryRow("SELECT id, title, COALESCE(content, ''), COALESCE(due_date, ''), created_at, updated_at FROM nodes WHERE id = ?", id)
	if err := q.Scan(&n.ID, &n.Title, &n.Content, &n.DueDate, &n.CreatedAt, &n.UpdatedAt); err != nil {
		return nil, err
	}

	if rows, err := db.Query("SELECT tag FROM tags WHERE node_id = ?", id); err == nil {
		defer rows.Close()
		for rows.Next() {
			var tag string
			rows.Scan(&tag)
			n.Tags = append(n.Tags, tag)
		}
	} else {
		return nil, err
	}

	if rows, err := db.Query("SELECT to_id, rel_type FROM rels WHERE from_id = ?", id); err == nil {
		defer rows.Close()
		for rows.Next() {
			var toID, relType string
			rows.Scan(&toID, &relType)
			n.Relations[relType] = append(n.Relations[relType], toID)
		}
	} else {
		return nil, err
	}
	return n, nil
}

func (db *DB) ListNodes(f ListFilter) ([]*models.Node, error) {
	q, args, joins, conds := "SELECT DISTINCT n.id FROM nodes n", []any{}, []string{}, []string{}
	if len(f.TagPrefixes) == 0 {
		f.TagPrefixes = append(f.TagPrefixes, "")
	}

	joins = append(joins, "JOIN tags t_tag ON n.id = t_tag.node_id")
	cond := ""
	for _, t := range f.TagPrefixes {
		cond += "t_tag.tag LIKE ? || '%' OR "
		args = append(args, t)
	}
	conds = append(conds, "SUM(CASE WHEN "+cond[:len(cond)-4]+" THEN 1 ELSE 0 END) >= ?")
	args = append(args, len(f.TagPrefixes))

	if f.Assignee != "" {
		joins = append(joins, "JOIN rels r_assign ON n.id = r_assign.from_id")
		conds = append(conds, "r_assign.to_id = ? AND r_assign.rel_type = ?")
		args = append(args, f.Assignee, models.RelAssignee)
	}
	if f.MentionsUser != "" {
		joins = append(joins, "JOIN rels r_mentions ON n.id = r_mentions.from_id")
		conds = append(conds, "r_mentions.to_id = ? AND r_mentions.rel_type = ?")
		args = append(args, f.MentionsUser, models.RelMentions)
	}

	if len(joins) > 0 {
		q += " " + strings.Join(joins, " ") + " "
	}
	q += "GROUP BY n.id"
	if len(conds) > 0 {
		q += " HAVING " + strings.Join(conds, " AND ")
	}

	rows, err := db.Query(q+" ORDER BY n.created_at DESC", args...)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var nodes []*models.Node
	for rows.Next() {
		var id string
		if err := rows.Scan(&id); err != nil {
			return nil, err
		}
		if n, err := db.NodeByID(id); err == nil {
			nodes = append(nodes, n)
		} else {
			return nil, err
		}
	}
	return nodes, nil
}

func (db *DB) CanClose(id string) (bool, []string, error) {
	rows, err := db.Query("SELECT to_id FROM rels WHERE from_id = ? AND rel_type = ?", id, models.RelBlocks)
	if err != nil {
		return false, nil, err
	}
	defer rows.Close()
	var blocking []string
	for rows.Next() {
		var bID, tag string
		if err := rows.Scan(&bID); err != nil {
			return false, nil, err
		}
		if err := db.QueryRow("SELECT tag FROM tags WHERE node_id = ? AND tag LIKE '_status::%'", bID).Scan(&tag); err == sql.ErrNoRows {
			continue
		} else if err != nil {
			return false, nil, err
		}
		if strings.HasSuffix(tag, "::open") {
			blocking = append(blocking, bID)
		}
	}
	return len(blocking) == 0, blocking, nil
}