From b0b8b762ab98355d39750ebee5ef9f9feaa3c0ba Mon Sep 17 00:00:00 2001
From: Jeff Carr <jcarr@wit.com>
Date: Sun, 31 Dec 2023 02:49:26 -0600
Subject: [PATCH] use go-arg package. start migrating more code over

Signed-off-by: Jeff Carr <jcarr@wit.com>
---
 args.go    |  6 ++++
 log.go     | 24 +++++++++++++++-
 notes.go   | 80 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 verbose.go | 10 +++++++
 4 files changed, 119 insertions(+), 1 deletion(-)
 create mode 100644 notes.go
 create mode 100644 verbose.go

diff --git a/args.go b/args.go
index 87deb0f..4752f53 100644
--- a/args.go
+++ b/args.go
@@ -12,6 +12,7 @@ var argLog ArgLog
 
 // This struct can be used with the go-arg package
 type ArgLog struct {
+	LogDebug bool `arg:"--log-debug" help:"show the log gui"`
 	LogTmp bool `arg:"--log-tmp" help:"send all output /tmp"`
 	LogStdout bool `arg:"--log-stdout" help:"send all output to STDOUT"`
 	LogQuiet bool `arg:"--log-quiet" help:"suppress all output"`
@@ -20,3 +21,8 @@ type ArgLog struct {
 func init() {
 	arg.Register(&argLog)
 }
+
+// returns true if --log-debug was passed from the command line
+func ArgDebug() bool {
+	return argLog.LogDebug
+}
diff --git a/log.go b/log.go
index e52ff48..17247db 100644
--- a/log.go
+++ b/log.go
@@ -5,16 +5,19 @@ import 	(
 	origlog "log"
 )
 
-var SPEW bool = false
 var INFO bool = true
 var WARN bool = true
 var ERROR bool = true
 
+var VERBOSE bool = false
+var SPEW bool = false
+
 func All(b bool) {
 	Set("SPEW", b)
 	Set("INFO", b)
 	Set("WARN", b)
 	Set("ERROR", b)
+	Set("VERBOSE", b)
 }
 
 func Set(flag string, b bool) {
@@ -27,6 +30,8 @@ func Set(flag string, b bool) {
 		SPEW = b
 	case "ERROR":
 		ERROR = b
+	case "VERBOSE":
+		VERBOSE = b
 	default:
 		Error(errors.New("unknown flag"), "Flag name sent:", flag)
 	}
@@ -42,16 +47,33 @@ func Get(flag string) bool {
 		return SPEW
 	case "ERROR":
 		return ERROR
+	case "VERBOSE":
+		return VERBOSE
 	default:
 		Error(errors.New("unknown flag"), "Flag name sent:", flag)
 	}
 	return false
 }
 
+// a simple way turn logging messages on and off
+func Log(b bool, a ...any) {
+	if ! b { return }
+	golanglog.Println(a...)
+}
+
+func Logf(b bool, s string, a ...any) {
+	if ! b { return }
+	golanglog.Printf(s, a...)
+}
+
 func Println(a ...any) {
 	origlog.Println(a...)
 }
 
+func Printf(s string, a ...any) {
+	origlog.Printf(s, a...)
+}
+
 func Fatalf(s string, a ...any) {
 	origlog.Fatalf(s, a...)
 }
diff --git a/notes.go b/notes.go
new file mode 100644
index 0000000..6b422f6
--- /dev/null
+++ b/notes.go
@@ -0,0 +1,80 @@
+package log
+
+/*
+var argv struct {
+	Foo string
+	Bar bool
+	User string `arg:"env:USER"`
+	Demo bool `help:"run a demo"`
+}
+*/
+
+/*
+var f1 *os.File
+var f2 *os.File
+var err error
+*/
+
+/* from gocron:
+
+// DefaultLogger is used by Cron if none is specified.
+var DefaultLogger Logger = PrintfLogger(log.New(os.Stdout, "cron: ", log.LstdFlags))
+
+// DiscardLogger can be used by callers to discard all log messages.
+var DiscardLogger Logger = PrintfLogger(log.New(ioutil.Discard, "", 0))
+
+// Logger is the interface used in this package for logging, so that any backend
+// can be plugged in. It is a subset of the github.com/go-logr/logr interface.
+type Logger interface {
+	// Info logs routine messages about cron's operation.
+	Info(msg string, keysAndValues ...interface{})
+	// Error logs an error condition.
+	Error(err error, msg string, keysAndValues ...interface{})
+}
+
+*/
+
+//	fmt.Println(argv.Foo, args.Bar, args.User)
+/*
+	// from: https://github.com/robfig/cron/blob/master/logger.go
+	log.Println()
+	log.Println("STDOUT is now at /tmp/guilogfile")
+	log.Println("STDOUT is now at /tmp/guilogfile")
+	log.Println()
+	f1, err = os.OpenFile(outfile, os.O_RDWR | os.O_CREATE | os.O_APPEND, 0666)
+	if err != nil {
+		log.Fatalf("error opening file: %v", err)
+	}
+	// hmm. is there a trick here or must this be in main()
+	// defer f.Close()
+
+	log.SetOutput(f1)
+	log.Println("This is a test log entry")
+*/
+
+/*
+func captureSTDOUT() {
+	f2, _ = os.OpenFile("/tmp/my.log", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0664)
+	multiWriter := io.MultiWriter(os.Stderr, f2)
+	rd, wr, err := os.Pipe()
+	if err != nil {
+	    os.Exit(1)
+	}
+
+	// overwrite os.Stdout
+	os.Stderr = wr
+
+	go func() {
+	    scanner := bufio.NewScanner(rd)
+	    for scanner.Scan() {
+	        stdoutLine := scanner.Text()
+	        multiWriter.Write([]byte(stdoutLine + "\n"))
+	    }
+	}()
+
+	fmt.Println("foobar")
+
+	// hacky sleep to ensure the go routine can write before program exits
+	time.Sleep(time.Second)
+}
+*/
diff --git a/verbose.go b/verbose.go
new file mode 100644
index 0000000..90add81
--- /dev/null
+++ b/verbose.go
@@ -0,0 +1,10 @@
+package log
+
+import 	(
+	golanglog "log"
+)
+
+func Verbose(a ...any) {
+	if ! VERBOSE { return }
+	golanglog.Println(a...)
+}