package main

import (
	"bytes"
	"flag"
	"fmt"
	"io"
	"log"
	"os"
	"os/exec"
	"path/filepath"
	"regexp"
	"strings"
	"time"

	"gopkg.in/yaml.v2"

	"jobwatch/state"
	"jobwatch/types"
)

// Jobs root-idfile

func evalOutput(job types.Job, output []string) (types.CMKState, error) {
	var res types.CMKState = types.OK
	var logLines []string
	var rcs []*regexp.Regexp

	for _, m := range job.LogMatches {
		r, err := regexp.Compile(m.Regex)
		if err != nil {
			return 0, err
		} else {
			rcs = append(rcs, r)
		}
	}

	// Determine state and wanted loglines
	for _, v := range output {
		for idx, m := range job.LogMatches {
			if rcs[idx].Match([]byte(v)) {
				if m.State > res {
					res = m.State
				}

				if m.AltMsg != "" {
					v = fmt.Sprintf(m.AltMsg, v)
				}

				var p = ""
				switch s := m.State; s {
				case types.OK:
					p = "O"
				case types.WARN:
					p = "W"
				case types.CRIT:
					p = "C"
				case types.UNKNOWN:
					p = "U"
				}
				p += ": "
				logLines = append(logLines, time.Now().Format("2006-01-2 15:04:05")+" "+p+v)

			}
		}
	}
	for _, oln := range logLines {
		log.Printf("- Matched LogLine %v\n", oln)
	}

	return res, nil
}

func loadJob(jobdir string, jobid string) (*types.Job, error) {
	// Find jobfile
	var dirs []string
	if jobdir != "" {
		dirs = append(dirs, jobdir)
	} else {
		if hd, err := os.UserHomeDir(); err == nil {
			dirs = append(dirs, filepath.FromSlash(hd)+"/jobwatch.d")
		}
		dirs = append(dirs, "/etc/jobwatch.d")
	}

	var jobfile = ""
	for _, d := range dirs {
		jobfile = filepath.FromSlash(d + "/" + jobid + ".job.yml")
		if _, err := os.Stat(jobfile); err == nil {
			break
		} else {
			jobfile = ""
			continue
		}
	}

	if jobfile == "" {
		return nil, fmt.Errorf("JobFile not found")
	}

	// Load job from jobfile
	job := types.Job{}
	bytes, _ := os.ReadFile(jobfile)
	err := yaml.Unmarshal(bytes, &job)

	if err == nil {
		log.Printf("%+v\n", job)
	} else {
		return nil, fmt.Errorf("! Error reading job %v: %+v\n", jobfile, err)
	}
	return &job, nil
}

func runJob(job types.Job) (types.CMKState, error) {

	cmd := exec.Command(job.Cmd, append(job.Args, job.InstArgs...)...)

	var stdoutBuf, stderrBuf, stdcombinedBuf bytes.Buffer
	if job.HideOutput {
		cmd.Stdout = io.MultiWriter(&stdoutBuf, &stdcombinedBuf)
		cmd.Stderr = io.MultiWriter(&stderrBuf, &stdcombinedBuf)
	} else {
		cmd.Stdout = io.MultiWriter(os.Stdout, &stdoutBuf, &stdcombinedBuf)
		cmd.Stderr = io.MultiWriter(os.Stderr, &stderrBuf, &stdcombinedBuf)
	}

	var state = 0
	if err := cmd.Run(); err != nil {
		// cmd executed, but failed w/ non-zero
		if exitError, ok := err.(*exec.ExitError); ok {
			state = exitError.ProcessState.ExitCode()
		} else {
			// cmd not found etc
			return types.UNKNOWN, err
		}
		if state == 0 { // Exec failed, but exitcode, be sure to get error!
			state = int(types.UNKNOWN)
		}
	} else {
		state = cmd.ProcessState.ExitCode()
	}
	log.Printf("- ExitCode of Command: %v", state)

	for _, em := range job.ExitCodeMap {
		// From == -1 -> Alle non-zero-states mappen
		if (state == int(em.From)) || (em.From == -1 && state > 0) {
			state = int(em.To)
		}
	}
	if state > int(types.UNKNOWN) {
		state = int(types.CRIT)
	}
	log.Printf("- State after ExitCodeMapping: %v", state)

	outText := string(stdcombinedBuf.Bytes())
	log_state, err := evalOutput(job, strings.Split(outText, "\n"))
	if int(log_state) > state {
		state = int(log_state)
	}

	log.Printf("- State Output-evaluation: %v", state)

	return types.CMKState(state), err
}

func setup() (*types.Job, error) {
	var jobdir string
	var jobid string
	var job_instance string
	var debug bool

	flag.StringVar(&jobdir, "jd", "", "JobDir. Default: $HOME/etc/jobwatch.d /etc/jobwatch.d'")
	flag.StringVar(&jobid, "j", "", "JobId. reads $jobDir/$job.job.yml Default ''")
	flag.StringVar(&job_instance, "i", "", "JobId Instance. Default ''")
	flag.BoolVar(&debug, "d", false, "Debug")
	flag.Parse()

	if debug {
		log.SetOutput(os.Stderr)
	} else {
		log.SetOutput(nil)
	}

	if !regexp.MustCompile("^[a-z0-9]*$").MatchString(job_instance) {
		return nil, fmt.Errorf("-i invalid chars")
	}

	log.Printf(". Raw args : %+v\n", flag.Args())
	log.Printf(". Job onstance id : %+v\n", job_instance)

	if job, err := loadJob(jobdir, jobid); err == nil {
		job.InstArgs = flag.Args()
		job.InstId = job_instance
		return job, nil
	} else {
		return nil, err
	}
}

func main() {
	fmt.Println("Jobwatch 0.1")

	job, err := setup()

	var res = types.UNKNOWN
	if err == nil {
		res, err = runJob(*job)
	}

	if err != nil {
		fmt.Printf("! Error running job %+v\n", err)
		os.Exit(int(types.UNKNOWN))
	} else {
		os.Exit(int(res))
	}

	state.WriteLog(*job)
}