package pkg

import (
	"regexp"

	"github.rackspace.com/gorax/tools/util"
)

var (
	LISTLTMRULERE = regexp.MustCompile(`(?i)(|ltm)\s+rule\s+(\S+)\s+{\n((.|\n)*?)(ltm|$)`)
	SHOWLTMRULERE = regexp.MustCompile(`(?i)(ltm|)::rule\s+event:\s+(\S+)((.|\n)*?)(ltm|$)`)
	PRIORITYRE    = regexp.MustCompile(`(?i)priority\s+([0-9]+)`)
	TOTALRE       = regexp.MustCompile(`(?i)total\s+([0-9]+)`)
	FAILURERE     = regexp.MustCompile(`(?i)failures\s+([0-9]+)`)
	ABORTSRE      = regexp.MustCompile(`(?i)aborts\s+([0-9]+)`)
	AVERAGERE     = regexp.MustCompile(`(?i)average\s+([0-9]+)`)
	MAXIMUMRE     = regexp.MustCompile(`(?i)maximum\s+([0-9]+)`)
	MINIMUMRE     = regexp.MustCompile(`(?i)minimum\s+([0-9]+)`)
)

type (
	LtmIrules struct {
		Irules []*Irule `json:"irules"`
	}

	Irule struct {
		Name string `json:"name"`
		Rule string `json:"rule"`
	}

	LtmIruleStats struct {
		IruleStats []*IruleStat `json:"irules_stats"`
	}

	IruleStat struct {
		Name         string        `json:"name"`
		Priority     int           `json:"priority"`
		IruleExec    *IruleExec    `json:"executiions"`
		IruleCpuExec *IruleCpuExec `json:"cpu_cycles_on_executing"`
	}

	IruleExec struct {
		Total    int `json:"total"`
		Failures int `json:"failures"`
		Aborts   int `json:"aborts"`
	}

	IruleCpuExec struct {
		Average int `json:"average"`
		Maximum int `json:"maximum"`
		Minimum int `josn:"minimum"`
	}
)

func (l *LtmIrules) Parse(s string) {
	for _, r := range LISTLTMRULERE.FindAllStringSubmatch(s, -1) {
		l.Irules = append(l.Irules, &Irule{
			Name: r[2],
			Rule: r[3],
		})
	}
}

func (l *LtmIruleStats) Parse(s string) {
	for _, r := range SHOWLTMRULERE.FindAllStringSubmatch(s, -1) {
		l.IruleStats = append(l.IruleStats, &IruleStat{
			Name:     r[2],
			Priority: util.Atoi(util.RegexpString(PRIORITYRE, r[3])),
			IruleExec: &IruleExec{
				Total:    util.Atoi(util.RegexpString(TOTALRE, r[3])),
				Failures: util.Atoi(util.RegexpString(FAILURERE, r[3])),
				Aborts:   util.Atoi(util.RegexpString(ABORTSRE, r[3])),
			},
			IruleCpuExec: &IruleCpuExec{
				Average: util.Atoi(util.RegexpString(AVERAGERE, r[3])),
				Maximum: util.Atoi(util.RegexpString(MAXIMUMRE, r[3])),
				Minimum: util.Atoi(util.RegexpString(MINIMUMRE, r[3])),
			},
		})
	}
}