patchwork

package main

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"os"
	"strconv"
	"strings"

	"git.pablomurad.com/pablo/patchwork/internal/diff"
	"git.pablomurad.com/pablo/patchwork/internal/doc"
	"git.pablomurad.com/pablo/patchwork/internal/store"
)

// findPage accepts a slug or a path relative to the source folder.
func (a *app) findPage(ctx context.Context, ref string) (*store.Page, error) {
	p, err := a.store.PageBySlug(ctx, ref)
	if errors.Is(err, store.ErrNotFound) {
		p, err = a.store.PageByPath(ctx, a.engine.Source, strings.TrimPrefix(ref, "./"))
	}
	if errors.Is(err, store.ErrNotFound) {
		return nil, fmt.Errorf("no page with slug or path %q", ref)
	}
	return p, err
}

func cmdLog(ctx context.Context, args []string) error {
	fs := newFlags("log", "<slug|path>")
	cfgPath := configFlag(fs)
	if err := fs.Parse(args); err != nil {
		return err
	}
	if fs.NArg() != 1 {
		fs.Usage()
		return errProblems
	}
	a, err := openApp(*cfgPath)
	if err != nil {
		return err
	}
	defer a.Close()

	p, err := a.findPage(ctx, fs.Arg(0))
	if err != nil {
		return err
	}
	revs, err := a.store.Revisions(ctx, p.ID)
	if err != nil {
		return err
	}
	snaps, err := a.store.SnapshotCount(ctx, p.ID)
	if err != nil {
		return err
	}
	last, err := a.store.LastSnapshot(ctx, p.ID)
	if err != nil {
		return err
	}

	fmt.Fprintf(stdout, "%s  (%s)\n", orDash(last.Title), p.Path)
	fmt.Fprintf(stdout, "slug %s · first published %s · maturity %s\n", orDash(p.Slug), p.OriginalDate, orDash(last.Maturity))
	fmt.Fprintf(stdout, "%d public versions, %d snapshots", len(revs), snaps)
	if p.RemovedAt != nil {
		fmt.Fprintf(stdout, " · removed %s", shortTime(*p.RemovedAt))
	}
	fmt.Fprintln(stdout)
	fmt.Fprintln(stdout)
	for i := len(revs) - 1; i >= 0; i-- {
		r := revs[i]
		if r.Baseline() {
			fmt.Fprintf(stdout, "#1  %s  baseline\n", shortTime(r.PublishedAt))
			continue
		}
		line := fmt.Sprintf("#%d  %s  %-14s +%d -%d  %s", r.Number, shortTime(r.PublishedAt), orDash(r.Kind), r.WordsAdded, r.WordsRemoved, r.Note)
		if r.RetractedAt != nil {
			line += "  (retracted)"
		} else if !r.UpdatedAt.Equal(r.PublishedAt) {
			line += fmt.Sprintf("  (updated %s)", shortTime(r.UpdatedAt))
		}
		fmt.Fprintln(stdout, line)
	}
	return nil
}

func cmdDiff(ctx context.Context, args []string) error {
	fs := newFlags("diff", "<slug|path> [n | a b]")
	cfgPath := configFlag(fs)
	plain := fs.Bool("plain", false, "no colors")
	if err := fs.Parse(args); err != nil {
		return err
	}
	if fs.NArg() < 1 || fs.NArg() > 3 {
		fs.Usage()
		return errProblems
	}
	a, err := openApp(*cfgPath)
	if err != nil {
		return err
	}
	defer a.Close()

	p, err := a.findPage(ctx, fs.Arg(0))
	if err != nil {
		return err
	}
	nums := make([]int, 0, 2)
	for _, s := range fs.Args()[1:] {
		n, err := strconv.Atoi(strings.TrimPrefix(s, "#"))
		if err != nil {
			return fmt.Errorf("version %q is not a number", s)
		}
		nums = append(nums, n)
	}

	var to *store.Revision
	if len(nums) == 0 {
		to, err = a.store.LastRevision(ctx, p.ID)
	} else {
		to, err = a.store.RevisionByNumber(ctx, p.ID, nums[len(nums)-1])
	}
	if err != nil {
		return fmt.Errorf("version: %w", err)
	}
	var from *store.Revision
	if len(nums) == 2 {
		from, err = a.store.RevisionByNumber(ctx, p.ID, nums[0])
	} else {
		from, err = a.store.RevisionBefore(ctx, p.ID, to.Number)
	}
	if errors.Is(err, store.ErrNotFound) {
		fmt.Fprintf(stdout, "#%d is the first version; nothing to compare it with\n", to.Number)
		return nil
	}
	if err != nil {
		return err
	}

	var full diff.Full
	cached := len(nums) < 2 && to.DiffJSON != "" && to.DiffVersion == diff.Version
	if cached {
		err = json.Unmarshal([]byte(to.DiffJSON), &full)
	} else {
		full, err = a.compare(ctx, from, to)
	}
	if err != nil {
		return err
	}

	color := !*plain && os.Getenv("NO_COLOR") == "" && isTerminal(os.Stdout)
	fmt.Fprintf(stdout, "#%d → #%d", from.Number, to.Number)
	if to.Note != "" && !to.Baseline() {
		fmt.Fprintf(stdout, "  %q", to.Note)
	}
	fmt.Fprintf(stdout, "  (+%d -%d words)\n\n", full.Stats.WordsAdded, full.Stats.WordsRemoved)
	printDiff(full, color)
	return nil
}

func (a *app) compare(ctx context.Context, from, to *store.Revision) (diff.Full, error) {
	fs, err := a.store.Snapshot(ctx, from.SnapshotID)
	if err != nil {
		return diff.Full{}, err
	}
	ts, err := a.store.Snapshot(ctx, to.SnapshotID)
	if err != nil {
		return diff.Full{}, err
	}
	opt := a.cfg.DocOptions()
	return diff.Compare(doc.Parse([]byte(fs.Raw), opt), doc.Parse([]byte(ts.Raw), opt), opt.DiffKeys), nil
}

const (
	ansiRed   = "\x1b[31m"
	ansiGreen = "\x1b[32m"
	ansiDim   = "\x1b[2m"
	ansiReset = "\x1b[0m"
)

func printDiff(full diff.Full, color bool) {
	paint := func(code, s string) string {
		if !color || s == "" {
			return s
		}
		return code + s + ansiReset
	}
	for _, m := range full.Meta {
		fmt.Fprintf(stdout, "%s: %s → %s\n", m.Key, paint(ansiRed, metaValue(m.Old)), paint(ansiGreen, metaValue(m.New)))
	}
	if len(full.Meta) > 0 {
		fmt.Fprintln(stdout)
	}
	ops, _ := diff.Excerpt(full.Ops, 1, len(full.Ops))
	for _, op := range ops {
		switch op.Op {
		case diff.OpGap:
			fmt.Fprintln(stdout, paint(ansiDim, fmt.Sprintf("  … %d unchanged", op.Count)))
		case diff.OpEq:
			fmt.Fprintln(stdout, paint(ansiDim, marked("  ", op.Text)))
		case diff.OpInsert:
			fmt.Fprintln(stdout, paint(ansiGreen, marked("+ ", op.Text)))
		case diff.OpDelete:
			fmt.Fprintln(stdout, paint(ansiRed, marked("- ", op.Text)))
		case diff.OpMove:
			fmt.Fprintf(stdout, "↕ (moved from block %d)\n%s\n", *op.From+1, marked("  ", op.Text))
		case diff.OpModify:
			var b strings.Builder
			b.WriteString("~ ")
			for _, s := range op.Segments {
				switch s.T {
				case diff.SegDel:
					if color {
						b.WriteString(paint(ansiRed, s.S))
					} else {
						b.WriteString("[-" + s.S + "-]")
					}
				case diff.SegIns:
					if color {
						b.WriteString(paint(ansiGreen, s.S))
					} else {
						b.WriteString("{+" + s.S + "+}")
					}
				default:
					b.WriteString(s.S)
				}
			}
			fmt.Fprintln(stdout, strings.ReplaceAll(b.String(), "\n", "\n  "))
		}
		fmt.Fprintln(stdout)
	}
}

// marked prefixes a block's first line and indents the rest under it.
func marked(prefix, text string) string {
	return prefix + strings.ReplaceAll(text, "\n", "\n"+strings.Repeat(" ", len(prefix)))
}

func metaValue(v any) string {
	if v == nil {
		return "(none)"
	}
	return fmt.Sprint(v)
}

func isTerminal(f *os.File) bool {
	fi, err := f.Stat()
	return err == nil && fi.Mode()&os.ModeCharDevice != 0
}

func orDash(s string) string {
	if s == "" {
		return "-"
	}
	return s
}