package main

import "fmt"
import "log"
import "strings"
import "io"
import "time"
import "os"
import "os/exec"
import "bufio"
import "reflect"
import "github.com/davecgh/go-spew/spew"

/*
func exampleCommand(a string, b ...string) {
	// cmd := exec.Command(range myargs)
	// args := []string{"/tmp", "/"}
	// cmd := exec.Command(args)
	cmd := exec.Command(a, b...)
	cmd.Stdin = strings.NewReader("foobar")
	var out bytes.Buffer
	cmd.Stdout = &out
	err := cmd.Run()
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(out.String())
	// fmt.Printf("in all caps: %q\n", out.String())
}

func format(mybut *ui.Button) {
	log.Println("doButton() mybut =", reflect.ValueOf(mybut).Elem())
	log.Println("format and mount here")
	exampleCommand("ls", "/tmp")
	ping()
}
*/

func ping(hostname string, count int) {
	cmdName := "ping " + hostname
	cmdArgs := strings.Fields(cmdName)

	cmd := exec.Command(cmdArgs[0], cmdArgs[1:len(cmdArgs)]...)
	stdout, _ := cmd.StdoutPipe()
	cmd.Start()

	f := bufio.NewWriter(os.Stdout)

	for {
		const delay = 1000 * time.Millisecond
		time.Sleep(delay / 2)
		// log.Println("sleep done")

		oneByte := make([]byte, 100)
		stuff, err := stdout.Read(oneByte)
		if stuff != 0 {
			// log.Println("stuff:", stuff)
			// f.Write([]byte("test \n"))
			f.Write(oneByte)
			f.Flush()
		}
		if err != nil {
			log.Println("ERROR:", err.Error())
		}
	}

	cmd.Wait()
}

// this runs a process, then captures both the stdout
// and stderr in raw byte (so ncurses-like things work)
// the does unbuffered writes to stdout by running
// a flush() on each write to stdout

func shellRAW(hostname string, count int) {
	cmdName := "ping " + hostname
	cmdArgs := strings.Fields(cmdName)

	cmd := exec.Command(cmdArgs[0], cmdArgs[1:len(cmdArgs)]...)

	// merge stdout and stderr into a combined buffer
	stdout, _ := cmd.StdoutPipe()
	stderr, _ := cmd.StderrPipe()
	merged := io.MultiReader(stderr, stdout)
	scanner := bufio.NewScanner(merged)

	cmd.Start()
//	oneByte := make([]byte, 100)


	num := 1
	for {
		// stuff := scanner.Bytes()
		stuff := scanner.Text()
		if stuff == "" {
			// log.Println("START ", stuff)
			// fmt.Printf(err.Error())
/*
			f := bufio.NewWriter(os.Stdout)
			f.Write(stuff)
			f.Flush()
*/
			// break
		} else {
			log.Println("START is nil", stuff)
		}
/*
		r := bufio.NewReader(stdout)
		line, _, _ := r.ReadLine()
		fmt.Println(string(line))
*/
		num = num + 1
/*
		if num > count {
			os.Exit(0)
		}
*/
	}

	cmd.Wait()
}

func script(cmds string) int {
	// split on new lines (while we are at it, handle stupid windows text files
	lines := strings.Split(strings.Replace(cmds, "\r\n", "\n", -1), "\n")

	for _, line := range lines {
		line = strings.TrimSpace(line) // this is like 'chomp' in perl
		fmt.Println("LINE:", line)
		time.Sleep(1)
		// simpleProcess("ls /")
		simpleProcess(line)
	}
	return 0
}

// Spawns a process and captures stdout and stderr
// this has to internally handle 'cd' and call os.Chdir()
func simpleProcess(cmd string) int {
	log.Println("START " + cmd)
	// cmd := exec.Command("ls", "/tmp", "/ballon", "/")

	cmd = strings.TrimSpace(cmd) // this is like 'chomp' in perl
	cmdArgs := strings.Fields(cmd)
	if (len(cmdArgs) == 0) {
		log.Println("END   " + cmd)
		return 0 // nothing to do
	}
	if (cmdArgs[0] == "cd") {
		if (len(cmdArgs) > 1) {
			log.Println("os.Chdir()", cmd)
			os.Chdir(cmdArgs[1])
		}
		log.Println("END   " + cmd)
		return 0 // nothing to do
	}
	process := exec.Command(cmdArgs[0], cmdArgs[1:len(cmdArgs)]...)
	stdout, _ := process.StdoutPipe()
	stderr, _ := process.StderrPipe()
	process.Start()

	pid := process.Process.Pid
	log.Println("pid =", pid)
	log.Println(reflect.ValueOf(process.Process).Elem())
	log.Println(reflect.TypeOf(process.Process))

	merged := io.MultiReader(stderr, stdout)
	scanner := bufio.NewScanner(merged)
	for scanner.Scan() {
		line := scanner.Text()
		fmt.Println("NOT " + line) // Println will add back the final '\n'
	}
	if err := scanner.Err(); err != nil {
		// fmt.Fprintln(os.Stderr, "reading standard input:", err)
		fmt.Println("reading standard input:", err)
	}

	// One must wait for the process to formally finish and flush all buffer output
	err := process.Wait()

	// try to process the return value from the OS. As of golang 1.12,
	// this should be cross platform (linux,macos,windows)
	if err != nil {
		spew.Dump(err.(*exec.ExitError))
		spew.Dump(process.ProcessState)
		stuff := err.(*exec.ExitError)
		log.Println("ERROR ", stuff)
		log.Println("END   ", cmd)
		return -1
	}
	log.Println("END   " + cmd)
	return 0
}

func exampleScanner() {
	// cmd := exec.Command("ls", "/tmp", "/ballon", "/")
	cmd := exec.Command("ls", "/ballon")
	stdout, _ := cmd.StdoutPipe()
	cmd.Start()

	scanner := bufio.NewScanner(stdout)
	for scanner.Scan() {
		line := scanner.Text()
		fmt.Println("NOT " + line) // Println will add back the final '\n'
	}
	if err := scanner.Err(); err != nil {
		// fmt.Fprintln(os.Stderr, "reading standard input:", err)
		fmt.Println("reading standard input:", err)
	}
}

// prompt = whatever you would type at the command line "ls /tmp"
// timeout = number of lines to read in until exit
func stdoutExec(prompt string, timeout int) {
	cmdArgs := strings.Fields(prompt)

	cmd := exec.Command(cmdArgs[0], cmdArgs[1:len(cmdArgs)]...)
	stdout, _ := cmd.StdoutPipe()
	cmd.Start()
	// oneByte := make([]byte, 100)
	num := 1
	for {
		/*
		_, err := stdout.Read(oneByte)
		if err != nil {
			fmt.Printf(err.Error())
			break
		}
		*/
		r := bufio.NewReader(stdout)
		line, _, _ := r.ReadLine()
		fmt.Println(string(line))
		num = num + 1
		if num > timeout {
			os.Exit(0)
		}
	}

	cmd.Wait()
}

func brokenping(hostname string, count int) {
	cmdName := "ping " + hostname
	cmdArgs := strings.Fields(cmdName)

	cmd := exec.Command(cmdArgs[0], cmdArgs[1:len(cmdArgs)]...)

	stdout, _ := cmd.StdoutPipe()
/*
	stderr, _ := cmd.StderrPipe()
	merged := io.MultiReader(stderr, stdout)
	scanner := bufio.NewScanner(merged)
*/

	scanner := bufio.NewScanner(stdout)

	cmd.Start()

	f := bufio.NewWriter(os.Stdout)

	for {
		time.Sleep(100 * time.Millisecond)   // only check the buffer 10 times a second
		log.Println("sleep done")

		smallbuf := make([]byte, 1024)       // make a 1K buffer. just do this each time so it's empty
		// stuff, err := stdout.Read(smallbuf)
		smallbuf = scanner.Bytes()
		if len(smallbuf) != 0 {
			log.Println("stuff:", smallbuf)
			// f.Write([]byte("test \n"))
			f.Write(smallbuf)
			f.Flush()
		}
/*
		if err != nil {
			log.Println("ERROR:", err.Error())
		}
*/

/*
		smallbuf = make([]byte, 1024)        // make a 1K buffer. just do this each time so it's empty
		log.Println("try stderr")
		stuff, err = stderr.Read(smallbuf)
		log.Println("tried stderr")
		if stuff != 0 {
			log.Println("stuff:", stuff)
			f.Write([]byte("test \n"))
			f.Write(smallbuf)
			f.Flush()
		}
		if err != nil {
			log.Println("ERROR:", err.Error())
		}
*/
	}

	cmd.Wait()
}