package main

import (
	"fmt"
	"strconv"
	"sync"
	"time"
)

var m map[string]string

type Data struct {
	Key   string
	Value string
}

func worker(queue chan Data, finished chan struct{}) {

	for {
		d, more := <-queue
		if !more {
			fmt.Println("Stopping worker due to closed channel")
			break

		}
		//fmt.Print(".")
		m[d.Key] = d.Value
	}
	finished <- struct{}{}
}

func main() {
	ConcurrentSender := 100

	m = make(map[string]string)
	done := []chan struct{}{}
	mutex := sync.Mutex{}
	start := time.Now()

	for i := 0; i < ConcurrentSender; i++ {
		d := make(chan struct{})
		done = append(done, d)
		go func(done chan struct{}, mut *sync.Mutex, ind int) {
			for j := 0; j < 100; j++ {
				mut.Lock()
				m[strconv.Itoa(j)] = strconv.Itoa(j + (1000 * (ind + 1)))
				mut.Unlock()
			}
			done <- struct{}{}
		}(d, &mutex, i)
	}
	for _, d := range done {
		_ = <-d
	}

	duration := time.Since(start)

	fmt.Printf("\nMutex Solution took %s", duration)

	m = make(map[string]string)

	done = []chan struct{}{}

	queue := make(chan Data)
	// start of the worker go routine
	finished := make(chan struct{})
	go worker(queue, finished)

	start = time.Now()
	for i := 0; i < ConcurrentSender; i++ {
		d := make(chan struct{})
		done = append(done, d)
		go func(queue chan Data, done chan struct{}, ind int) {
			for i := 0; i < 100; i++ {
				// Write element to queue
				queue <- Data{Key: strconv.Itoa(i), Value: strconv.Itoa(i + (100 * (ind + 1)))}
			}
			done <- struct{}{}
		}(queue, d, i)

	}

	for _, d := range done {
		_ = <-d
	}

	duration = time.Since(start)

	close(queue)
	_ = <-finished
	fmt.Printf("Channel Solution took %s", duration)

}