package officekit

import (
	"strings"
	"testing"
)

func TestReplaceDocxTextTrackedRoundTrip(t *testing.T) {
	data := minimalWordDoc(t)
	out, n, err := ReplaceDocxTextTracked(data, "cell one text", "updated cell text", "Reviewer A")
	if err != nil {
		t.Fatalf("ReplaceDocxTextTracked: %v", err)
	}
	if n != 1 {
		t.Fatalf("expected 1 run changed, got %d", n)
	}

	// Plain read-back should show the NEW text (deleted text is review
	// chrome, not live content) and still see the untouched paragraph.
	text, err := ReadDocxText(out)
	if err != nil {
		t.Fatalf("ReadDocxText: %v", err)
	}
	if !strings.Contains(text, "updated cell text") {
		t.Errorf("expected new text in read-back, got: %s", text)
	}
	if !strings.Contains(text, "Intro paragraph.") {
		t.Errorf("unrelated paragraph lost: %s", text)
	}

	revisions, err := ReadDocxRevisions(out)
	if err != nil {
		t.Fatalf("ReadDocxRevisions: %v", err)
	}
	for _, want := range []string{"Reviewer A", "cell one text", "updated cell text"} {
		if !strings.Contains(revisions, want) {
			t.Errorf("expected revisions summary to contain %q, got:\n%s", want, revisions)
		}
	}

	raw, ok, err := readZipPart(out, docxDocumentPart)
	if err != nil || !ok {
		t.Fatalf("readZipPart: ok=%v err=%v", ok, err)
	}
	body := string(raw)
	if !strings.Contains(body, "<del ") || !strings.Contains(body, "<ins ") {
		t.Errorf("expected <del>/<ins> elements in document.xml, got:\n%s", body)
	}
}

func TestAppendDocxParagraphTrackedThenAccept(t *testing.T) {
	data := minimalWordDoc(t)
	out, err := AppendDocxParagraphTracked(data, Paragraph{Text: "Pending new line."}, "")
	if err != nil {
		t.Fatalf("AppendDocxParagraphTracked: %v", err)
	}
	revisions, err := ReadDocxRevisions(out)
	if err != nil {
		t.Fatalf("ReadDocxRevisions: %v", err)
	}
	if !strings.Contains(revisions, "enkly agent") || !strings.Contains(revisions, "Pending new line.") {
		t.Errorf("expected default author + inserted text in revisions, got:\n%s", revisions)
	}

	accepted, err := AcceptAllDocxChanges(out)
	if err != nil {
		t.Fatalf("AcceptAllDocxChanges: %v", err)
	}
	text, err := ReadDocxText(accepted)
	if err != nil {
		t.Fatalf("ReadDocxText: %v", err)
	}
	if !strings.Contains(text, "Pending new line.") {
		t.Errorf("expected accepted insertion to survive as plain text, got: %s", text)
	}
	if noRev, err := ReadDocxRevisions(accepted); err != nil || noRev != "" {
		t.Errorf("expected no revisions left after accept, got %q (err=%v)", noRev, err)
	}
}

func TestReplaceDocxTextTrackedThenReject(t *testing.T) {
	data := minimalWordDoc(t)
	out, _, err := ReplaceDocxTextTracked(data, "Intro paragraph.", "Rewritten intro.", "Reviewer B")
	if err != nil {
		t.Fatalf("ReplaceDocxTextTracked: %v", err)
	}
	rejected, err := RejectAllDocxChanges(out)
	if err != nil {
		t.Fatalf("RejectAllDocxChanges: %v", err)
	}
	text, err := ReadDocxText(rejected)
	if err != nil {
		t.Fatalf("ReadDocxText: %v", err)
	}
	if !strings.Contains(text, "Intro paragraph.") {
		t.Errorf("expected original text restored after reject, got: %s", text)
	}
	if strings.Contains(text, "Rewritten intro.") {
		t.Errorf("rejected insertion should not survive, got: %s", text)
	}
	if noRev, err := ReadDocxRevisions(rejected); err != nil || noRev != "" {
		t.Errorf("expected no revisions left after reject, got %q (err=%v)", noRev, err)
	}
}

func TestReadDocxRevisionsEmptyWhenNoChanges(t *testing.T) {
	revisions, err := ReadDocxRevisions(minimalWordDoc(t))
	if err != nil {
		t.Fatalf("ReadDocxRevisions: %v", err)
	}
	if revisions != "" {
		t.Errorf("expected no revisions in a plain document, got: %s", revisions)
	}
}