package main

import (
	"encoding/base64"
	"fmt"
	"mime"
	"os"
	"path/filepath"
	"strings"
	"time"

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

func (a *App) CaptureText(text string) (*InboxNodeDTO, error) {
	if err := a.requireVault(); err != nil {
		return nil, err
	}
	text = strings.TrimSpace(text)
	if text == "" {
		return nil, fmt.Errorf("text required")
	}
	title := firstLineTitle(text, "Captured text")
	content := "# " + title + "\n\n" + text + "\n"
	return a.createCaptureNote(title, content, "text", "clipboard")
}

func (a *App) CaptureURL(rawURL, title string) (*InboxNodeDTO, error) {
	if err := a.requireVault(); err != nil {
		return nil, err
	}
	rawURL = strings.TrimSpace(rawURL)
	if rawURL == "" {
		return nil, fmt.Errorf("url required")
	}
	title = strings.TrimSpace(title)
	if title == "" {
		title = rawURL
	}
	title = firstLineTitle(title, rawURL)
	content := "# " + title + "\n\n" + rawURL + "\n"
	return a.createCaptureNote(title, content, "url", "clipboard")
}

func (a *App) CapturePath(sourcePath string) (*InboxNodeDTO, error) {
	if err := a.requireVault(); err != nil {
		return nil, err
	}
	sourcePath = strings.TrimSpace(sourcePath)
	if sourcePath == "" {
		return nil, fmt.Errorf("path required")
	}
	absPath, err := filepath.Abs(sourcePath)
	if err != nil {
		return nil, fmt.Errorf("abs path: %w", err)
	}
	info, err := os.Stat(absPath)
	if err != nil {
		return nil, fmt.Errorf("stat: %w", err)
	}

	nodeType := nodes.TypeFile
	kind := captureKindForFilename(absPath)
	if info.IsDir() {
		nodeType = nodes.TypeFolder
		kind = "folder"
	}
	node, err := a.nodes.Create(nil, nodeType, filepath.Base(absPath), 0, "", "")
	if err != nil {
		return nil, fmt.Errorf("create capture node: %w", err)
	}
	stagingRel, _, err := a.captureStagingDir(node)
	if err != nil {
		return nil, err
	}

	if info.IsDir() {
		if err := a.nodes.UpdateFsPath(node.ID, stagingRel); err != nil {
			return nil, fmt.Errorf("set capture folder path: %w", err)
		}
		entries, err := os.ReadDir(absPath)
		if err != nil {
			return nil, fmt.Errorf("read source dir: %w", err)
		}
		for _, entry := range entries {
			if _, err := a.files.AddPathCopy(node.ID, filepath.Join(absPath, entry.Name())); err != nil {
				return nil, fmt.Errorf("copy capture child %s: %w", entry.Name(), err)
			}
		}
	} else {
		if _, err := a.files.CopyIntoVault(node.ID, absPath, stagingRel); err != nil {
			return nil, fmt.Errorf("copy capture file: %w", err)
		}
	}

	if err := a.setCaptureMeta(node.ID, kind, "drop"); err != nil {
		return nil, err
	}
	target := activity.TargetFile
	evType := activity.TypeFileAdded
	entity := syncsvc.EntityFile
	if info.IsDir() {
		target = activity.TargetFolder
		evType = activity.TypeFolderAdded
		entity = syncsvc.EntityFolder
	}
	_ = a.activity.Record("", target, node.ID, "", evType, node.Title, `{"capture":true}`)
	_ = a.sync.RecordOp(entity, node.ID, syncsvc.OpCreate, a.filePayload(node))
	return a.inboxNodeDTO(node)
}

func (a *App) CaptureFileData(filename, dataBase64 string) (*InboxNodeDTO, error) {
	if err := a.requireVault(); err != nil {
		return nil, err
	}
	filename = filepath.Base(strings.TrimSpace(filename))
	if filename == "." || filename == "" {
		filename = "clipboard.bin"
	}
	if err := files.ValidateName(filename); err != nil {
		return nil, err
	}
	if comma := strings.Index(dataBase64, ","); comma >= 0 {
		dataBase64 = dataBase64[comma+1:]
	}
	data, err := base64.StdEncoding.DecodeString(strings.TrimSpace(dataBase64))
	if err != nil {
		return nil, fmt.Errorf("decode file data: %w", err)
	}
	if len(data) == 0 {
		return nil, fmt.Errorf("file data required")
	}

	node, err := a.nodes.Create(nil, nodes.TypeFile, filename, 0, "", "")
	if err != nil {
		return nil, fmt.Errorf("create capture file node: %w", err)
	}
	stagingRel, stagingAbs, err := a.captureStagingDir(node)
	if err != nil {
		return nil, err
	}
	absPath := filepath.Join(stagingAbs, filename)
	if err := os.WriteFile(absPath, data, 0o640); err != nil {
		return nil, fmt.Errorf("write capture data: %w", err)
	}
	relPath := filepath.Join(stagingRel, filename)
	fileRec := &files.Record{
		ID:          util.UUID7(),
		NodeID:      node.ID,
		Filename:    filename,
		Path:        relPath,
		StorageMode: "vault",
		Size:        int64(len(data)),
		MIME:        mimeForFilename(filename),
		CreatedAt:   time.Now().UTC(),
		UpdatedAt:   time.Now().UTC(),
	}
	if _, err := a.db.Exec(
		`INSERT INTO files (id,node_id,filename,path,storage_mode,size,mime,created_at,updated_at,missing)
		 VALUES (?,?,?,?,?,?,?,?,?,0)`,
		fileRec.ID, fileRec.NodeID, fileRec.Filename, fileRec.Path, fileRec.StorageMode,
		fileRec.Size, fileRec.MIME, fileRec.CreatedAt.Format(time.RFC3339), fileRec.UpdatedAt.Format(time.RFC3339)); err != nil {
		return nil, fmt.Errorf("insert capture file data: %w", err)
	}
	if err := a.setCaptureMeta(node.ID, captureKindForFilename(filename), "clipboard"); err != nil {
		return nil, err
	}
	_ = a.activity.Record("", activity.TargetFile, node.ID, "", activity.TypeFileAdded, filename, `{"capture":true}`)
	_ = a.sync.RecordOp(syncsvc.EntityFile, node.ID, syncsvc.OpCreate, a.filePayload(node))
	return a.inboxNodeDTO(node)
}

func (a *App) createCaptureNote(title, content, kind, source string) (*InboxNodeDTO, error) {
	node, err := a.nodes.Create(nil, nodes.TypeNote, title, 0, "", "")
	if err != nil {
		return nil, fmt.Errorf("create node: %w", err)
	}

	inboxDir := filepath.Join(a.vault, ".verstak", "inbox")
	if err := os.MkdirAll(inboxDir, 0o750); err != nil {
		return nil, fmt.Errorf("create inbox dir: %w", err)
	}
	filename := node.ID + ".md"
	absPath := filepath.Join(inboxDir, filename)
	if err := os.WriteFile(absPath, []byte(content), 0o640); err != nil {
		return nil, fmt.Errorf("write capture note: %w", err)
	}
	relPath, _ := filepath.Rel(a.vault, absPath)
	now := time.Now().UTC()
	fileRec := &files.Record{
		ID:          util.UUID7(),
		NodeID:      node.ID,
		Filename:    filename,
		Path:        relPath,
		StorageMode: "vault",
		Size:        int64(len(content)),
		MIME:        "text/markdown",
		CreatedAt:   now,
		UpdatedAt:   now,
	}
	if _, err := a.db.Exec(
		`INSERT INTO files (id,node_id,filename,path,storage_mode,size,mime,created_at,updated_at,missing)
		 VALUES (?,?,?,?,?,?,?,?,?,0)`,
		fileRec.ID, fileRec.NodeID, fileRec.Filename, fileRec.Path, fileRec.StorageMode,
		fileRec.Size, fileRec.MIME, fileRec.CreatedAt.Format(time.RFC3339), fileRec.UpdatedAt.Format(time.RFC3339)); err != nil {
		return nil, fmt.Errorf("insert capture file: %w", err)
	}
	if _, err := a.db.Exec(`INSERT INTO notes (node_id, file_id, format) VALUES (?,?,?)`, node.ID, fileRec.ID, "markdown"); err != nil {
		return nil, fmt.Errorf("insert capture note: %w", err)
	}
	if err := a.setCaptureMeta(node.ID, kind, source); err != nil {
		return nil, err
	}

	_ = a.activity.Record("", activity.TargetNote, node.ID, "", activity.TypeNoteCreated, title, `{"capture":true}`)
	_ = a.sync.RecordOp(syncsvc.EntityNote, node.ID, syncsvc.OpCreate, notePayload(node, fileRec, content))

	return a.inboxNodeDTO(node)
}

func (a *App) captureStagingDir(node *nodes.Node) (string, string, error) {
	segment := node.ID + "_" + templates.SafeDisplayNameToPathSegment(node.Title)
	rel := filepath.Join(".verstak", "inbox", segment)
	abs := filepath.Join(a.vault, rel)
	if err := os.MkdirAll(abs, 0o750); err != nil {
		return "", "", fmt.Errorf("create inbox staging dir: %w", err)
	}
	return rel, abs, nil
}

func (a *App) setCaptureMeta(nodeID, kind, source string) error {
	if err := a.nodes.MetaSet(nodeID, "capture.inbox", "true"); err != nil {
		return err
	}
	if err := a.nodes.MetaSet(nodeID, "capture.kind", kind); err != nil {
		return err
	}
	if err := a.nodes.MetaSet(nodeID, "capture.source", source); err != nil {
		return err
	}
	return a.nodes.MetaSet(nodeID, "capture.created_at", time.Now().UTC().Format(time.RFC3339))
}

func (a *App) inboxNodeDTO(n *nodes.Node) (*InboxNodeDTO, error) {
	dto := &InboxNodeDTO{NodeDTO: toNodeDTO(n)}
	if kind, ok, err := a.nodes.MetaGet(n.ID, "capture.kind"); err == nil && ok {
		dto.CaptureKind = kind
	}
	if source, ok, err := a.nodes.MetaGet(n.ID, "capture.source"); err == nil && ok {
		dto.CaptureSource = source
	}
	return dto, nil
}

func captureKindForFilename(filename string) string {
	if strings.HasPrefix(mimeForFilename(filename), "image/") {
		return "image"
	}
	return "file"
}

func mimeForFilename(filename string) string {
	ext := strings.ToLower(filepath.Ext(filename))
	switch ext {
	case ".png":
		return "image/png"
	case ".jpg", ".jpeg":
		return "image/jpeg"
	case ".gif":
		return "image/gif"
	case ".webp":
		return "image/webp"
	}
	if mimeType := mime.TypeByExtension(ext); mimeType != "" {
		if semi := strings.Index(mimeType, ";"); semi >= 0 {
			return mimeType[:semi]
		}
		return mimeType
	}
	return "application/octet-stream"
}

func firstLineTitle(text, fallback string) string {
	for _, line := range strings.Split(text, "\n") {
		line = strings.TrimSpace(line)
		if line != "" {
			if len(line) > 80 {
				return line[:80]
			}
			return line
		}
	}
	return fallback
}