package main

import (
	"fmt"

	"github.com/go-redis/redis"
	"github.com/taylorchu/work"
)

type message struct {
	Text string
}

func main() {
	client := newRedisClient()
	defer client.Close()

	job := work.NewJob()
	err := job.MarshalPayload(message{Text: "hello"})

	if (err != nil) {
		panic(err)
	}

	err = work.NewRedisQueue(client).Enqueue(job, &work.EnqueueOptions{
		Namespace: "ns1",
		QueueID:   "worker",
	})

	if (err != nil) {
		panic(err)
	}

	fmt.Println("job submitted")
}

func newRedisClient() *redis.Client {
	return redis.NewClient(&redis.Options{
		Addr:         "127.0.0.1:6379",
		PoolSize:     10,
		MinIdleConns: 10,
	})
}

package main

import (
	"fmt"
	"os"
    "os/signal"
	"time"

	"github.com/go-redis/redis"
	"github.com/taylorchu/work"
)

type message struct {
	Text string
}

func main() {
	client := newRedisClient()
	defer client.Close()

	w := work.NewWorker(&work.WorkerOptions{
		Namespace: "ns1",
		Queue:     work.NewRedisQueue(client),
	})
	err := w.Register("worker",
		func(job *work.Job, _ *work.DequeueOptions) error {
			var msg message
			job.UnmarshalPayload(&msg)
			fmt.Println(msg)
			return nil
		},
		&work.JobOptions{
			MaxExecutionTime: time.Second,
			IdleWait:         time.Second,
			NumGoroutines:    2,
		},
	)

	if (err != nil) {
		panic(err)
	}

	fmt.Println("starting")

	w.Start()

	// Wait for a signal to quit:
    signalChan := make(chan os.Signal, 1)
    signal.Notify(signalChan, os.Interrupt, os.Kill)
    <-signalChan

    fmt.Println("stopped")

    w.Stop()
}

func newRedisClient() *redis.Client {
	return redis.NewClient(&redis.Options{
		Addr:         "127.0.0.1:6379",
		PoolSize:     10,
		MinIdleConns: 10,
	})
}

var testNamespace = "this-is-test-namespace"
var testQueueID = "this-is-test-queue-id"

func workFunc(job *work.Job, jobOpts *work.DequeueOptions) error {
	var args map[string]interface{}
	if err := job.UnmarshalPayload(&args); err != nil {
		return err
	}

	contractAddr := ""
	ok := false
	if contractAddrFromMsg, exist := args[contractAddrKey]; exist {
		if contractAddr, ok = contractAddrFromMsg.(string); !ok {
			return fmt.Errorf("aadsada")
		}
	}

	if contractAddr == "" {
		return fmt.Errorf("empty contract addr")
	}

	fmt.Println("successful deque")

	time.Sleep(500 * time.Millisecond)

	fmt.Println("successful return")
	return nil
}

func TestTaylorChuWork(t *testing.T) {
	m, err := miniredis.Run()
	if err != nil {
		t.Fatal("Failed to start", "err", err)
	}

	uc := redis.NewUniversalClient(&redis.UniversalOptions{
		Addrs: []string{m.Addr()},
	})

	
	queue := work.NewRedisQueue(uc)
	
	worker := work.NewWorker(&work.WorkerOptions{
		Namespace: testNamespace,
		Queue:     queue,
	})
	
	err = worker.Register(
		testQueueID,
		workFunc,
		&work.JobOptions{
			//WorkerOptions:     work.WorkerOptions{},
			MaxExecutionTime:  10 * time.Second,
			IdleWait:          1 * time.Second,
			NumGoroutines:     10,
			DequeueMiddleware: nil,
			HandleMiddleware:  nil,
		}, )
	if err != nil {
		t.Fatal(err)
	}

	worker.Start()

	job := work.NewJob()
	job, err = job.WithPayload(map[string]interface{}{contractAddrKey :  contractAddrKey})
	if err != nil {
		t.Fatal(err)
	}

	err = queue.Enqueue(job, &work.EnqueueOptions{Namespace:testNamespace, QueueID: testQueueID})
	if err != nil {
		t.Fatal(err)
	}

	time.Sleep(10*time.Second)

}

=== RUN   TestTaylorChuWork
successful deque
successful deque
successful return
successful return

...
foundJobs, err := c.BulkFindJobs(job.ID)
	if err != nil {
		return err
	}

	if len(foundJobs) > 0 && foundJobs[0] != nil {
		logrus.Warnf("Did not enqueue Job: %s in Queue: %s due to uniqueness constraint", job.ID, jobParams.jobQueueName)
		return nil
	}
...

// called on application start-up 
func main() {
...
redisClient := application.BuildRedisClient()
jobsClient := application.BuildJobsClient(redisClient)

core := core.New(
core.Config{
                     ...
JobsClient:            jobsClient,
RedisClient:           redisClient,
...
        })

... 

group.Go(func() error {
cron.CronHandler(jobsClient, context.Background())
return nil
})

}

// JobsHandler, also called on start-up
func JobsHandler(redisClient *redis.ClusterClient, handlerFunc work.ContextHandleFunc) {
	jobWorker := work.NewWorker(&work.WorkerOptions{
		Namespace: jobs.NAMESPACE,
		Queue:     work.NewRedisQueue(redisClient),
		ErrorFunc: func(err error) {
			log.Println(err)
		},
	})

	jobOpts := &work.JobOptions{
		MaxExecutionTime: time.Minute,
		IdleWait:         time.Second,
		NumGoroutines:    4,
		HandleMiddleware: []work.HandleMiddleware{
			logrus.HandleFuncLogger,
			catchPanic,
		},
	}

	for queueName := range jobs.JOB_QUEUES {
		jobWorker.RegisterWithContext(string(queueName), handlerFunc, jobOpts)
	}

	jobWorker.Start()
}

// cron service
package cron

import (
	"context"
	"main/entities/jobs"
	"main/lib/errors"

	"github.com/robfig/cron/v3"
)

func CronHandler(jobsClient jobs.Client, ctx context.Context) {
	c := cron.New()
	c.AddFunc("50 * * * *", func() { enqueueOurJob(jobsClient, ctx) })
	c.Start()
	return
}

func enqueueOurJob(jobsClient jobs.Client, ctx context.Context) {
	uniqueId := "uniqueId"
	enqueueJobParams, err := jobs.CreateEnqueueJobParams(jobs.CreateEnqueueJobParamsArgs{
		Name:         jobs.OurJob,
		UniqueJobId:  &uniqueId,
	}, &jobs.OurJobPayload{})

	err = jobsClient.EnqueueJob(ctx, *enqueueJobParams)
}

func (c *client) EnqueueJob(ctx context.Context, jobParams EnqueueJobParams) error {
	job := work.NewJob()

	if jobParams.uniqueJobId != nil {
		job.ID = *jobParams.uniqueJobId
	}

	if jobParams.enqueueDelay != nil {
		job = job.Delay(*jobParams.enqueueDelay)
	}

	if err := job.MarshalJSONPayload(string(jobParams.jobPayload)); err != nil {
		return err
	}

	foundJobs, err := c.BulkFindJobs(job.ID)
	if err != nil {
		return err
	}

        // uniqueness constraint
	if len(foundJobs) > 0 && foundJobs[0] != nil {
		logrus.Warnf("Did not enqueue Job: %s in Queue: %s due to uniqueness constraint", job.ID, jobParams.jobQueueName)
		return nil
	}

	err = c.enqueue(job, &work.EnqueueOptions{
		Namespace: NAMESPACE,
		QueueID:   string(jobParams.jobQueueName),
	})
	if err != nil {
		return err
	}

	return nil
}