package main

import (
    "fmt"
    "time"

    logql "github.com/Apoorvgarg-creator/go-logql"
)

func main() {
    q := logql.NewLogQuery().
        Eq("job", "api").
        Eq("env", "prod").
        LineContains("error")

    fmt.Println(q.String())
    // {job="api", env="prod"} |= "error"

    m := logql.Rate(q, 5*time.Minute).
        Sum().
        By("job", "instance")

    fmt.Println(m.String())
    // sum by (job, instance) (rate({job="api", env="prod"} |= "error" [5m]))
}

q := logql.NewLogQuery().
    Eq("job", "api").          // {job="api"}
    Neq("env", "dev").         // {env!="dev"}
    Re("instance", "10\\..*"). // {instance=~"10\..*"}
    Nre("method", "OPTIONS")   // {method!~"OPTIONS"}

q := logql.NewLogQuery().
    Eq("job", "api").
    LineContains("error").       // |= "error"
    LineNotContains("debug").    // != "debug"
    LineMatch("error|warn").     // |~ "error|warn"
    LineNotMatch("trace|debug")  // !~ "trace|debug"

// JSON parser
q := logql.NewLogQuery().Eq("job", "api").JSON()
// {job="api"} | json

// JSON with specific fields
q = logql.NewLogQuery().Eq("job", "api").JSON("status", "method")
// {job="api"} | json status, method

// Logfmt parser
q = logql.NewLogQuery().Eq("job", "api").Logfmt()
// {job="api"} | logfmt

// Regexp parser
q = logql.NewLogQuery().Eq("job", "api").Regexp(`(?P<method>\w+) (?P<path>\S+)`)
// {job="api"} | regexp "(?P<method>\w+) (?P<path>\S+)"

// Pattern parser
q = logql.NewLogQuery().Eq("job", "api").Pattern("<method> <path> <status>")
// {job="api"} | pattern "<method> <path> <status>"

// Unpack
q = logql.NewLogQuery().Eq("job", "api").Unpack()
// {job="api"} | unpack

q := logql.NewLogQuery().
    Eq("job", "api").
    JSON().
    LabelEqual("level", "error").     // | level = "error"
    LabelNotEqual("method", "GET").   // | method != "GET"
    LabelGreater("status", "400").    // | status > 400
    LabelGreaterEq("status", "400"). // | status >= 400
    LabelLess("duration", "5s").      // | duration < 5s
    LabelLessEq("duration", "10s").  // | duration <= 10s
    LabelRe("method", "GET|POST").    // | method =~ "GET|POST"
    LabelNre("path", "/health.*")     // | path !~ "/health.*"

q := logql.NewLogQuery().
    Eq("job", "api").
    JSON().
    LineFormat("{{.msg}}").              // | line_format "{{.msg}}"
    LabelFormatEntry("dst", "src").      // | label_format dst=src
    Drop("internal_id", "trace_id").     // | drop internal_id, trace_id
    Keep("level", "msg").                // | keep level, msg
    Decolorize()                         // | decolorize

base := logql.NewLogQuery().Eq("job", "api").Eq("env", "prod")

errors := base.LineContains("error")
warnings := base.LineContains("warning")

fmt.Println(base.String())     // {job="api", env="prod"}
fmt.Println(errors.String())   // {job="api", env="prod"} |= "error"
fmt.Println(warnings.String()) // {job="api", env="prod"} |= "warning"

q := logql.NewLogQuery().Eq("job", "api")

logql.Rate(q, 5*time.Minute)            // rate({job="api"} [5m])
logql.CountOverTime(q, 1*time.Hour)      // count_over_time({job="api"} [1h])
logql.BytesRate(q, 5*time.Minute)        // bytes_rate({job="api"} [5m])
logql.BytesOverTime(q, 1*time.Hour)      // bytes_over_time({job="api"} [1h])
logql.AbsentOverTime(q, 5*time.Minute)   // absent_over_time({job="api"} [5m])
logql.FirstOverTime(q, 5*time.Minute)    // first_over_time({job="api"} [5m])
logql.LastOverTime(q, 5*time.Minute)     // last_over_time({job="api"} [5m])

q := logql.NewLogQuery().Eq("job", "api").JSON().Unwrap("latency_ms")

logql.SumOverTime(q, 5*time.Minute)      // sum_over_time({...} | json | unwrap latency_ms [5m])
logql.AvgOverTime(q, 5*time.Minute)      // avg_over_time(...)
logql.MaxOverTime(q, 5*time.Minute)      // max_over_time(...)
logql.MinOverTime(q, 5*time.Minute)      // min_over_time(...)
logql.StddevOverTime(q, 5*time.Minute)   // stddev_over_time(...)
logql.StdvarOverTime(q, 5*time.Minute)   // stdvar_over_time(...)
logql.QuantileOverTime(0.95, q, 5*time.Minute) // quantile_over_time(0.95, ...)

q := logql.NewLogQuery().Eq("job", "api")
r := logql.Rate(q, 5*time.Minute)

r.Sum()                        // sum (rate(...))
r.Avg()                        // avg (rate(...))
r.Min()                        // min (rate(...))
r.Max()                        // max (rate(...))
r.Count()                      // count (rate(...))
r.Stddev()                     // stddev (rate(...))
r.Stdvar()                     // stdvar (rate(...))
r.TopK(5)                      // topk(5, rate(...))
r.BottomK(3)                   // bottomk(3, rate(...))
r.Sort()                       // sort(rate(...))
r.SortDesc()                   // sort_desc(rate(...))

r := logql.Rate(
    logql.NewLogQuery().Eq("job", "api"),
    5*time.Minute,
)

r.Sum().By("job", "instance")       // sum by (job, instance) (rate(...))
r.Sum().Without("instance")         // sum without (instance) (rate(...))
r.Offset(1 * time.Hour)             // rate(...) offset 1h

errors := logql.Rate(
    logql.NewLogQuery().Eq("job", "api").LineContains("error"),
    5*time.Minute,
)
total := logql.Rate(
    logql.NewLogQuery().Eq("job", "api"),
    5*time.Minute,
)

// Error rate as percentage
expr := logql.Mul(logql.Div(errors, total), &logql.Literal{Value: 100})
fmt.Println(expr.String())
// (rate({job="api"} |= "error" [5m]) / rate({job="api"} [5m])) * 100

// Comparison with bool modifier
alert := logql.CmpGt(
    logql.Rate(logql.NewLogQuery().Eq("job", "api").LineContains("error"), 5*time.Minute),
    &logql.Literal{Value: 10},
).Bool()
fmt.Println(alert.String())
// rate({job="api"} |= "error" [5m]) > bool 10

q := logql.NewLogQuery() // no selectors
_, err := q.Build()
// err: "logql: at least one stream selector is required"