package importer

import (
	"archive/zip"
	"bytes"
	"context"
	"os"
	"path/filepath"
	"slices"
	"strings"
	"testing"
	"time"

	"munin/internal/export"
	"munin/internal/store"
)

// testStore öffnet eine frische Datenbank mit einem Projekt.
func testStore(t *testing.T, projectSlug string) (*store.Store, store.Project) {
	t.Helper()
	s, err := store.Open(filepath.Join(t.TempDir(), "test.db"))
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { s.Close() })

	p, err := s.CreateProject(context.Background(), store.NewID(), projectSlug, "Projekt "+projectSlug, "")
	if err != nil {
		t.Fatal(err)
	}
	return s, p
}

// pack baut ein ZIP-Archiv aus Pfad → Inhalt.
func pack(t *testing.T, files map[string]string) []byte {
	t.Helper()
	var buf bytes.Buffer
	w := zip.NewWriter(&buf)
	for filePath, content := range files {
		f, err := w.Create(filePath)
		if err != nil {
			t.Fatal(err)
		}
		f.Write([]byte(content))
	}
	if err := w.Close(); err != nil {
		t.Fatal(err)
	}
	return buf.Bytes()
}

// packDir packt alle Dateien eines Ordners, so wie ein Mensch den
// Exportordner eines Projekts zippen würde.
func packDir(t *testing.T, dir string) []byte {
	t.Helper()
	files := map[string]string{}
	entries, err := os.ReadDir(dir)
	if err != nil {
		t.Fatal(err)
	}
	for _, e := range entries {
		content, err := os.ReadFile(filepath.Join(dir, e.Name()))
		if err != nil {
			t.Fatal(err)
		}
		files["projekt/"+e.Name()] = string(content)
	}
	return pack(t, files)
}

// TestRoundTripFromExport ist der wichtigste Test: Was der Export schreibt,
// kommt beim Import unverändert wieder heraus, samt Schlagworten, Herkunft,
// Autor, Prüfvermerk und Änderungsdatum.
func TestRoundTripFromExport(t *testing.T) {
	ctx := context.Background()
	source, qp := testStore(t, "quelle")

	old := time.Date(2023, 5, 1, 8, 30, 0, 0, time.UTC)
	original := []store.EntryWrite{
		{Slug: "deployment", Title: "Deployment: so geht's", Content: "Schritt 1\n\n# Keine Titelzeile\n\nsiehe [[rollback]]",
			Tags: []string{"ops", "release"}, Source: store.SourceAgent, Author: "agent-1", Curated: true,
			CreatedAt: old, UpdatedAt: old},
		{Slug: "rollback", Title: `Rollback mit "Anführungszeichen"`, Content: "Zurück.\nZweite Zeile",
			Source: store.SourceHuman, Author: "anna"},
	}
	for _, w := range original {
		w.ProjectID = qp.ID
		if _, err := source.PutEntry(ctx, w); err != nil {
			t.Fatal(err)
		}
	}

	exportDir := t.TempDir()
	qp.WorkspaceID = "ws-test"
	if _, err := export.New(exportDir).ExportProject(ctx, source, qp); err != nil {
		t.Fatal(err)
	}

	files, err := ReadZip(packDir(t, filepath.Join(exportDir, "ws-test", "quelle")))
	if err != nil {
		t.Fatal(err)
	}
	if len(files) != 2 {
		t.Fatalf("%d Dateien gelesen, erwartet 2 (_index.md gehört nicht dazu)", len(files))
	}

	target, zp := testStore(t, "ziel")
	report, err := Import(ctx, target, zp.ID, files, Options{Mode: ModeSkip, Author: "importeur"})
	if err != nil {
		t.Fatal(err)
	}
	if report.Created != 2 || report.Failed != 0 {
		t.Fatalf("Bericht: %s — %+v", report.Summary(), report.Rows)
	}

	for _, w := range original {
		a, _ := source.EntryBySlug(ctx, qp.ID, w.Slug)
		b, err := target.EntryBySlug(ctx, zp.ID, w.Slug)
		if err != nil {
			t.Fatalf("%s fehlt nach dem Import: %v", w.Slug, err)
		}
		if a.Title != b.Title || a.Content != b.Content || !slices.Equal(a.Tags, b.Tags) ||
			a.Source != b.Source || a.Author != b.Author || a.Curated != b.Curated {
			t.Errorf("%s nach dem Import verändert:\nvorher  %+v\nnachher %+v", w.Slug, a, b)
		}
		if !a.UpdatedAt.Truncate(time.Second).Equal(b.UpdatedAt) {
			t.Errorf("%s: Änderungsdatum %v, erwartet %v", w.Slug, b.UpdatedAt, a.UpdatedAt)
		}
	}

	// Die Verweise sind wieder da, rollback wird von deployment verlinkt.
	back, _ := target.Backlinks(ctx, zp.ID, "rollback")
	if len(back) != 1 || back[0].Slug != "deployment" {
		t.Errorf("Rückverweise nach dem Import: %+v", back)
	}

	// Ein zweiter Lauf ändert nichts und erzeugt keine neuen Fassungen.
	again, err := Import(ctx, target, zp.ID, files, Options{Mode: ModeOverwrite, Author: "importeur"})
	if err != nil {
		t.Fatal(err)
	}
	if again.Unchanged != 2 {
		t.Errorf("zweiter Lauf: %s, erwartet 2 unverändert", again.Summary())
	}
}

// TestRoundTripFromDownload: Das ZIP aus dem Download (export.WriteZIP)
// muss ohne Umweg wieder in den Import passen — genau dafür ist es da.
func TestRoundTripFromDownload(t *testing.T) {
	ctx := context.Background()
	source, qp := testStore(t, "quelle")

	for _, w := range []store.EntryWrite{
		{Slug: "deployment", Title: "Deployment", Content: "siehe [[rollback]]", Tags: []string{"ops"}, Source: store.SourceAgent, Author: "agent-1"},
		{Slug: "rollback", Title: "Rollback", Content: "Zurück.", Source: store.SourceHuman, Author: "anna"},
	} {
		w.ProjectID = qp.ID
		if _, err := source.PutEntry(ctx, w); err != nil {
			t.Fatal(err)
		}
	}

	files, err := export.ProjectFiles(ctx, source, qp)
	if err != nil {
		t.Fatal(err)
	}
	var zip bytes.Buffer
	if err := export.WriteZIP(&zip, files); err != nil {
		t.Fatal(err)
	}

	read, err := ReadZip(zip.Bytes())
	if err != nil {
		t.Fatal(err)
	}
	target, zp := testStore(t, "ziel")
	report, err := Import(ctx, target, zp.ID, read, Options{Mode: ModeSkip, Author: "importeur"})
	if err != nil {
		t.Fatal(err)
	}
	if report.Created != 2 || report.Failed != 0 {
		t.Fatalf("Bericht: %s — %+v", report.Summary(), report.Rows)
	}

	for _, slug := range []string{"deployment", "rollback"} {
		a, _ := source.EntryBySlug(ctx, qp.ID, slug)
		b, err := target.EntryBySlug(ctx, zp.ID, slug)
		if err != nil {
			t.Fatalf("%s fehlt nach dem Import: %v", slug, err)
		}
		if a.Title != b.Title || a.Content != b.Content || !slices.Equal(a.Tags, b.Tags) || a.Author != b.Author {
			t.Errorf("%s nach dem Import verändert:\nvorher  %+v\nnachher %+v", slug, a, b)
		}
	}
}

func TestConflictModes(t *testing.T) {
	ctx := context.Background()
	s, p := testStore(t, "test")

	if _, err := s.PutEntry(ctx, store.EntryWrite{
		ProjectID: p.ID, Slug: "vorhanden", Title: "Vorhanden", Content: "alt",
		Source: store.SourceHuman, Author: "anna",
	}); err != nil {
		t.Fatal(err)
	}

	files := []File{
		{Path: "vorhanden.md", Content: []byte("# Vorhanden\n\nneu")},
		{Path: "frisch.md", Content: []byte("# Frisch\n\nText")},
	}

	// Preview schreibt nichts.
	preview, err := Import(ctx, s, p.ID, files, Options{Mode: ModeOverwrite, Preview: true, Author: "imp"})
	if err != nil {
		t.Fatal(err)
	}
	if preview.Created != 1 || preview.Overwritten != 1 || len(preview.Written) != 0 {
		t.Errorf("Vorschau: %s", preview.Summary())
	}
	if _, err := s.EntryBySlug(ctx, p.ID, "frisch"); err == nil {
		t.Error("die Vorschau hat geschrieben")
	}

	// Überspringen lässt Vorhandenes in Ruhe.
	over, _ := Import(ctx, s, p.ID, files, Options{Mode: ModeSkip, Author: "imp"})
	if over.Created != 1 || over.Skipped != 1 {
		t.Errorf("Überspringen: %s", over.Summary())
	}
	if e, _ := s.EntryBySlug(ctx, p.ID, "vorhanden"); e.Content != "alt" {
		t.Error("Überspringen hat überschrieben")
	}

	// Überschreiben legt eine neue Fassung an, die alte steht im Verlauf.
	newer, _ := Import(ctx, s, p.ID, files, Options{Mode: ModeOverwrite, Author: "imp"})
	if newer.Overwritten != 1 || newer.Unchanged != 1 {
		t.Errorf("Überschreiben: %s", newer.Summary())
	}
	e, _ := s.EntryBySlug(ctx, p.ID, "vorhanden")
	if e.Content != "neu" || e.Version != 2 || e.Author != "imp" {
		t.Errorf("nach dem Überschreiben: Inhalt %q, Fassung %d, Autor %q", e.Content, e.Version, e.Author)
	}
}

// TestTrashIsNotRevivedWhenSkipping prüft, dass ein Import im Modus
// „Überspringen“ keinen gelöschten Eintrag zurückholt.
func TestTrashIsNotRevivedWhenSkipping(t *testing.T) {
	ctx := context.Background()
	s, p := testStore(t, "test")

	s.PutEntry(ctx, store.EntryWrite{ProjectID: p.ID, Slug: "weg", Title: "Weg", Content: "x", Source: store.SourceHuman})
	if err := s.MoveEntryToTrash(ctx, p.ID, "weg", "anna"); err != nil {
		t.Fatal(err)
	}

	files := []File{{Path: "weg.md", Content: []byte("# Weg\n\nwieder da")}}
	b, _ := Import(ctx, s, p.ID, files, Options{Mode: ModeSkip})
	if b.Skipped != 1 || !strings.Contains(b.Rows[0].Reason, "Papierkorb") {
		t.Errorf("Bericht: %s, Grund %q", b.Summary(), b.Rows[0].Reason)
	}
	if _, err := s.EntryBySlug(ctx, p.ID, "weg"); err == nil {
		t.Error("der gelöschte Eintrag wurde zurückgeholt")
	}
}

func TestDuplicateSlugInArchive(t *testing.T) {
	ctx := context.Background()
	s, p := testStore(t, "test")

	files := []File{
		{Path: "ops/deploy.md", Content: []byte("eins")},
		{Path: "alt/deploy.md", Content: []byte("zwei")},
	}
	b, _ := Import(ctx, s, p.ID, files, Options{Mode: ModeSkip})
	if b.Created != 1 || b.Failed != 1 || !strings.Contains(b.Rows[1].Reason, "ops/deploy.md") {
		t.Errorf("Bericht: %s — %+v", b.Summary(), b.Rows)
	}
}

func TestParsePlainMarkdown(t *testing.T) {
	e, err := Parse("Doku/Mein Leitfaden.md", []byte("\uFEFF# Leitfaden für Neue\r\n\r\nErster Absatz.\r\n"))
	if err != nil {
		t.Fatal(err)
	}
	if e.Slug != "mein-leitfaden" || e.Title != "Leitfaden für Neue" || e.Content != "Erster Absatz." {
		t.Errorf("gelesen: %+v", e)
	}

	noHeading, err := Parse("notiz.md", []byte("Nur Text"))
	if err != nil {
		t.Fatal(err)
	}
	if noHeading.Title != "notiz" {
		t.Errorf("Titel ohne Überschrift: %q", noHeading.Title)
	}
}

func TestParseForeignFrontmatter(t *testing.T) {
	file := `---
title: 'It''s a title'
date: 2024-01-01
tags:
  - Ops
  - "release notes"
draft: false
---

Inhalt`
	e, err := Parse("post.md", []byte(file))
	if err != nil {
		t.Fatal(err)
	}
	if e.Title != "It's a title" || !slices.Equal(e.Tags, []string{"Ops", "release notes"}) || e.Content != "Inhalt" {
		t.Errorf("gelesen: %+v", e)
	}
}

func TestParseInlineListWithCommaInQuotes(t *testing.T) {
	e, err := Parse("x.md", []byte("---\ntags: [\"a, b\", c]\n---\nText"))
	if err != nil {
		t.Fatal(err)
	}
	if !slices.Equal(e.Tags, []string{"a, b", "c"}) {
		t.Errorf("Schlagworte: %q", e.Tags)
	}
}

func TestParseRejects(t *testing.T) {
	cases := map[string]string{
		"offener Kopf":         "---\ntitle: x\nText ohne Ende",
		"leer":                 "---\ntitle: x\n---\n\n",
		"ungültiger slug":      "---\nslug: \"Mit Leerzeichen\"\n---\nText",
		"nur eine Überschrift": "# Titel\n",
	}
	for name, content := range cases {
		if _, err := Parse("x.md", []byte(content)); err == nil {
			t.Errorf("%s: kein Fehler", name)
		}
	}
}

func TestReadZipSkipsAndLimits(t *testing.T) {
	archive := pack(t, map[string]string{
		"projekt/_index.md":              "Übersicht",
		"projekt/eintrag.md":             "Text",
		"projekt/bild.png":               "PNG",
		"__MACOSX/projekt/._eintrag.md":  "Müll",
		"projekt/.obsidian/workspace.md": "Einstellungen",
	})
	files, err := ReadZip(archive)
	if err != nil {
		t.Fatal(err)
	}
	if len(files) != 1 || files[0].Path != "projekt/eintrag.md" {
		t.Errorf("gelesen: %+v", files)
	}

	tooLarge := pack(t, map[string]string{"gross.md": strings.Repeat("x", MaxFileBytes+1)})
	if _, err := ReadZip(tooLarge); err == nil {
		t.Error("eine zu große Datei wurde angenommen")
	}

	if _, err := ReadZip([]byte("kein zip")); err == nil {
		t.Error("Unsinn wurde als Archiv angenommen")
	}
	if _, err := ReadZip(pack(t, map[string]string{"bild.png": "x"})); err == nil {
		t.Error("ein Archiv ohne Markdown wurde angenommen")
	}
}