// Copyright 2026 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package gentools

import (
	"bytes"
	"fmt"
	"os"
	"path/filepath"
	"strings"
	"testing"
)

func TestGoFileFormatting(t *testing.T) {
	t.Parallel()

	var outBuf bytes.Buffer
	var files Files
	files.Options = &Options{
		Txtar:  true,
		Output: &outBuf,
	}

	buf := files.NewGoFile("test.go")
	buf.WriteString("package test\nfunc Foo() int { return 42 }\n")

	err := files.Flush()
	if err != nil {
		t.Fatalf("Flush failed: %v", err)
	}

	outStr := outBuf.String()
	expected := "-- src/test.go --\npackage test\n\nfunc Foo() int { return 42 }\n"
	if outStr != expected {
		t.Errorf("got txtar output:\n%q\nwant:\n%q", outStr, expected)
	}
}

func TestFormattingError(t *testing.T) {
	t.Parallel()

	var errBuf bytes.Buffer
	var files Files
	files.Options = &Options{
		ErrOutput: &errBuf,
	}

	buf := files.NewGoFile("bad.go")
	buf.WriteString("package test\n\tfunc Foo( {\n") // invalid syntax with tab indentation

	err := files.Flush()
	if err == nil {
		t.Fatalf("expected formatting error, got nil")
	}
	if !strings.Contains(err.Error(), "error formatting bad.go") {
		t.Errorf("unexpected error message: %v", err)
	}

	const expectedErrOutput = "package test\n\tfunc Foo( {\n\t          ^\n2:12: expected ')', found '{'\n"
	if errBuf.String() != expectedErrOutput {
		t.Errorf("got error output:\n%q\nwant:\n%q", errBuf.String(), expectedErrOutput)
	}
}

func TestWriteMode(t *testing.T) {
	t.Parallel()

	tmpDir := t.TempDir()
	var files Files
	files.Options = &Options{
		GOROOT: tmpDir,
		Write:  true,
	}

	gobuf := files.NewGoFile("pkg/a.go")
	gobuf.WriteString("package pkg\nconst X = 1\n")

	const expectedRawContent = "raw content\n"
	rawbuf := files.NewRawFile("pkg/a.txt")
	rawbuf.WriteString(expectedRawContent)

	if err := files.Flush(); err != nil {
		t.Fatalf("Flush failed: %v", err)
	}

	aGo, err := os.ReadFile(filepath.Join(tmpDir, "src", "pkg", "a.go"))
	if err != nil {
		t.Fatalf("reading a.go: %v", err)
	}
	if string(aGo) != "package pkg\n\nconst X = 1\n" {
		t.Errorf("unexpected a.go content: %q", string(aGo))
	}

	aTxt, err := os.ReadFile(filepath.Join(tmpDir, "src", "pkg", "a.txt"))
	if err != nil {
		t.Fatalf("reading a.txt: %v", err)
	}
	if string(aTxt) != expectedRawContent {
		t.Errorf("unexpected a.txt content: %q", string(aTxt))
	}
}

func TestWriteAsideMode(t *testing.T) {
	t.Parallel()

	tmpDir := t.TempDir()
	tmpDir2 := t.TempDir()
	var files Files
	files.Options = &Options{
		GOROOT: tmpDir,
		outDir: tmpDir2,
		Write:  true,
	}

	gobuf := files.NewGoFile("pkg/a.go")
	gobuf.WriteString("package pkg\nconst X = 1\n")

	const expectedRawContent = "raw content\n"
	rawbuf := files.NewRawFile("pkg/a.txt")
	rawbuf.WriteString(expectedRawContent)

	if err := files.Flush(); err != nil {
		t.Fatalf("Flush failed: %v", err)
	}

	aGo, err := os.ReadFile(filepath.Join(tmpDir2, "src", "pkg", "a.go"))
	if err != nil {
		t.Fatalf("reading a.go: %v", err)
	}
	if string(aGo) != "package pkg\n\nconst X = 1\n" {
		t.Errorf("unexpected a.go content: %q", string(aGo))
	}

	aTxt, err := os.ReadFile(filepath.Join(tmpDir2, "src", "pkg", "a.txt"))
	if err != nil {
		t.Fatalf("reading a.txt: %v", err)
	}
	if string(aTxt) != expectedRawContent {
		t.Errorf("unexpected a.txt content: %q", string(aTxt))
	}
}

func TestWriteAsideRefusesOverwrite(t *testing.T) {
	t.Parallel()

	tmpDir := t.TempDir()
	outDir := t.TempDir()

	// Pre-create a file in the output directory
	existingFile := filepath.Join(outDir, "src", "pkg", "a.go")
	if err := os.MkdirAll(filepath.Dir(existingFile), 0755); err != nil {
		t.Fatal(err)
	}
	if err := os.WriteFile(existingFile, []byte("existing"), 0644); err != nil {
		t.Fatal(err)
	}

	var files Files
	files.Options = &Options{
		GOROOT: tmpDir,
		outDir: outDir,
		Write:  true,
	}

	defer func() {
		r := recover()
		if r == nil {
			t.Fatalf("expected panic when creating file that exists in output directory, got none")
		}
		msg, ok := r.(string)
		if !ok || !strings.Contains(msg, "file already exists in output directory") {
			t.Errorf("unexpected panic message: %v", r)
		}
	}()

	files.NewGoFile("pkg/a.go")
}

func TestDuplicateFileCreationPanics(t *testing.T) {
	t.Parallel()

	var files Files
	files.NewGoFile("pkg/a.go")

	defer func() {
		r := recover()
		if r == nil {
			t.Fatalf("expected panic on duplicate file creation, got none")
		}
		msg, ok := r.(string)
		if !ok || !strings.Contains(msg, "generator already created file") {
			t.Errorf("unexpected panic message: %v", r)
		}
	}()

	files.NewGoFile("pkg/a.go")
}

func TestDiffMode(t *testing.T) {
	t.Parallel()

	tmpDir := t.TempDir()
	targetFile := filepath.Join(tmpDir, "src", "pkg", "a.go")
	os.MkdirAll(filepath.Dir(targetFile), 0755)
	os.WriteFile(targetFile, []byte("package pkg\n\nconst X = 1\n"), 0644)

	// Test matching content
	var files1 Files
	files1.Options = &Options{
		GOROOT: tmpDir,
		Diff:   true,
	}
	buf1 := files1.NewGoFile("pkg/a.go")
	buf1.WriteString("package pkg\nconst X = 1\n")
	if err := files1.Flush(); err != nil {
		t.Errorf("expected no diff error, got: %v", err)
	}

	// Test non-matching content
	var outBuf bytes.Buffer
	var files2 Files
	files2.Options = &Options{
		GOROOT: tmpDir,
		Diff:   true,
		Output: &outBuf,
	}
	buf2 := files2.NewGoFile("pkg/a.go")
	buf2.WriteString("package pkg\nconst X = 2\n")

	err := files2.Flush()
	if err == nil {
		t.Errorf("expected diff error, got nil")
	}

	if !strings.Contains(outBuf.String(), "-const X = 1") || !strings.Contains(outBuf.String(), "+const X = 2") {
		t.Errorf("unexpected diff output:\n%s", outBuf.String())
	}
}

func TestPostProcessor(t *testing.T) {
	t.Parallel()

	var outBuf bytes.Buffer
	var files Files
	files.Options = &Options{
		Txtar:  true,
		Output: &outBuf,
	}

	files.AddPostProcessor(func(relPath string, isGo bool, content []byte) ([]byte, error) {
		if !isGo {
			return append([]byte("# header\n"), content...), nil
		}
		// In Go files, replace Bar with Baz
		return bytes.ReplaceAll(content, []byte("Bar"), []byte("Baz")), nil
	})

	goBuf := files.NewGoFile("test.go")
	goBuf.WriteString("package test\nfunc Bar() int { return 1 }\n")

	rawBuf := files.NewRawFile("test.txt")
	rawBuf.WriteString("hello\n")

	if err := files.Flush(); err != nil {
		t.Fatalf("Flush failed: %v", err)
	}

	outStr := outBuf.String()
	expected := "-- src/test.go --\npackage test\n\nfunc Baz() int { return 1 }\n\n-- src/test.txt --\n# header\nhello\n"
	if outStr != expected {
		t.Errorf("got txtar output:\n%q\nwant:\n%q", outStr, expected)
	}
}

func TestPostProcessorError(t *testing.T) {
	t.Parallel()

	var files Files
	files.Options = &Options{
		Txtar:  true,
		Output: &bytes.Buffer{},
	}

	files.AddPostProcessor(func(relPath string, isGo bool, content []byte) ([]byte, error) {
		if relPath == "bad.go" {
			return nil, fmt.Errorf("custom hook error on %s", relPath)
		}
		return content, nil
	})

	buf := files.NewGoFile("bad.go")
	buf.WriteString("package test\n")

	err := files.Flush()
	if err == nil {
		t.Fatalf("expected post-processor error, got nil")
	}
	if !strings.Contains(err.Error(), "custom hook error on bad.go") {
		t.Errorf("unexpected error: %v", err)
	}
}