package tasks

import (
	"errors"
	"log"
	"os"
	"testing"
	"time"
)

type tShortTask struct{}

func (t *tShortTask) Run() error {
	time.Sleep(time.Second * 1)
	return nil
}

type tLongTask struct{}

func (t *tLongTask) Run() error {
	time.Sleep(time.Second * 2)
	return nil
}

type tErrorTask struct{}

func (t *tErrorTask) Run() error {
	time.Sleep(time.Second * 2)
	return eErrorTask
}

var (
	eErrorTask = errors.New("tErrorTask testing error")

	testLogger = log.New(os.Stderr, "", log.LstdFlags|log.Lshortfile)
)

func TestIntegration(t *testing.T) {
	logger = testLogger

	tg := NewGroup()

	pairs := map[string]Task{
		"tShortTask": &tShortTask{},
		"tLongTask":  &tLongTask{},
		"tErrorTask": &tErrorTask{},
	}

	done := []string{}
	for name, task := range pairs {
		err := tg.Add(name, task)
		if err != nil {
			t.Fatalf("while adding: %s", err)
		}
		testLogger.Println("Added: ", name)

		registered := tg.Registered()
		testLogger.Println("Currently registered: ", registered)
		for _, n := range done {
			_, ok := registered[n]
			if !ok {
				t.Fatalf("%s is supposed to be registered", n)
			}
		}
	}

	reg := tg.Registered()
	testLogger.Println("Registered tasks: ", reg)

	err := tg.Add("tLongTask", &tLongTask{})
	if !errors.Is(err, EAlreadyRegistered) {
		t.Errorf("tLongTask should already be registered got: %s", err)
	}

	err = tg.Start("tLongTask")
	if err != nil {
		t.Errorf("starting tLongTask err should've been nil: %s", err)
	}
	testLogger.Println("tried starting tLongTask again")

	err = tg.Run("tShortTask")
	if err != nil {
		t.Errorf("running tShortTask err should've been nil: %s", err)
	}

	finished := tg.Finished()
	testLogger.Println("Finished tasks: ", finished)
	_, ok := finished["tShortTask"]
	if !ok {
		t.Errorf("tShortTask should've been finished and isn't")
	}

	_, ok = finished["tLongTask"]
	if ok {
		t.Errorf("tLongTask is finished and it shouldn't be")
	}

	err = tg.Start("tLongTask")
	if !errors.Is(err, EAlreadyStarted) {
		t.Errorf("tLongTask should've already been started got: %s", err)
	}

	err = tg.Run("tLongTask")
	if !errors.Is(err, EAlreadyStarted) {
		t.Errorf("tLongTask should've already been started got: %s", err)
	}

	running := tg.Running()
	testLogger.Println("Running tasks: ", running)

	err = tg.Run("tErrorTask")
	if err == nil {
		t.Error("tErrorTask should have produced an error")
	}

	withErrors := tg.Error()
	testLogger.Println("Errored tasks: ", withErrors)
	_, ok = withErrors["tErrorTask"]
	if !ok {
		t.Error("tErrorTask should've been found within tg.Error()")
	}

	err = tg.GetError("tErrorTask")
	if !errors.Is(err, eErrorTask) {
		t.Errorf("tErrorTask should've returned an error got: %s", err)
	}

	finished = tg.Finished()
	testLogger.Println("Finished tasks: ", finished)

	for name := range pairs {
		_, ok := finished[name]
		if !ok {
			t.Errorf("'%s' should be finished and isn't", name)
		}
	}

}