package archive

import (
	"archive/tar"
	"cmp"
	"fmt"
	"io"
	"os"
	"path"
	"runtime"
	"slices"
	"testing"

	"go.podman.io/storage/pkg/idtools"
)

func TestHardLinkOrder(t *testing.T) {
	// TODO Should run for Solaris
	if runtime.GOOS == "solaris" {
		t.Skip("gcp failures on Solaris")
	}
	names := []string{"file1.txt", "file2.txt", "file3.txt"}
	msg := []byte("Hey y'all")

	// Create dir
	src := t.TempDir()
	for _, name := range names {
		func() {
			fh, err := os.Create(path.Join(src, name))
			if err != nil {
				t.Fatal(err)
			}
			defer fh.Close()
			if _, err = fh.Write(msg); err != nil {
				t.Fatal(err)
			}
		}()
	}
	// Create dest, with changes that includes hardlinks
	dest := t.TempDir()
	os.RemoveAll(dest) // we just want the name, at first
	if err := copyDir(src, dest); err != nil {
		t.Fatal(err)
	}
	for _, name := range names {
		for i := range 5 {
			if err := os.Link(path.Join(dest, name), path.Join(dest, fmt.Sprintf("%s.link%d", name, i))); err != nil {
				t.Fatal(err)
			}
		}
	}

	// get changes
	changes, err := ChangesDirs(dest, &idtools.IDMappings{}, src, &idtools.IDMappings{})
	if err != nil {
		t.Fatal(err)
	}

	// sort
	slices.SortFunc(changes, compareChangesByPath)

	// ExportChanges
	ar, err := ExportChanges(dest, changes, nil, nil)
	if err != nil {
		t.Fatal(err)
	}
	hdrs, err := walkHeaders(ar)
	if err != nil {
		t.Fatal(err)
	}

	// reverse sort
	slices.SortFunc(changes, func(a, b Change) int {
		return -compareChangesByPath(a, b)
	})
	// ExportChanges
	arRev, err := ExportChanges(dest, changes, nil, nil)
	if err != nil {
		t.Fatal(err)
	}
	hdrsRev, err := walkHeaders(arRev)
	if err != nil {
		t.Fatal(err)
	}

	// line up the two sets
	slices.SortFunc(hdrs, compareTarHeaders)
	slices.SortFunc(hdrsRev, compareTarHeaders)

	// compare Size and LinkName
	for i := range hdrs {
		if hdrs[i].Name != hdrsRev[i].Name {
			t.Errorf("headers - expected name %q; but got %q", hdrs[i].Name, hdrsRev[i].Name)
		}
		if hdrs[i].Size != hdrsRev[i].Size {
			t.Errorf("headers - %q expected size %d; but got %d", hdrs[i].Name, hdrs[i].Size, hdrsRev[i].Size)
		}
		if hdrs[i].Typeflag != hdrsRev[i].Typeflag {
			t.Errorf("headers - %q expected type %d; but got %d", hdrs[i].Name, hdrs[i].Typeflag, hdrsRev[i].Typeflag)
		}
		if hdrs[i].Linkname != hdrsRev[i].Linkname {
			t.Errorf("headers - %q expected linkname %q; but got %q", hdrs[i].Name, hdrs[i].Linkname, hdrsRev[i].Linkname)
		}
	}
}

func compareTarHeaders(a, b tar.Header) int {
	return cmp.Compare(a.Name, b.Name)
}

func walkHeaders(r io.Reader) ([]tar.Header, error) {
	t := tar.NewReader(r)
	headers := []tar.Header{}
	for {
		hdr, err := t.Next()
		if err != nil {
			if err == io.EOF {
				break
			}
			return headers, err
		}
		headers = append(headers, *hdr)
	}
	return headers, nil
}
