path: root/main.go

package main

// Takes one file as the `src` and another as the `check` (passed via -c). 
// Ensures that all entries in `check` are in `src`, returning as missing all 
// entries in `check` that are missing from `src`.
// To check all that are in `src` missing in `check`, you can firstly simply 
// switch around the order of parameters, or otherwise use bt-present, which 
// returns either a true or false that all entries on `src` are on `check`, 
// which could be used to weed out any incorrect values on `src`. 

import (
	bt "badtudexo"
	st "saggytrousers"
	xl "github.com/xuri/excelize/v2"
	"os"
	"fmt"
)

func usage() {
	fmt.Println(
`bt-missing: check whether entries on check are missing on src.

You must pass two files: a source file (src, passed as an argument) and
a check file (check, passed with --check). This script will iterate 
over all entries in the check file, and output all which are missing on 
the source file. 

This script has fundmentally two uses. 

The first is: given a larger file, check all which are _not_ on the 
smaller file. To perform this, run:
    bt-missing -c large.xlsx small.xlsx

The second is: expand the output of bt-present. bt-present returns a 
boolean whether all entries on the source file are present in the 
check file. If bt-present returns false, you may wish to get the 
entries that are missing. To do this, invoke bt-missing with the 
positions of the arguments reversed:
    bt-present -c check.xlsx src.xlsx
    bt-missing -c src.xlsx check.xlsx
This can be a little confusing - if in doubt, just switch them around 
and see whichever one looks right! 

You may specify the sheet and the columns to check against as flags 
here so you do not need to specify them when the script is running. 

You can additionally specify an output file with -o or --output; the 
output of this command will be copied into the output file. 

If the specific sheets and columns are known, it can help to pass them 
as flags, saving you to have to confirm them when the program is 
running.

Flags:
-h, --help	Display this help message.
-c, --check	The file to check against; you must pass this. 
-ss, --ssheet	The sheet to check against (for src).
-cs, --csheet	The sheet to check against (for check).
-sc, --scolumn	The column to check against (for src) as a string (i.e. not an index)
-cc, --ccolumn	The column to check against (for check) as a string (i.e. not an index)
-o, --output	The path of an output file to store the output in. 
-q, --quiet	Be quiet: do not return the results to stdout. 
		This means this script does not show if there are any 
		missing unless you also pass -o. 
`)
	os.Exit(0)
}

func parseArgs(args []string) {
	var check bool = false

	for i := 0; i < len(args); i++ {
		arg := args[i]
		switch arg {
		case "-h", "--help", "help":
			usage()
		case "-c", "--check", "--ck":
			i++
			g_ckfile = args[i]
			check = true
		case "-cs", "--csheet", "--check-sheet", "--ck-sheet":
			i++
			g_cksheet = args[i]
		case "-cc", "--ccolumn", "--check-column", "--ck-column":
			i++
			g_ckcol = args[i]
		case "-ss", "--ssheet", "--source-sheet", "--src-sheet": 
			i++
			g_srcsheet = args[i]
		case "-sc", "--scolumn", "--source-column", "--src-column":
			i++
			g_srccol = args[i]
		case "-o", "--out", "--output":
			i++
			g_out = args[i]
		case "-q", "--quiet": // Do not print to stdout.
			quiet = true

		default:
			g_srcfile = arg
		}
	}

	if !check {
		fmt.Println("You need to pass --check.")
		os.Exit(-1)
	}

	if quiet && g_out == "" {
		fmt.Println("You must pass --output if you pass -quiet.")
		os.Exit(-1)
	}
}

// Global Variables
var g_ckfile string 
var g_cksheet string
var g_ckcol string
var g_srcfile string
var g_srcsheet string
var g_srccol string
var g_out string
var quiet bool = false

func main() {
	args := os.Args
	parseArgs(args)

/* Open the check and source files. */
	// Load check file. 
	ck, err := xl.OpenFile(g_ckfile)
	if err != nil {
		fmt.Println("Could not open check file.")
		return
	}
	// Load src file. 
	src, err := xl.OpenFile(g_srcfile)
	if err != nil {
		fmt.Println("Could not open src file.")
		return
	}

/* Select the sheet and the column to operate on for the two files. */
	fmt.Println("Load the check file (you may be asked questions here.)")
	cksheet := st.SelectSheet(ck, g_cksheet)
	ckcol := st.SelectHeader(ck, cksheet, g_ckcol, /* exact: */ false) 


	fmt.Println("------ ------")
	fmt.Println("Load the source file now (you may be asked questions here.)")
	fmt.Println("------ ------")
	srcsheet := st.SelectSheet(src, g_srcsheet)
	srccol := st.SelectHeader(src, srcsheet, g_srccol, /* exact: */ false)

/* Grab the columns of each files which are to be processed with. */
	ckrows, err := ck.GetCols(cksheet)
	if err != nil {
		fmt.Printf("Could not get the rows of sheet %s of the checkfile.\n", g_cksheet)
		return
	} 
	srcrows, err := src.GetCols(srcsheet) 
	if err != nil {
		fmt.Printf("Could not get the rows of sheet %s of the sourcefile.\n", g_srcsheet)
		return
	}
	ckrow  := ckrows[ckcol]
	srcrow := srcrows[srccol]

	// Output what is checked against what. 


	// Actually, like, do the checks. 
	missing := bt.Missing(ckrow, srcrow)

	// Write the output to stdout and to a file if -o passed.
	printOutput(missing, g_out, cksheet, srcsheet, ckcol, srccol)
}

func writeBoth(quiet, write bool, file *os.File, str, errstr string) {
	if !quiet { fmt.Printf(str) }
	if write {
		_, err := file.WriteString(str)
		if err != nil {
			fmt.Printf("Could not write to file %d", errstr)
		}
	}
}

func printOutput[T comparable](missing []bt.MissingValue[T], outputFile string,
				cksheet, srcsheet string,
				ckcol, srccol int) {

/* Determine whether to write to an --out file and open it if we are. */
	writeFile := false
	out, err := os.Create(outputFile)
	if outputFile != "" && err != nil {
		fmt.Println("Cannot open file to output.")
	} else {
		writeFile = true 
	}

/* The data which was checked against. */
	writeBoth(quiet, writeFile, out, "--- Check File Information  ---\n", "check file info")
	writeBoth(quiet, writeFile, out, fmt.Sprintf("Filename: %s\n", g_ckfile), "check filename")
	writeBoth(quiet, writeFile, out, fmt.Sprintf("Sheet:    %s\n", cksheet), "check sheet")
	writeBoth(quiet, writeFile, out, fmt.Sprintf("Column:   %d\n", ckcol), "check column")

	writeBoth(quiet, writeFile, out, "--- Source File Information ---\n", "source file info")
	writeBoth(quiet, writeFile, out, fmt.Sprintf("Filename: %s\n", g_srcfile), "check filename")
	writeBoth(quiet, writeFile, out, fmt.Sprintf("Sheet:    %s\n", srcsheet), "source sheet")
	writeBoth(quiet, writeFile, out, fmt.Sprintf("Column:   %d\n", srccol), "source column")


/* Write all missing entries. */
	for _, m := range missing {
		str := fmt.Sprintf("Missing: \"%s\" at index %d.\n", m.Value, m.Index)
		if !quiet { fmt.Printf(str) }
		if writeFile {
			_, err := out.WriteString(str)
			if err != nil {
				fmt.Printf("Cannot write missing entry %d to file\n", m.Index)
			}
		}
	}

/* Write total missing entries. */
	str := fmt.Sprintf("Total Missing: %d\n", len(missing))
	if !quiet { fmt.Printf(str) }
	if writeFile {
		_, err := out.WriteString(str)
		if err != nil {
			fmt.Printf("Could not write total missing to file.")
		}
	}

}