package main

import (
	"database/sql"
	"net/http"
	"time"
)

type (
	check struct {
		NodeId      int
		NodeName    string
		CommandName string
		CheckID     int64
		CheckName   string
		MappingId   int
		State       int
		Enabled     bool
		Notify      bool
		Notice      sql.NullString
		NextTime    time.Time
		Msg         string
		StateSince  time.Time
	}

	checkDetails struct {
		Id             int64
		Name           string
		Message        string
		Enabled        bool
		Updated        time.Time
		LastRefresh    time.Time
		NextTime       time.Time
		MappingId      int
		MappingName    string
		NodeId         int
		NodeName       string
		NodeMessage    string
		CommandId      int
		CommandName    string
		CommandLine    []string
		CommandMessage string
		States         []int64
		Notice         sql.NullString
		Notifiers      []notifier
		Notifications  []notification
		CheckerID      int
		CheckerName    string
		CheckerMsg     string
	}

	notifier struct {
		Id      int
		Name    string
		Enabled bool
	}

	notification struct {
		Id           int64
		State        int
		Output       string
		Inserted     time.Time
		Sent         sql.NullTime
		NotifierName string
		MappingId    int
	}
)

// showCheck loads shows the notifications for a specific check.
func showCheck(con *Context) {
	cd := checkDetails{}
	con.CheckDetails = &cd
	id, found := con.r.URL.Query()["check_id"]
	if !found {
		con.Error = "no check given to view"
		returnError(http.StatusNotFound, con, con.w)
		return
	}
	query := `select c.id, c.name, c.message, c.enabled, c.updated, c.last_refresh,
		m.id, m.name, n.id, n.name, n.message, co.id, co.Name, co.message,
		ac.cmdline, ac.states, ac.msg, ac.next_time, ch.id, ch.name, ch.description
	from checks c
	join active_checks ac on c.id = ac.check_id
	join nodes n on c.node_id = n.id
	join commands co on c.command_id = co.id
	join mappings m on ac.mapping_id = m.id
	join checkers ch on c.checker_id = ch.id
	where c.id = $1::bigint`
	err := DB.QueryRow(query, id[0]).Scan(&cd.Id, &cd.Name, &cd.Message, &cd.Enabled,
		&cd.Updated, &cd.LastRefresh, &cd.MappingId, &cd.MappingName, &cd.NodeId,
		&cd.NodeName, &cd.NodeMessage, &cd.CommandId, &cd.CommandName, &cd.CommandMessage,
		&cd.CommandLine, &cd.States, &cd.Notice, &cd.NextTime,
		&cd.CheckerID, &cd.CheckerName, &cd.CheckerMsg)
	if err != nil && err == sql.ErrNoRows {
		con.w.Header()["Location"] = []string{"/"}
		con.w.WriteHeader(http.StatusSeeOther)
		return
	} else if err != nil {
		con.w.WriteHeader(http.StatusInternalServerError)
		con.w.Write([]byte("problems with the database"))
		con.log.Info("could not get check details for check id", "id", id[0], "error", err)
		return
	}

	query = `select n.id, states[1], output, inserted, sent, no.name, n.mapping_id
		from notifications n
		join notifier no on n.notifier_id = no.id
		where check_id = $1::bigint
		order by inserted desc
		limit 500`
	rows, err := DB.Query(query, cd.Id)
	defer rows.Close()
	if err != nil {
		con.log.Info("could not load notifications", "error", err)
		con.Error = "could not load notification information"
		returnError(http.StatusInternalServerError, con, con.w)
		return
	}
	cd.Notifications = []notification{}
	for rows.Next() {
		if err := rows.Err(); err != nil {
			con.log.Info("could not load notifications", "error", err)
			con.Error = "could not load notification information"
			returnError(http.StatusInternalServerError, con, con.w)
			return
		}
		no := notification{}
		if err := rows.Scan(&no.Id, &no.State, &no.Output, &no.Inserted,
			&no.Sent, &no.NotifierName, &no.MappingId); err != nil {
			con.log.Info("could not scan notifications", "error", err)
			con.Error = "could not load notification information"
			returnError(http.StatusInternalServerError, con, con.w)
			return
		}
		cd.Notifications = append(cd.Notifications, no)
	}

	if err := con.loadMappings(); err != nil {
		con.w.WriteHeader(http.StatusInternalServerError)
		con.w.Write([]byte("problem with the mappings"))
		con.log.Info("could not load mappings", "error", err)
		return
	}

	con.w.Header()["Content-Type"] = []string{"text/html"}
	con.Render("check")
}

func showChecks(con *Context) {
	query := `select c.id, c.name, n.id, n.name, co.name, ac.mapping_id, ac.states[1] as state,
	ac.enabled, ac.notice, ac.next_time, ac.msg,
	case when cn.check_id is null then false else true end as notify_enabled,
	state_since
  from active_checks ac
	join checks c on ac.check_id = c.id
	join nodes n on c.node_id = n.id
	join commands co on c.command_id = co.id
	left join ( select distinct check_id from checks_notify where enabled = true) cn on c.id = cn.check_id`
	filter := newFilter()
	con.Filter = filter
	if id, found := con.r.URL.Query()["group_id"]; found {
		query += ` join nodes_groups ng on n.id = ng.node_id`
		filter.Add("ng.group_id", "=", id[0], "int")
	}
	filter.filterChecks(con)
	if search, found := con.r.URL.Query()["search"]; found {
		filter.AddSpecial(
			`to_tsvector('english', regexp_replace(n.name, '[.-/]', ' ', 'g'))`,
			`@@`,
			`to_tsquery('english', regexp_replace($%d, '[.-/]', ' & ', 'g') || ':*')`,
			search[0])
	}
	if id, found := con.r.URL.Query()["node_id"]; found {
		filter.Add("n.id", "=", id[0], "int")
	}
	if id, found := con.r.URL.Query()["check_id"]; found {
		filter.Add("c.id", "=", id[0], "int")
	}
	where, params := filter.Join()
	if len(where) > 0 {
		query += " where " + where
	}
	query += ` order by n.name, c.name, co.name`
	rows, err := DB.Query(query, params...)
	if err != nil {
		con.w.WriteHeader(http.StatusInternalServerError)
		con.w.Write([]byte("problems with the database"))
		con.log.Info("could not get check list", "error", err)
		return
	}
	defer rows.Close()

	checks := []check{}
	for rows.Next() {
		c := check{}
		err := rows.Scan(&c.CheckID, &c.CheckName, &c.NodeId, &c.NodeName, &c.CommandName, &c.MappingId,
			&c.State, &c.Enabled, &c.Notice, &c.NextTime, &c.Msg, &c.Notify, &c.StateSince)
		if err != nil {
			con.w.WriteHeader(http.StatusInternalServerError)
			returnError(http.StatusInternalServerError, con, con.w)
			con.log.Info("could not get check list", "error", err)
			return
		}
		checks = append(checks, c)
	}
	con.Checks = checks
	if err := con.loadCommands(); err != nil {
		con.Error = "could not load commands"
		returnError(http.StatusInternalServerError, con, con.w)
		con.log.Info("could not get commands", "error", err)
		return
	}
	if err := con.loadMappings(); err != nil {
		con.Error = "could not load mapping data"
		con.w.WriteHeader(http.StatusInternalServerError)
		con.w.Write([]byte("problem with the mappings"))
		con.log.Info("could not load mappings", "error", err)
		return
	}
	con.w.Header()["Content-Type"] = []string{"text/html"}
	con.Render("checklist")
	return
}