package main

import (
	"fmt"
	"os"
	"path/filepath"
	"strings"
	"time"

	"verstak/internal/core/activity"
	"verstak/internal/core/nodes"
	syncsvc "verstak/internal/core/sync"
	"verstak/internal/core/templates"
)

func (a *App) ListWorkspaceTree() ([]NodeDTO, error) {
	list, err := a.nodes.ListRoots(false)
	if err != nil {
		return nil, err
	}
	return toNodeDTOs(list), nil
}

func (a *App) ListChildren(parentID string) ([]NodeDTO, error) {
	list, err := a.nodes.ListChildren(parentID, false)
	if err != nil {
		return nil, err
	}
	return toNodeDTOs(list), nil
}

func (a *App) GetNodeDetail(nodeID string) (*NodeDTO, error) {
	n, err := a.nodes.GetActive(nodeID)
	if err != nil {
		return nil, err
	}
	dto := toNodeDTO(n)
	return &dto, nil
}

func (a *App) CreateNodeFromTemplate(parentID, title, templateID string) (*NodeDTO, error) {
	tmpl, ok := a.templates.Get(templateID)
	if !ok {
		return nil, fmt.Errorf("template %q not found", templateID)
	}

	seg := templates.SafeDisplayNameToPathSegment(title)
	if seg == "" {
		seg = "node"
	}

	var parent *nodes.Node
	var parentFsPath string
	if parentID != "" {
		var err error
		parent, err = a.nodes.GetActive(parentID)
		if err != nil {
			return nil, fmt.Errorf("parent not found: %w", err)
		}
		parentFsPath = parent.FsPath
	}

	fsPath := seg
	if parentFsPath != "" {
		fsPath = filepath.Join(parentFsPath, seg)
	}

	physPath := filepath.Join(a.vault, fsPath)
	physPath = templates.UniquePath(physPath)
	rel, _ := filepath.Rel(a.vault, physPath)
	fsPath = rel

	var pID *string
	if parentID != "" {
		pID = &parentID
	}

	sortOrder := 0
	n, err := a.nodes.Create(pID, tmpl.Type, title, sortOrder, tmpl.ID, fsPath)
	if err != nil {
		return nil, fmt.Errorf("create node: %w", err)
	}

	if err := os.MkdirAll(physPath, 0o755); err != nil {
		return nil, fmt.Errorf("create folder: %w", err)
	}

	for _, df := range tmpl.DefaultFiles {
		fpath := filepath.Join(physPath, df.Path)
		if err := os.MkdirAll(filepath.Dir(fpath), 0o755); err != nil {
			continue
		}
		content := fmt.Sprintf("# %s\n\n", title)
		_ = os.WriteFile(fpath, []byte(content), 0o640)
	}

	for _, folder := range tmpl.DefaultFolders {
		fpath := filepath.Join(physPath, folder)
		_ = os.MkdirAll(fpath, 0o755)
	}

	pid := ""
	if parentID != "" {
		pid = parentID
	}
	_ = a.activity.Record(pid, activity.TargetNode, n.ID, "", activity.TypeNodeCreated, title, `{"template":"`+templateID+`"}`)
	_ = a.sync.RecordOp(syncsvc.EntityNode, n.ID, syncsvc.OpCreate, nodePayload(n))

	dto := toNodeDTO(n)
	return &dto, nil
}

func (a *App) DeleteNode(id string) error {
	n, err := a.nodes.GetActive(id)
	if err != nil {
		return a.nodes.SoftDelete(id)
	}
	pid := ""
	if n.ParentID != nil {
		pid = *n.ParentID
	}
	var entity string
	var targetType string
	var evType string
	switch n.Type {
	case nodes.TypeNote:
		entity = syncsvc.EntityNote
		targetType = activity.TargetNote
		evType = activity.TypeNoteDeleted
	case nodes.TypeFolder, nodes.TypeProject, nodes.TypeClient, nodes.TypeDocument, nodes.TypeRecipe, nodes.TypeSpace:
		entity = syncsvc.EntityFolder
		targetType = activity.TargetFolder
		evType = activity.TypeFolderDeleted
	case nodes.TypeFile:
		entity = syncsvc.EntityFile
		targetType = activity.TargetFile
		evType = activity.TypeFileDeleted
	default:
		entity = syncsvc.EntityNode
		targetType = activity.TargetNode
		evType = activity.TypeNodeDeleted
	}
	_ = a.activity.Record(pid, targetType, id, "", evType, n.Title, "")
	_ = a.sync.RecordOp(entity, id, syncsvc.OpDelete, nil)

	return a.files.DeleteNodeAndChildren(id)
}

func (a *App) RenameNode(nodeID, newTitle string) error {
	n, err := a.nodes.GetActive(nodeID)
	if err != nil {
		return err
	}

	seg := templates.SafeDisplayNameToPathSegment(newTitle)
	if seg == "" {
		seg = "node"
	}

	isFolderLike := n.Type != nodes.TypeNote && n.Type != nodes.TypeFile

	if isFolderLike {
		// Folder-like node: rename physical directory
		if n.FsPath == "" {
			return fmt.Errorf("cannot rename node %s (%s): fs_path is empty", n.ID, n.Title)
		}

		oldFsPath := n.FsPath
		oldPhysPath := filepath.Join(a.vault, oldFsPath)

		parentFsPath := ""
		if n.ParentID != nil {
			p, err := a.nodes.GetActive(*n.ParentID)
			if err == nil {
				parentFsPath = p.FsPath
			}
		}
		newFsPath := seg
		if parentFsPath != "" {
			newFsPath = filepath.Join(parentFsPath, seg)
		}
		newPhysPath := filepath.Join(a.vault, newFsPath)
		newPhysPath = templates.UniquePath(newPhysPath)
		rel, _ := filepath.Rel(a.vault, newPhysPath)
		newFsPath = rel

		oldTitle := n.Title
		if err := a.nodes.UpdateTitle(nodeID, newTitle); err != nil {
			return err
		}
		if err := a.nodes.UpdateFsPath(nodeID, newFsPath); err != nil {
			return err
		}
		if err := a.nodes.UpdateFsPathRecursive(nodeID, newFsPath); err != nil {
			return err
		}

		if _, err := os.Stat(oldPhysPath); err == nil {
			if err := os.Rename(oldPhysPath, newPhysPath); err != nil {
				return fmt.Errorf("rename folder: %w", err)
			}
		}

		pid := ""
		if n.ParentID != nil {
			pid = *n.ParentID
		}
		_ = a.activity.Record(pid, activity.TargetFolder, nodeID, "", activity.TypeFolderRenamed, newTitle, `{"from":"`+oldTitle+`","to":"`+newTitle+`"}`)
		_ = a.sync.RecordOp(syncsvc.EntityFolder, nodeID, syncsvc.OpUpdate, map[string]interface{}{
			"title":      newTitle,
			"fs_path":    newFsPath,
			"updated_at": time.Now().UTC().Format(time.RFC3339),
		})
		return nil
	}

	// Note/file node: rename the physical file, update file record
	if err := a.nodes.UpdateTitle(nodeID, newTitle); err != nil {
		return err
	}

	// Collect file records first to avoid connection deadlock (SetMaxOpenConns=1)
	type fileRec struct {
		id, path, filename string
	}
	var records []fileRec
	rows, err := a.db.Query(`SELECT id, path, filename FROM files WHERE node_id=?`, nodeID)
	if err == nil {
		for rows.Next() {
			var r fileRec
			if err := rows.Scan(&r.id, &r.path, &r.filename); err != nil {
				continue
			}
			records = append(records, r)
		}
		rows.Close()
	}

	for _, r := range records {
		if r.path == "" {
			continue
		}
		oldAbs := filepath.Join(a.vault, r.path)
		dir := filepath.Dir(r.path)
		var newFilename string
		if n.Type == nodes.TypeNote {
			ext := filepath.Ext(r.filename)
			if ext == "" {
				ext = ".md"
			}
			newFilename = seg + ext
		} else {
			// File node: title is the full filename
			newFilename = newTitle
		}
		newRelPath := filepath.Join(dir, newFilename)
		newAbs := filepath.Join(a.vault, newRelPath)

		// Check for collision — generate unique name if needed
		if _, err := os.Stat(newAbs); err == nil {
			ext := filepath.Ext(newFilename)
			base := strings.TrimSuffix(newFilename, ext)
			baseSeg := templates.SafeDisplayNameToPathSegment(base)
			if baseSeg == "" {
				baseSeg = "renamed"
			}
			for n := 2; ; n++ {
				candidate := fmt.Sprintf("%s (%d)%s", baseSeg, n, ext)
				candidatePath := filepath.Join(dir, candidate)
				if _, err := os.Stat(filepath.Join(a.vault, candidatePath)); os.IsNotExist(err) {
					newFilename = candidate
					newRelPath = candidatePath
					newAbs = filepath.Join(a.vault, newRelPath)
					break
				}
			}
		}

		// Rename physical file
		if _, err := os.Stat(oldAbs); err == nil {
			if err := os.Rename(oldAbs, newAbs); err == nil {
				_, _ = a.db.Exec(`UPDATE files SET filename=?, path=? WHERE id=?`,
					newFilename, newRelPath, r.id)
			}
		}
	}

	pid := ""
	if n.ParentID != nil {
		pid = *n.ParentID
	}
	var evType string
	var targetType string
	var syncEntity string
	if n.Type == nodes.TypeNote {
		evType = activity.TypeNoteUpdated
		targetType = activity.TargetNote
		syncEntity = syncsvc.EntityNote
	} else {
		evType = activity.TypeFileRenamed
		targetType = activity.TargetFile
		syncEntity = syncsvc.EntityFile
	}
	_ = a.activity.Record(pid, targetType, nodeID, "", evType, newTitle, "")
	_ = a.sync.RecordOp(syncEntity, nodeID, syncsvc.OpUpdate, map[string]interface{}{
		"title":      newTitle,
		"updated_at": time.Now().UTC().Format(time.RFC3339),
	})
	return nil
}

func (a *App) MoveNode(nodeID, newParentID string) error {
	node, err := a.nodes.GetActive(nodeID)
	if err != nil {
		return err
	}

	isFolderLike := node.Type != nodes.TypeNote && node.Type != nodes.TypeFile

	// Resolve new parent
	var parent *nodes.Node
	if newParentID != "" {
		parent, err = a.nodes.GetActive(newParentID)
		if err != nil {
			return fmt.Errorf("new parent not found: %w", err)
		}
	}

	// Resolve name conflicts first
	nodeTitle := node.Title
	if parent != nil {
		destChildren, _ := a.nodes.ListChildren(newParentID, false)
		for i := range destChildren {
			if destChildren[i].Title == nodeTitle {
				nodeTitle = fmt.Sprintf("%s (%d)", nodeTitle, 2)
				break
			}
		}
	}

	// Update title if changed
	if nodeTitle != node.Title {
		if err := a.nodes.UpdateTitle(nodeID, nodeTitle); err != nil {
			return err
		}
		node.Title = nodeTitle
	}

	if isFolderLike {
		// Folder-like node: move physical directory
		if node.FsPath == "" {
			return fmt.Errorf("cannot move node %s (%s): fs_path is empty", node.ID, node.Title)
		}

		seg := templates.SafeDisplayNameToPathSegment(node.Title)
		oldPhysPath := filepath.Join(a.vault, node.FsPath)

		newFsPath := seg
		if parent != nil && parent.FsPath != "" {
			newFsPath = filepath.Join(parent.FsPath, seg)
		}
		newPhysPath := filepath.Join(a.vault, newFsPath)
		newPhysPath = templates.UniquePath(newPhysPath)
		rel, _ := filepath.Rel(a.vault, newPhysPath)
		newFsPath = rel

		// Update parent_id (use nil for root move)
		if newParentID == "" {
			if err := a.nodes.Move(nodeID, nil, 0); err != nil {
				return err
			}
		} else {
			if err := a.nodes.Move(nodeID, &newParentID, 0); err != nil {
				return err
			}
		}
		if err := a.nodes.UpdateFsPath(nodeID, newFsPath); err != nil {
			return err
		}
		if err := a.nodes.UpdateFsPathRecursive(nodeID, newFsPath); err != nil {
			return err
		}

		if _, err := os.Stat(oldPhysPath); err == nil {
			if err := os.Rename(oldPhysPath, newPhysPath); err != nil {
				return fmt.Errorf("move folder: %w", err)
			}
		}

		node.FsPath = newFsPath
	} else {
		// Note/file node: update parent_id and move physical file
		if newParentID == "" {
			if err := a.nodes.Move(nodeID, nil, 0); err != nil {
				return err
			}
		} else {
			if err := a.nodes.Move(nodeID, &newParentID, 0); err != nil {
				return err
			}
		}

		// Update file record path to reflect new parent
		type fileMove struct {
			id, path string
		}
		var fileMoves []fileMove
		frows, ferr := a.db.Query(`SELECT id, path FROM files WHERE node_id=?`, nodeID)
		if ferr == nil {
			for frows.Next() {
				var fm fileMove
				if err := frows.Scan(&fm.id, &fm.path); err != nil {
					continue
				}
				fileMoves = append(fileMoves, fm)
			}
			frows.Close()
		}

		for _, fm := range fileMoves {
			if fm.path == "" {
				continue
			}
			filename := filepath.Base(fm.path)
			newRelPath := filename
			if parent != nil && parent.FsPath != "" {
				newRelPath = filepath.Join(parent.FsPath, filename)
			}
			oldAbs := filepath.Join(a.vault, fm.path)
			newAbs := filepath.Join(a.vault, newRelPath)

			if _, err := os.Stat(oldAbs); err == nil {
				_ = os.MkdirAll(filepath.Dir(newAbs), 0o750)
				if err := os.Rename(oldAbs, newAbs); err == nil {
					_, _ = a.db.Exec(`UPDATE files SET path=? WHERE id=?`,
						newRelPath, fm.id)
				}
			}
		}
	}

	pid := ""
	if node.ParentID != nil {
		pid = *node.ParentID
	}
	var targetType string
	var evType string
	var syncEntity string
	if isFolderLike {
		targetType = activity.TargetFolder
		evType = activity.TypeFolderMoved
		syncEntity = syncsvc.EntityFolder
	} else if node.Type == nodes.TypeNote {
		targetType = activity.TargetNote
		evType = activity.TypeNoteUpdated
		syncEntity = syncsvc.EntityNote
	} else {
		targetType = activity.TargetFile
		evType = activity.TypeFileMoved
		syncEntity = syncsvc.EntityFile
	}
	_ = a.activity.Record(pid, targetType, nodeID, "", evType, node.Title, `{"to":"`+newParentID+`"}`)
	var opFsPath string
	if isFolderLike && node.FsPath != "" {
		opFsPath = node.FsPath
	}
	_ = a.sync.RecordOp(syncEntity, nodeID, syncsvc.OpMove, map[string]interface{}{
		"parent_id":  newParentID,
		"fs_path":    opFsPath,
		"updated_at": time.Now().UTC().Format(time.RFC3339),
	})
	return nil
}

func (a *App) ListEnabledTemplates() ([]TemplateDTO, error) {
	list := a.templates.Enabled()
	result := make([]TemplateDTO, len(list))
	for i, t := range list {
		result[i] = TemplateDTO{
			ID:    t.ID,
			Title: t.Title,
			Type:  t.Type,
			Icon:  t.Icon,
		}
	}
	return result, nil
}

func (a *App) OpenNodeFolder(nodeID string) (string, error) {
	n, err := a.nodes.GetActive(nodeID)
	if err != nil {
		return "", err
	}
	if n.FsPath == "" {
		return "", fmt.Errorf("node %s has no physical path", nodeID)
	}
	physPath := filepath.Join(a.vault, n.FsPath)
	return physPath, nil
}