package main

import (
	"sync"
	"time"
	"runtime"

	"github.com/myzhan/boomer"
)

func someSequentialActions() {
	for step := 0; step < 20; step++ {
		sum := 0
		for i := 0; i < 100000; i++ {
			sum += i
			runtime.Gosched()
		}
	}
}

const (
	interval   = 50 * time.Millisecond
	spawnCount = 1000
	spawnRate  = 50
)

type Foo struct {
	stop   chan any
	stream chan int
}

func (f *Foo) Generate() {
	ticker := time.NewTicker(interval)
	defer ticker.Stop()
	for {
		select {
		case <-f.stop:
			ticker.Stop()
			return
		case <-ticker.C:
			f.stream <- 1
		}
	}
}

func (f *Foo) Receive(stream <-chan int) {
	maxInterval := 2 * interval
	for {
		select {
		case <-f.stop:
			return
		case <-time.After(maxInterval):
			panic("timeout")
		case <-stream:
			// do something
		}
	}

}

func (f *Foo) Stop() {
	close(f.stop)
}

func main() {
	wg := sync.WaitGroup{}
	task := &boomer.Task{
		Name:   "foo",
		Weight: 10,
		Fn: func() {
			wg.Add(1)
			defer wg.Done()

			f := &Foo{
				stop:   make(chan any),
				stream: make(chan int),
			}
			defer f.Stop()

			go f.Generate()
			go f.Receive(f.stream)

			someSequentialActions()
		},
	}

	instance := boomer.NewStandaloneBoomer(spawnCount, spawnRate)
	go instance.Run(task)

	time.Sleep(100 * time.Second)
	instance.Quit()
	wg.Wait()
	println("done")
}