package main

import "fmt"
import "net/http"
import "io"
import "io/ioutil"
import "log"
import "gopkg.in/yaml.v3"
import "time"
import "sync"
import "os/signal"
import "os"

type Check struct {
	Type     string `yaml:"type"`
	Port     int    `yaml:"port"`
	Uri      string `yaml:"uri"`
	Method   string `yaml:"method"`
	Timeout  int    `yaml:"timeout"`
	Interval int    `yaml:"interval"`
}

type Group struct {
	Name   string   `yaml:"group"`
	Tables []string `yaml:"tables"`
	Hosts  []string `yaml:"hosts"`
	Check  Check    `yaml:"check"`
}

func main() {
	log.Println("Starting")

	var waitGroup sync.WaitGroup

	var conf map[string]Group
	yamlFile, err := ioutil.ReadFile("conf.yaml")
	if err != nil {
		log.Fatalf("Configuration open error #%v ", err)
	}
	err = yaml.Unmarshal(yamlFile, &conf)
	if err != nil {
		log.Fatalf("Configuration read error #%v", err)
	}

	stopChannel := make(chan bool)
	for name, group := range conf {
		log.Println("Checking group", name, group)
		waitGroup.Add(1)
		go checkGroup(name, group, &waitGroup, stopChannel)
	}

	exit := make(chan os.Signal, 1)

	signal.Notify(exit, os.Interrupt)

	s := <-exit
	log.Println("Received signal", s)
	log.Println("main closing stopChannel")
	close(stopChannel)
	waitGroup.Wait()
}

func checkGroup(name string, group Group, waitGroup *sync.WaitGroup, stopChannel chan bool) {
	channels := make(map[string]chan int)
	for _, host := range group.Hosts {
		channel := make(chan int, 1)
		channels[host] = channel
		waitGroup.Add(1)
		go checkHost(channels[host], name, host, group.Check, waitGroup, stopChannel)
	}

	for {
		select {
		case <-stopChannel:
			log.Println("checkGroup", name, "stopChannel")
			waitGroup.Done()
			return
			break
		default:
			for host, channel := range channels {
				select {
				case stop := <-stopChannel:
					log.Println("checkGroup", name, "stopChannel", stop)
					break
				case status := <-channel:
					log.Println("Status for ", host, "is", status)
				default:
					time.Sleep(100 * time.Millisecond)
				}
			}
		}
	}
}

func checkHost(status chan<- int, group string, host string, check Check, waitGroup *sync.WaitGroup, stopChannel chan bool) {

  if check.Timeout == 0 {
    check.Timeout = 5
  }
  if check.Interval == 0 {
    check.Interval = 60
  }
  if len(check.Method) == 0 {
    check.Method = "HEAD"
  }
  if len(check.Uri) == 0 {
    check.Uri = "/"
  }
  if check.Port == 0 {
    check.Port = 80
  }
	for {
		select {
		case <-stopChannel:
			log.Println("checkHost", host, "group", group, "stopChannel")
			waitGroup.Done()
			return
		default:
      var err error

      err = nil
			switch check.Type {
			case "http":
				err = CheckHTTP(host, check)
			case "tcp":
				err = CheckTCP(host, check)
			case "smtp":
				err = CheckSMTP(host, check)
			default:
				err = CheckHTTP(host, check)
			}
      if err != nil {
        status <- 1
        log.Println("checkHost", host, "group", group, "error", err)
      } else {
        status <- 0
      }
			time.Sleep(time.Duration(check.Interval) * time.Second)
		}
	}
}

func CheckHTTP(host string, check Check) error {

	client := &http.Client{
		Timeout: time.Second * time.Duration(check.Timeout),
	}
	resp, err := client.Head(fmt.Sprintf("http://%s", host))
	if err != nil {
    return err
	} 
  _, _ = io.ReadAll(resp.Body)
  resp.Body.Close()

	return nil
}

func CheckTCP(host string, check Check) error {
  return nil
}

func CheckSMTP(host string, check Check) error {
  return nil
}