package push

import (
	"archive/zip"
	"bytes"
	"io"
	"os"
	"path/filepath"
	"reflect"
	"sort"
	"testing"
)

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

	cases := []struct {
		name    string
		env     map[string]string
		want    *Config
		wantErr bool
	}{
		{
			name: "minimal",
			env:  map[string]string{"name": "foo", "path": "dist"},
			want: &Config{Name: "foo", Path: "dist"},
		},
		{
			name: "patterns",
			env:  map[string]string{"name": "foo", "path": "dist", "pattern": "**/*.go\n\n!main.go\n"},
			want: &Config{Name: "foo", Path: "dist", Patterns: []string{"**/*.go", "!main.go"}},
		},
		{
			name:    "missing name",
			env:     map[string]string{"path": "dist"},
			wantErr: true,
		},
		{
			name:    "missing path",
			env:     map[string]string{"name": "foo"},
			wantErr: true,
		},
	}

	for _, tc := range cases {
		tc := tc
		t.Run(tc.name, func(t *testing.T) {
			t.Parallel()

			got, err := ParseConfig(func(k string) string { return tc.env[k] })
			if tc.wantErr {
				if err == nil {
					t.Fatalf("expected error, got %+v", got)
				}
				return
			}
			if err != nil {
				t.Fatal(err)
			}
			if !reflect.DeepEqual(got, tc.want) {
				t.Errorf("expected %+v, got %+v", tc.want, got)
			}
		})
	}
}

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

	dir := t.TempDir()
	writeFile(t, filepath.Join(dir, "a.txt"), "a")
	writeFile(t, filepath.Join(dir, "sub", "b.txt"), "b")
	writeFile(t, filepath.Join(dir, "sub", "c.log"), "c")

	rd, err := CreateArchive(dir, []string{"**/*.txt"})
	if err != nil {
		t.Fatal(err)
	}

	entries := zipEntries(t, rd)
	if want := []string{"a.txt", "sub/b.txt"}; !reflect.DeepEqual(entries, want) {
		t.Errorf("expected entries %v, got %v", want, entries)
	}
}

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

	dir := t.TempDir()
	path := filepath.Join(dir, "file.txt")
	writeFile(t, path, "x")

	if _, err := CreateArchive(path, []string{"**/*"}); err == nil {
		t.Fatal("expected error for non-directory path")
	}
}

func writeFile(t *testing.T, path, content string) {
	t.Helper()
	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
		t.Fatal(err)
	}
	if err := os.WriteFile(path, []byte(content), 0o644); err != nil {
		t.Fatal(err)
	}
}

func zipEntries(t *testing.T, r io.Reader) []string {
	t.Helper()

	data, err := io.ReadAll(r)
	if err != nil {
		t.Fatal(err)
	}
	zr, err := zip.NewReader(bytes.NewReader(data), int64(len(data)))
	if err != nil {
		t.Fatal(err)
	}

	var entries []string
	for _, f := range zr.File {
		if f.FileInfo().IsDir() {
			continue
		}
		entries = append(entries, f.Name)
	}
	sort.Strings(entries)
	return entries
}