package mytinytodo

import (
	"local/mytinytodoclient/mytinytodo/remote"
	"net/http"
	"net/http/httptest"
	"os"
	"testing"
	"time"
)

func TestNewBuffer(t *testing.T) {
	b, s := mockBuffer(t)
	defer b.Close()
	defer s.Close()
}

func TestBufferEnqueue(t *testing.T) {
	b, s := mockBuffer(t)
	defer b.Close()
	defer s.Close()

	if err := b.Enqueue(remote.NEW, "list", "task", "one", "tag", "two"); err != nil {
		t.Errorf("cannot enqueue: %v", err)
	}

	todo1 := NewStringArray()
	if err := b.db.Get(nsQueue, keyQueue, todo1); err != nil || len(todo1.StringArray()) != 1 {
		t.Fatalf("enqueue didnt create list: %v (%d)", err, len(todo1.StringArray()))
	}
}

func TestBufferDequeue(t *testing.T) {
	b, s := mockBuffer(t)
	defer b.Close()
	defer s.Close()

	if err := b.Enqueue(remote.NEW, "list", "task", "one", "tag", "two"); err != nil {
		t.Fatalf("cannot enqueue to dequeue: %v", err)
	}

	todo1 := NewStringArray()
	if err := b.db.Get(nsQueue, keyQueue, todo1); err != nil || len(todo1.StringArray()) != 1 {
		t.Fatalf("enqueue didnt create list: %v (%d)", err, len(todo1.StringArray()))
	}

	b.Dequeue()

	todo2 := NewStringArray()
	if err := b.db.Get(nsQueue, keyQueue, todo2); err != nil || len(todo2.StringArray()) != 0 {
		t.Fatalf("dequeue didnt remove from list: %v (%d)", err, len(todo2.StringArray()))
	}

}

func TestBufferRefreshLocal(t *testing.T) {
	b, s := mockBuffer(t)
	defer b.Close()
	defer s.Close()

	b.RefreshLocal()

	var lists remote.Lists
	if err := b.db.Get(nsLists, keyLists, &lists); err != nil || lists.Length() != 1 {
		t.Fatalf("refreshLocal didnt create list: %v (%d)", err, lists.Length())
	}

	var tasks remote.Tasks
	if err := b.db.Get(nsTasks, lists.ListArray()[0].ID, &tasks); err != nil || tasks.Length() != 1 {
		t.Fatalf("failed to parse task on refresh: %v (%d)", err, tasks.Length())
	}
}

func TestBufferNotDoneCallback(t *testing.T) {
	b := &Buffer{
		done:     make(chan struct{}),
		interval: time.Millisecond * 70,
	}
	called := make(chan struct{})
	go b.notDoneCallback(func() {
		called <- struct{}{}
	})
	<-called
	close(b.done)
}

func mockBuffer(t *testing.T) (*Buffer, *httptest.Server) {
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
		w.Write([]byte(`
         {
            "list":[
               {
                  "id":"id",
                  "name":"name",
                  "title":"title",
                  "compl":0
               }
            ]
         }
      `))
	}))
	osArgsWas := os.Args[:]
	os.Args = []string{"skip", "-remote", srv.URL, "-p", ""}
	defer func() {
		os.Args = osArgsWas[:]
	}()
	config, err := NewConfig()
	if err != nil {
		t.Fatalf("cannot get new config: %v", err)
	}
	buff, err := NewBuffer(config)
	if err != nil {
		t.Fatalf("cannot get new buffer: %v", err)
	}
	return buff, srv
}