package main

import (
	"fmt"
	"path/filepath"
	"reflect"
	"testing"
)

func TestReadFileTime(t *testing.T) {
	tt := []struct {
		fileName          string
		expectedTimestamp int
	}{
		{"1.txt", 3},
		{"2.txt", 5},
		{"3.txt", 11},
	}
	for _, tc := range tt {
		t.Run(tc.fileName, func(t *testing.T) {
			filePath := filepath.Join("testdata", tc.fileName)
			timestamp, err := readFileTime(filePath)
			if err != nil {
				t.Fatal("error reading file time: ", err)
			}
			if timestamp != tc.expectedTimestamp {
				t.Errorf("expected %d, got %d", tc.expectedTimestamp, timestamp)
			}
		})
	}
}

func TestOrderFiles(t *testing.T) {
	var (
		expectedOrder = []int{3, 5, 11}
		expectedMap   = map[int][]int{
			3:  {1},
			5:  {2, 7},
			11: {3, 4, 5},
		}
	)
	fileMap, order, err := orderFiles("testdata")
	if err != nil {
		t.Fatal("error ordering files: ", err)
	}
	if !reflect.DeepEqual(order, expectedOrder) {
		t.Errorf("expected %v, got %v", expectedOrder, order)
	}
	if !reflect.DeepEqual(fileMap, expectedMap) {
		t.Errorf("expected %v, got %v", expectedMap, fileMap)
	}
}

func TestFileContentsCache(t *testing.T) {
	fcc := FileContentsCache{BaseDir: "testdata"}
	cases := []struct {
		fileNumber int
		contents   string
	}{
		{1, "foo foo foo"},
		{2, "bar bar bar"},
		{3, "baz baz baz"},
	}

	// Test initial reads.
	for _, c := range cases {
		t.Run(fmt.Sprintf("initial read %d", c.fileNumber), func(t *testing.T) {
			got, err := fcc.GetFileContents(c.fileNumber)
			if err != nil {
				t.Fatal("error getting file contents: ", err)
			}
			if !reflect.DeepEqual(got, []string{c.contents}) {
				t.Errorf("expected %q, got %q", c.contents, got)
			}
		})
	}

	// Ensure files are actually stored in cache.
	for _, c := range cases {
		t.Run(fmt.Sprintf("cache check %d", c.fileNumber), func(t *testing.T) {
			if got, ok := fcc.cache.Load(c.fileNumber); !ok {
				t.Fatalf("file %d not found in cache", c.fileNumber)
			} else if !reflect.DeepEqual(got, []string{c.contents}) {
				t.Fatalf("expected %q, got %q", c.contents, got)
			}
		})
	}

	// Test clear-except operation.
	t.Run("clear except", func(t *testing.T) {
		fcc.ClearFilesExcept([]int{1})
		if _, ok := fcc.cache.Load(1); !ok {
			t.Fatal("file 1 not found in cache, expected to be kept")
		}
		if _, ok := fcc.cache.Load(2); ok {
			t.Fatal("file 2 found in cache, expected to be cleared")
		}
		if _, ok := fcc.cache.Load(3); ok {
			t.Fatal("file 3 found in cache, expected to be cleared")
		}
	})
}

func TestEndToEnd(t *testing.T) {
	docs, err := run([]string{"argv0", "-path", "testdata/e2e"})
	want := []int{1, 6, 9, 12, 14, 18}
	if err != nil {
		t.Fatal("error running program: ", err)
	}
	if len(docs) != 1 {
		t.Fatalf("expected %d documents, got %d", 1, len(docs))
	}
	doc := docs[0]
	if doc.ID != 1 {
		t.Errorf("expected ID %d, got %d", 0, doc.ID)
	}
	if doc.LatestTimestamp != 5 {
		t.Errorf("expected latest timestamp %d, got %d", 3, doc.LatestTimestamp)
	}
	if !reflect.DeepEqual(doc.AssociatedFiles, want) {
		t.Errorf("expected associated files %v, got %v", want, doc.AssociatedFiles)
	}
}