package scheduler

import (
	"bytes"
	"encoding/gob"
	"fmt"
	"local/firestormy/logger"
	"os/exec"

	"github.com/google/uuid"
)

type Job struct {
	Name     string
	Schedule string
	Raw      string
	Runner   Runner
	foo      func()
}

func NewJob(runner Runner, schedule, raw string) (*Job, error) {
	switch runner {
	case Bash:
		return newBashJob(schedule, raw)
	default:
		return nil, ErrBadRunner
	}
}

func newBashJob(schedule, sh string) (*Job, error) {
	if !validCron(schedule) {
		return nil, ErrBadCron
	}
	return &Job{
		Name:     uuid.New().String(),
		Schedule: schedule,
		Raw:      sh,
		Runner:   Bash,
		foo: func() {
			cmd := exec.Command("bash", "-c", sh)
			out, err := cmd.CombinedOutput()
			if err != nil {
				panic(err)
			}
			logger.New().Info(fmt.Sprintf("executed %s: %s", sh, out))
		},
	}, nil
}

func (j *Job) Run() {
	j.foo()
}

func (j *Job) Encode() ([]byte, error) {
	buff := bytes.NewBuffer(nil)
	encoder := gob.NewEncoder(buff)
	err := encoder.Encode(*j)
	return buff.Bytes(), err
}

func (j *Job) Decode(b []byte) error {
	buff := bytes.NewReader(b)
	decoder := gob.NewDecoder(buff)
	err := decoder.Decode(j)
	if err != nil {
		return err
	}
	k, err := NewJob(j.Runner, j.Schedule, j.Raw)
	if err == nil {
		k.Name = j.Name
		*j = *k
	}
	return err
}