# HG changeset patch
# User Sascha L. Teichmann <sascha.teichmann@intevation.de>
# Date 1635115059 -7200
# Node ID 7e21a9e6353d839dfe4677c0ddccc5eceee41fb2
# Parent  84f0c53e6ffe52146bf2dff5dfe8a4d5b617f54f
Cleaned up and simplified code.

diff -r 84f0c53e6ffe -r 7e21a9e6353d pkg/imports/gm.go
--- a/pkg/imports/gm.go	Sun Oct 24 23:57:14 2021 +0200
+++ b/pkg/imports/gm.go	Mon Oct 25 00:37:39 2021 +0200
@@ -363,163 +363,72 @@
 }
 
 func (gls gmLogs) logging(feedback Feedback) {
-	gls.logUnknown(feedback)
-	gls.logAssumedZPG(feedback)
-	gls.logAssumedCM(feedback)
-	gls.logBadValues(feedback)
-	gls.logMissingValues(feedback)
-	gls.logRescaleErrors(feedback)
-	gls.logIgnoredMeasureCodes(feedback)
-	gls.logPredictions(feedback)
-	gls.logMeasurements(feedback)
-}
+	gls.logBool(
+		(*gmLog).getUnkown,
+		"Cannot find following gauges: ",
+		feedback.Warn)
+
+	gls.logBool(
+		(*gmLog).getAssumedZPG,
+		"Reference_code' not specified. Assuming 'ZPG': ",
+		feedback.Warn)
+
+	gls.logInt(
+		(*gmLog).getAssumedCM,
+		"'Unit' not specified. Assuming 'cm': ",
+		feedback.Warn)
+
+	gls.logInt(
+		(*gmLog).getBadValues,
+		"Ignored measurements with value -99999: ",
+		feedback.Warn)
 
-func (gls gmLogs) logMeasurements(feedback Feedback) {
-	var sb strings.Builder
-	for _, gl := range gls {
-		if gl.measurements > 0 {
-			if sb.Len() == 0 {
-				sb.WriteString("New measurements: ")
-			} else {
-				sb.WriteString("; ")
-			}
-			fmt.Fprintf(&sb, "%s (%d)", gl.gid, gl.measurements)
-		}
-	}
-	if sb.Len() > 0 {
-		feedback.Info(sb.String())
-	}
+	gls.logString(
+		(*gmLog).getMissingValues,
+		"Missing mandatory values: ",
+		feedback.Warn)
+
+	gls.logString(
+		(*gmLog).getRescaleErrors,
+		"Cannot convert units: ",
+		feedback.Error)
+
+	gls.logString(
+		(*gmLog).getRescaleErrors,
+		"Ignored measure codes: ",
+		feedback.Warn)
+
+	gls.logInt(
+		(*gmLog).getPredictions,
+		"New predictions: ",
+		feedback.Info)
+
+	gls.logInt(
+		(*gmLog).getMeasurements,
+		"New measurements: ",
+		feedback.Info)
 }
 
-func (gls gmLogs) logPredictions(feedback Feedback) {
-	var sb strings.Builder
-	for _, gl := range gls {
-		if gl.predictions > 0 {
-			if sb.Len() == 0 {
-				sb.WriteString("New predictions: ")
-			} else {
-				sb.WriteString("; ")
-			}
-			fmt.Fprintf(&sb, "%s (%d)", gl.gid, gl.predictions)
-		}
-	}
-	if sb.Len() > 0 {
-		feedback.Info(sb.String())
-	}
-}
+func (gl *gmLog) getAssumedZPG() bool              { return gl.assumedZPG }
+func (gl *gmLog) getUnkown() bool                  { return gl.unknown }
+func (gl *gmLog) getIgnoredMeasureCodes() []string { return gl.ignoredMeasureCodes }
+func (gl *gmLog) getRescaleErrors() []string       { return gl.rescaleErrors }
+func (gl *gmLog) getMissingValues() []string       { return gl.missingValues }
+func (gl *gmLog) getAssumedCM() int                { return gl.assumedCM }
+func (gl *gmLog) getBadValues() int                { return gl.badValues }
+func (gl *gmLog) getPredictions() int              { return gl.predictions }
+func (gl *gmLog) getMeasurements() int             { return gl.measurements }
 
-func (gls gmLogs) logIgnoredMeasureCodes(feedback Feedback) {
-	var sb strings.Builder
-	for _, gl := range gls {
-		if len(gl.ignoredMeasureCodes) > 0 {
-			if sb.Len() == 0 {
-				sb.WriteString("Ignored measure codes: ")
-			} else {
-				sb.WriteString("; ")
-			}
-			fmt.Fprintf(&sb, "%s (", gl.gid)
-			for i, mc := range gl.ignoredMeasureCodes {
-				if i > 0 {
-					sb.WriteString(", ")
-				}
-				sb.WriteString(mc)
-			}
-			sb.WriteByte(')')
-		}
-	}
-	if sb.Len() > 0 {
-		feedback.Warn(sb.String())
-	}
-}
-
-func (gls gmLogs) logRescaleErrors(feedback Feedback) {
+func (gls gmLogs) logBool(
+	access func(*gmLog) bool,
+	header string,
+	log func(string, ...interface{}),
+) {
 	var sb strings.Builder
 	for _, gl := range gls {
-		if len(gl.rescaleErrors) > 0 {
-			if sb.Len() == 0 {
-				sb.WriteString("Cannot convert units: ")
-			} else {
-				sb.WriteString("; ")
-			}
-			fmt.Fprintf(&sb, "%s (", gl.gid)
-			for i, e := range gl.rescaleErrors {
-				if i > 0 {
-					sb.WriteString(", ")
-				}
-				sb.WriteString(e)
-			}
-			sb.WriteByte(')')
-		}
-	}
-	if sb.Len() > 0 {
-		feedback.Error(sb.String())
-	}
-}
-
-func (gls gmLogs) logMissingValues(feedback Feedback) {
-	var sb strings.Builder
-	for _, gl := range gls {
-		if len(gl.missingValues) > 0 {
+		if access(gl) {
 			if sb.Len() == 0 {
-				sb.WriteString("Missing mandatory values: ")
-			} else {
-				sb.WriteString("; ")
-			}
-			fmt.Fprintf(&sb, "%s (", gl.gid)
-			for i, m := range gl.missingValues {
-				if i > 0 {
-					sb.WriteString(", ")
-				}
-				sb.WriteString(m)
-			}
-			sb.WriteByte(')')
-		}
-	}
-	if sb.Len() > 0 {
-		feedback.Warn(sb.String())
-	}
-}
-
-func (gls gmLogs) logBadValues(feedback Feedback) {
-	var sb strings.Builder
-	for _, gl := range gls {
-		if gl.badValues > 0 {
-			if sb.Len() == 0 {
-				sb.WriteString("Ignored measurements with value -99999: ")
-			} else {
-				sb.WriteString("; ")
-			}
-			fmt.Fprintf(&sb, "%s (%d)", gl.gid, gl.badValues)
-		}
-	}
-	if sb.Len() > 0 {
-		feedback.Warn(sb.String())
-	}
-}
-
-func (gls gmLogs) logAssumedCM(feedback Feedback) {
-	var sb strings.Builder
-	for _, gl := range gls {
-		if gl.assumedCM > 0 {
-			if sb.Len() == 0 {
-				sb.WriteString("'Unit' not specified. Assuming 'cm': ")
-			} else {
-				sb.WriteString("; ")
-			}
-			fmt.Fprintf(&sb, "%s (%d)", gl.gid, gl.assumedCM)
-		}
-	}
-	if sb.Len() > 0 {
-		feedback.Warn(sb.String())
-	}
-}
-
-func (gls gmLogs) logUnknown(feedback Feedback) {
-	var sb strings.Builder
-	for _, gl := range gls {
-		if gl.assumedZPG {
-			if sb.Len() == 0 {
-				sb.WriteString("Cannot find following gauges: ")
+				sb.WriteString(header)
 			} else {
 				sb.WriteString("; ")
 			}
@@ -527,24 +436,56 @@
 		}
 	}
 	if sb.Len() > 0 {
-		feedback.Warn(sb.String())
+		log(sb.String())
+	}
+}
+
+func (gls gmLogs) logInt(
+	access func(*gmLog) int,
+	header string,
+	log func(string, ...interface{}),
+) {
+	var sb strings.Builder
+	for _, gl := range gls {
+		if v := access(gl); v > 0 {
+			if sb.Len() == 0 {
+				sb.WriteString(header)
+			} else {
+				sb.WriteString("; ")
+			}
+			fmt.Fprintf(&sb, "%s (%d)", gl.gid, v)
+		}
+	}
+	if sb.Len() > 0 {
+		log(sb.String())
 	}
 }
 
-func (gls gmLogs) logAssumedZPG(feedback Feedback) {
+func (gls gmLogs) logString(
+	access func(*gmLog) []string,
+	header string,
+	log func(string, ...interface{}),
+) {
 	var sb strings.Builder
 	for _, gl := range gls {
-		if gl.assumedZPG {
+		if s := access(gl); len(s) > 0 {
 			if sb.Len() == 0 {
-				sb.WriteString("'Reference_code' not specified. Assuming 'ZPG': ")
+				sb.WriteString(header)
 			} else {
 				sb.WriteString("; ")
 			}
-			sb.WriteString(gl.gid)
+			fmt.Fprintf(&sb, "%s (", gl.gid)
+			for i, v := range s {
+				if i > 0 {
+					sb.WriteString(", ")
+				}
+				sb.WriteString(v)
+			}
+			sb.WriteByte(')')
 		}
 	}
 	if sb.Len() > 0 {
-		feedback.Info(sb.String())
+		log(sb.String())
 	}
 }
 
@@ -619,34 +560,26 @@
 			log := findLog(curr)
 			gids = append(gids, curr)
 
-			//feedback.Info("Found measurements/predictions for %s", curr)
 			if !isKnown(curr) {
 				log.unknown = true
-				// feedback.Warn("Cannot find gauge %q for import", curr)
 				continue
 			}
 
 			var referenceCode string
 			if wrm.Reference_code == nil {
-				//feedback.Info("'Reference_code' not specified. Assuming 'ZPG'")
 				log.assumedZPG = true
 				referenceCode = "ZPG"
 			} else {
 				referenceCode = string(*wrm.Reference_code)
 			}
 
-			//badValue := 0
-			//newM, newP := 0, 0
 			for _, measure := range wrm.Measure {
 				var unit string
 				if *measure.Measure_code != nts.Measure_code_enumWAL {
 					log.ignoreMeasureCode(*measure.Measure_code)
-					//feedback.Warn("Ignored message with measure_code %s",
-					//		*measure.Measure_code)
 					continue
 				}
 				if measure.Unit == nil {
-					//feedback.Info("'Unit' not specified. Assuming 'cm'")
 					log.assumedCM++
 					unit = "cm"
 				} else {
@@ -751,14 +684,6 @@
 					}
 				}
 			}
-			//if badValue > 0 {
-			//	feedback.Warn("Ignored %d measurements with value -99999",
-			//		badValue)
-			//}
-			//feedback.Info("Inserted %d measurements for %s",
-			//	newM, curr)
-			//feedback.Info("Inserted %d predictions for %s",
-			//	newP, curr)
 		}
 	}
 	return gids, nil