package main

import (
	"flag"
	"fmt"
	"io"
	"os"
	"os/exec"
	"strconv"
)

import (
	"mailq-inspector/parser"
)

var settings = make(map[string]string)

func main() {
	parseArguments()
	if settings["interactive"] == "false" {
		showQueue()
	}
	if settings["interactive"] == "true" {
		interactiveShell()
	}
}

func parseArguments() {
	mailqCommandPtr := flag.String("mailqCommand", "mailq", "Command to use for getting mailq output")
	mailqCommandArgsPtr := flag.String("mailqCommandArgs", "", "Optional arguments to pass to mailqCommand")
	interactivePtr := flag.Bool("interactive", false, "Set to true for shell mode")
	machineFormatPtr := flag.Bool("machineFormat", false, "Set to true to get output suitable for cut/awk/...")
	usePagerPtr := flag.Bool("usePager", true, "Use pager to display output?")
	flag.Parse()
	settings["mailqCommand"] = *mailqCommandPtr
	settings["mailqCommandArgs"] = *mailqCommandArgsPtr
	settings["interactive"] = strconv.FormatBool(*interactivePtr)
	settings["machineFormat"] = strconv.FormatBool(*machineFormatPtr)
	settings["usePager"] = strconv.FormatBool(*usePagerPtr)
}

func interactiveShell() {

}

func showQueue() {
	queue, err := fetchQueue()
	if err != nil {
		fmt.Printf("Could not fetch queue entries: %s\n", err.Error())
		os.Exit(1)
	}
	if settings["usePager"] == "true" {
		pagerReader, pagerWriter := io.Pipe()
		pagerDone := make(chan bool)
		go launchPager(pagerReader, pagerDone)
		printQueue(queue, pagerWriter)
		pagerWriter.Close()
		// Wait for pager to be closed before continuing the main program
		<-pagerDone
	} else {
		printQueue(queue, os.Stdout)
	}
}

func printQueue(queue parser.MailQ, writer io.Writer) {
	if settings["machineFormat"] == "true" {
		queue.PrintMachineReadable(writer)
	} else {
		queue.PrintHumanReadable(writer)
	}
}

func launchPager(reader *io.PipeReader, pagerDone chan<- bool) {
	cmd := exec.Command("less", "--chop-long-lines")
	cmd.Stdin = reader
	cmd.Stdout = os.Stdout
	if err := cmd.Start(); err != nil {
		fmt.Printf("Error launching pager: %s\n", err.Error())
	}
	if err := cmd.Wait(); err != nil {
		fmt.Printf("Error terminating pager: %s\n", err.Error())
	} else {
		reader.Close()
		pagerDone <- true
	}
}

func fetchQueue() (parser.MailQ, error) {
	if settings["mailqCommandArgs"] == "" {
		return readFromCmd(exec.Command(settings["mailqCommand"]))
	} else {
		return readFromCmd(exec.Command(settings["mailqCommand"], settings["mailqCommandArgs"]))
	}
}

func readFromCmd(cmd *exec.Cmd) (parser.MailQ, error) {
	stdout, err := cmd.StdoutPipe()
	if err != nil {
		return parser.MailQ{}, err
	}
	if err := cmd.Start(); err != nil {
		return parser.MailQ{}, err
	}
	result, resultError := parser.ParseMailQ(stdout)
	if err := cmd.Wait(); err != nil {
		return parser.MailQ{}, err
	}
	return result, resultError
}