package channels

import (
	"bufio"
	"context"
	"errors"
	"os"
	"slices"
	"strings"
	"testing"

	"code.wmdillon.com/GoApi/set"
)

const (
	TheWordsFilename = "words"
)

var (
	TheWords = func() []string {
		f, err := os.Open(TheWordsFilename)
		if err != nil {
			panic("error opening " + TheWordsFilename + ": " + err.Error())
		}
		defer f.Close()
		set := set.New[string](false)
		scanner := bufio.NewScanner(f)
		for scanner.Scan() {
			if line := strings.ToLower(strings.TrimSpace(scanner.Text())); len(line) > 0 {
				set.Insert(line)
			}
		}
		return set.ToSlice()
	}()
)

func TestSliceToChannelAndChannelToSlice(t *testing.T) {
	wordsChannel := SliceToChannel(TheWords, len(TheWords))
	wordsSlice := ChannelToSlice(wordsChannel)
	if !slices.Equal(wordsSlice, TheWords) {
		t.Fatalf("error: words != words slice\n")
	}
}

var ReverseString ChannelPipelineWorkFunction[string] = func(s string) string {
	r := []rune(s)
	slices.Reverse(r)
	return string(r)
}

func TestProcessChannelThroughFunction(t *testing.T) {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()
	f1 := func(s string) string {
		results := strings.ToUpper(s)
		//fmt.Printf("f1: %s => %s\n", s, results)
		return results
	}
	f2 := func(s string) string {
		results := ReverseString(s)
		//fmt.Printf("f2: %s => %s\n", s, results)
		return results
	}
	words, words_copy := CopyChannelWithContext(ctx, SliceToChannel(TheWords, len(TheWords)))
	modified := ProcessChannelThroughFunction(ctx, ProcessChannelThroughFunction(ctx, words, f1), f2)
	for {
		want, wantErr := TrySelectFromChannel(ctx, words_copy)
		got, gotErr := TrySelectFromChannel(ctx, modified)
		if wantErr != nil || gotErr != nil {
			if !errors.Is(gotErr, wantErr) {
				t.Fatalf("error: wanted %v; got %v\n", wantErr, gotErr)
			}
			break
		}
		want = f2(f1(want))
		if want != got {
			t.Fatalf("error: wanted %s; got %s\n", want, got)
		}
	}
}

func TestMergeChannels(t *testing.T) {
	channels := make([]<-chan string, 0, 26)
	for slice := range slices.Chunk(TheWords, len(TheWords)/25) {
		channels = append(channels, SliceToChannel(slice, len(slice)))
	}
	got := ChannelToSlice(MergeChannels(len(TheWords), channels...))
	want := TheWords
	slices.Sort(want)
	slices.Sort(got)
	if len(want) != len(got) {
		t.Fatalf("error: wanted %d words; got %d\n", len(want), len(got))
	}
	for i := range len(want) {
		if want, got := want[i], got[i]; want != got {
			t.Fatalf("error: wanted %s; got %s\n", want, got)
		}
	}
}