func (j *Job) Tuesday() *Job {
	j.unit = tuesday
	return j
}
Tuesday method fills the given job struct with tuesday
package clockwork
import (
	"fmt"
	"strconv"
	"strings"
	"time"
	"github.com/google/uuid"
)
type TimeUnit int
const (
	none = iota
	second
	minute
	hour
	day
	week
	monday
	tuesday
	wednesday
	thursday
	friday
	saturday
	sunday
)
var timeNow = func() time.Time {
	return time.Now()
}
type Job struct {
	identifier string
	scheduler  *Scheduler
	unit       TimeUnit
	frequency  int
	useAt      bool
	atHour     int
	atMinute   int
	workFunc   func()
	nextScheduledRun time.Time
}
func (j *Job) Every(frequencies ...int) *Job {
	l := len(frequencies)
	switch l {
	case 0:
		j.frequency = 1
	case 1:
		if frequencies[0] <= 0 {
			panic("Every expects frequency to be greater than of equal to 1")
		}
		j.frequency = frequencies[0]
	default:
		panic("Every expects 0 or 1 arguments")
	}
	return j
}
func (j *Job) EverySingle() *Job {
	return j.Every()
}
func (j *Job) At(t string) *Job {
	j.useAt = true
	j.atHour, _ = strconv.Atoi(strings.Split(t, ":")[0])
	j.atMinute, _ = strconv.Atoi(strings.Split(t, ":")[1])
	return j
}
func (j *Job) Do(function func()) string {
	j.workFunc = function
	j.scheduleNextRun()
	j.scheduler.jobs = append(j.scheduler.jobs, *j)
	return j.identifier
}
func (j *Job) due() bool {
	return timeNow().After(j.nextScheduledRun)
}
func (j *Job) isAtUsedIncorrectly() bool {
	return j.useAt == true && (j.unit == second || j.unit == minute ||
		j.unit == hour || j.unit == week)
}
func (j *Job) unitNotDayOrWEEKDAY() bool {
	return j.unit == second || j.unit == minute ||
		j.unit == hour || j.unit == week
}
func (j *Job) unitNotWEEKDAY() bool {
	return j.unit == second || j.unit == minute ||
		j.unit == hour || j.unit == day ||
		j.unit == week
}
func (j *Job) scheduleNextRun() {
	if j.frequency == 1 {
		if j.isAtUsedIncorrectly() {
			panic(
				`Cannot schedule Every(1) with At()
				 when unit is not day or WEEKDAY`,
			)  
		}
		if j.unitNotDayOrWEEKDAY() {
			if j.nextScheduledRun == (time.Time{}) {
				j.nextScheduledRun = timeNow()
			}
			switch j.unit {
			case second:
				j.nextScheduledRun = j.nextScheduledRun.Add(1 * time.Second)
			case minute:
				j.nextScheduledRun = j.nextScheduledRun.Add(1 * time.Minute)
			case hour:
				j.nextScheduledRun = j.nextScheduledRun.Add(1 * time.Hour)
			case week:
				j.nextScheduledRun = j.nextScheduledRun.Add(168 * time.Hour)
			}
		} else {
			switch j.unit {
			case day:
				if j.nextScheduledRun == (time.Time{}) {
					now := timeNow()
					lastMidnight := time.Date(
						now.Year(),
						now.Month(),
						now.Day(),
						0, 0, 0, 0,
						time.Local,
					)
					if j.useAt == true {
						j.nextScheduledRun = lastMidnight.Add(
							time.Duration(j.atHour)*time.Hour +
								time.Duration(j.atMinute)*time.Minute,
						)
					} else {
						j.nextScheduledRun = lastMidnight.Add(24 * time.Hour)
					}
				} else {
					j.nextScheduledRun = j.nextScheduledRun.Add(24 * time.Hour)
				}
			case monday:
				j.scheduleWeekday(time.Monday)
			case tuesday:
				j.scheduleWeekday(time.Tuesday)
			case wednesday:
				j.scheduleWeekday(time.Wednesday)
			case thursday:
				j.scheduleWeekday(time.Thursday)
			case friday:
				j.scheduleWeekday(time.Friday)
			case saturday:
				j.scheduleWeekday(time.Saturday)
			case sunday:
				j.scheduleWeekday(time.Sunday)
			}
		}
		fmt.Println("Scheduled for ", j.nextScheduledRun)
	} else {
		if j.isAtUsedIncorrectly() {
			panic("Cannot schedule Every(>1) with At() when unit is not day")
		}
		if j.unitNotWEEKDAY() {
			if j.unit != day {
				if j.nextScheduledRun == (time.Time{}) {
					j.nextScheduledRun = timeNow()
				}
				switch j.unit {
				case second:
					j.nextScheduledRun = j.nextScheduledRun.Add(
						time.Duration(j.frequency) * time.Second,
					)
				case minute:
					j.nextScheduledRun = j.nextScheduledRun.Add(
						time.Duration(j.frequency) * time.Minute,
					)
				case hour:
					j.nextScheduledRun = j.nextScheduledRun.Add(
						time.Duration(j.frequency) * time.Hour,
					)
				case week:
					j.nextScheduledRun = j.nextScheduledRun.Add(
						time.Duration(j.frequency*168) * time.Hour,
					)  
				}
			} else {
				if j.nextScheduledRun == (time.Time{}) {
					now := timeNow()
					lastMidnight := time.Date(
						now.Year(),
						now.Month(),
						now.Day(),
						0, 0, 0, 0,
						time.Local,
					)
					if j.useAt == true {
						j.nextScheduledRun = lastMidnight.Add(
							time.Duration(j.atHour)*time.Hour +
								time.Duration(j.atMinute)*time.Minute,
						)
					} else {
						j.nextScheduledRun = lastMidnight
					}
				}
				j.nextScheduledRun = j.nextScheduledRun.Add(
					time.Duration(j.frequency*24) * time.Hour,
				)
			}
		} else {
			panic("Cannot schedule Every(>1) when unit is WEEKDAY")
		}
		fmt.Println("Scheduled for ", j.nextScheduledRun)
	}
	return
}
func (j *Job) scheduleWeekday(dayOfWeek time.Weekday) {
	if j.nextScheduledRun == (time.Time{}) {
		now := timeNow()
		lastWeekdayMidnight := time.Date(
			now.Year(),
			now.Month(),
			now.Day()-int(now.Weekday()-dayOfWeek),
			0, 0, 0, 0,
			time.Local)
		if j.useAt == true {
			j.nextScheduledRun = lastWeekdayMidnight.Add(
				time.Duration(j.atHour)*time.Hour +
					time.Duration(j.atMinute)*time.Minute,
			)
		} else {
			j.nextScheduledRun = lastWeekdayMidnight
		}
	}
	j.nextScheduledRun = j.nextScheduledRun.Add(7 * 24 * time.Hour)
}
func (j *Job) Second() *Job {
	j.unit = second
	return j
}
func (j *Job) Seconds() *Job {
	j.unit = second
	return j
}
func (j *Job) Minute() *Job {
	j.unit = minute
	return j
}
func (j *Job) Minutes() *Job {
	j.unit = minute
	return j
}
func (j *Job) Hour() *Job {
	j.unit = hour
	return j
}
func (j *Job) Hours() *Job {
	j.unit = hour
	return j
}
func (j *Job) Day() *Job {
	j.unit = day
	return j
}
func (j *Job) Days() *Job {
	j.unit = day
	return j
}
func (j *Job) Week() *Job {
	j.unit = week
	return j
}
func (j *Job) Weeks() *Job {
	j.unit = week
	return j
}
func (j *Job) Monday() *Job {
	j.unit = monday
	return j
}