202 lines
4.5 KiB
Go

package main
import (
"flag"
"fmt"
"log"
"time"
)
func renderYear() string {
// Get Current time
var ct time.Time
var offset int
ct, offset = getCurrentTime()
// So what the following does is
// Add one year to the current time (and call it next year)
// Get the start of this year
// Get the start of the next year
// The New Year
ny := ct.AddDate(1, 0, 0)
// Get the start of this and next year
t1 := startYear(ct.Year(), 1, 1)
t2 := startYear(ny.Year(), 1, 1)
// Subtract the current year in seconds from next year, in seconds.
// This will leave us with the total year in seconds
// I do this in case there is a leap-year,
// or some dodgy science reason to add 30 seconds to a day.
seconds := t2.Sub(t1).Seconds()
// From the current time, subtract the start of this year, in seconds.
// This should leave us with how far we are into the year, in seconds.
tdiff := ct.Sub(t1).Seconds()
// Calculate the percentages
percentage := calcPercentageFloat64(seconds, tdiff+float64(offset))
// Wrap things up
var render string
render = renderPercentage(percentage)
render = render + fmt.Sprintf(" %.7f%%", percentage)
return render
}
func renderDay() string {
// Get Current time
var ct time.Time
var offset int
ct, offset = getCurrentTime()
// Get the Start of the Day
sd := time.Date(ct.Year(), ct.Month(), ct.Day(), 0, 0, 0, 0, time.UTC)
// Get the End of the Day
ed := ct.AddDate(0, 0, 1)
ed = time.Date(ed.Year(), ed.Month(), ed.Day(), 0, 0, 0, 0, time.UTC)
// From the end of the day, subtract the end of the day to get the number of seconds.
// Normally this would be 86400, thanks to science this may change.
// Think Leap Seconds
//
// Get the current number of seconds into the day
seconds_total := ed.Sub(sd).Seconds()
seconds_tmp := ed.Sub(ct).Seconds()
seconds_current := seconds_total - seconds_tmp
// Calculate the percentages
percentage := calcPercentageFloat64(seconds_total, seconds_current+float64(offset))
// Wrap everything up
var render string
render = renderPercentage(percentage)
render = render + fmt.Sprintf(" %.7f%%", percentage)
return render
}
func renderCustom(t1 time.Time, t2 time.Time) string {
var ct time.Time
var offset int
ct, offset = getCurrentTime()
seconds := t2.Sub(t1).Seconds()
tdiff := ct.Sub(t1).Seconds()
percentage := calcPercentageFloat64(seconds, tdiff+float64(offset))
var render string
render = renderPercentage(percentage)
render = render + fmt.Sprintf(" %.7f%%", percentage)
return render
}
func getCurrentTime() (time.Time, int) {
// Declarations
var offset int
var loc *time.Location
var err error
// Current Time
ct := time.Now()
// Get the offset from whatever the system timezone is
_, offset = ct.Local().Zone()
// Make sure that the time is in UTC, so the offset makes sense
loc, err = time.LoadLocation("UTC")
if err != nil {
log.Fatal(err)
}
ct = ct.In(loc)
// Return things
return ct, offset
}
// displayPercentage Print a string of blocks simulating percentages
func renderPercentage(percentage float64) string {
var counter int
var balk string
for percentage > 2 {
balk = balk + "▓"
percentage = percentage - 2
counter++
}
if percentage < 2 {
balk = balk + "▒"
counter++
}
for counter < 50 {
balk = balk + "░"
counter++
}
return balk
}
// Get the percentages between two float64s
func calcPercentageFloat64(full float64, part float64) float64 {
var percentage float64
percentage = part / (full / 100)
if percentage >= 100 {
percentage = percentage - 100
}
return percentage
}
// Get the start of the year.
func startYear(year, month, day int) time.Time {
return time.Date(year, time.Month(month), day, 0, 0, 0, 0, time.UTC)
}
func main() {
var dayFlag = flag.Bool("day", true, "Display progress of the day.")
var yearFlag = flag.Bool("year", true, "Display progress of this year.")
var customFlag = flag.Bool("custom", false, "Display a custom range")
var customStart = flag.String("custom-start", "", "Start of the custom range")
var customStop = flag.String("custom-stop", "", "Start of the custom range")
flag.Parse()
if *dayFlag {
fmt.Println(renderDay())
}
if *yearFlag {
fmt.Println(renderYear())
}
if *customFlag {
bt, err := time.Parse(time.RFC3339, *customStart)
if err != nil {
log.Fatalln("Error parsing start time: ", err)
}
pa, err := time.Parse(time.RFC3339, *customStop)
if err != nil {
log.Fatalln("Error parsing stop time: ", err)
}
fmt.Println(renderCustom(bt, pa))
}
}