package main

import (
    "errors"
    "net/http"
    "strings"

    "github.com/alibaba/higress/plugins/wasm-go/pkg/wrapper"
    "github.com/higress-group/proxy-wasm-go-sdk/proxywasm"
    "github.com/higress-group/proxy-wasm-go-sdk/proxywasm/types"
    "github.com/tidwall/gjson"
)

var defaultTimeout uint32 = 60000

func main() {
    wrapper.SetCtx(
        "try-paths",
        wrapper.ParseConfigBy(parseConfig),
        wrapper.ProcessRequestHeadersBy(onHttpRequestHeaders),
    )
}

// 自定义插件配置
type TryPathsConfig struct {
    host     string
    port     int64
    tryPaths []string
    code     int
    client   wrapper.HttpClient
}

func Client(json gjson.Result) (wrapper.HttpClient, error) {
    serviceSource := json.Get("serviceSource").String()
    serviceName := json.Get("serviceName").String()
    servicePort := json.Get("servicePort").Int()
    if serviceName == "" || servicePort == 0 {
        return nil, errors.New("invalid service config")
    }
    switch serviceSource {
    case "k8s":
        namespace := json.Get("namespace").String()
        return wrapper.NewClusterClient(wrapper.K8sCluster{
            ServiceName: serviceName,
            Namespace:   namespace,
            Port:        servicePort,
        }), nil
    case "nacos":
        namespace := json.Get("namespace").String()
        return wrapper.NewClusterClient(wrapper.NacosCluster{
            ServiceName: serviceName,
            NamespaceID: namespace,
            Port:        servicePort,
        }), nil
    case "ip":
        return wrapper.NewClusterClient(wrapper.StaticIpCluster{
            ServiceName: serviceName,
            Port:        servicePort,
        }), nil
    case "dns":
        domain := json.Get("domain").String()
        return wrapper.NewClusterClient(wrapper.DnsCluster{
            ServiceName: serviceName,
            Port:        servicePort,
            Domain:      domain,
        }), nil
    default:
        return nil, errors.New("unknown service source: " + serviceSource)
    }
}

func parseConfig(json gjson.Result, config *TryPathsConfig, log wrapper.Log) error {
    // 解析出配置，更新到config中
    for _, result := range json.Get("tryPaths").Array() {
        config.tryPaths = append(config.tryPaths, result.String())
    }

    // code默认值为404
    if json.Get("code").String() == "" {
        config.code = http.StatusNotFound
    } else {
        config.code = int(json.Get("code").Int())
    }
    client, err := Client(json)
    if err != nil {
        return err
    }
    config.client = client
    return nil
}

func convHttpHeadersToStruct(responseHeaders http.Header) [][2]string {
    headerStruct := make([][2]string, len(responseHeaders))
    i := 0
    for key, values := range responseHeaders {
        headerStruct[i][0] = key
        headerStruct[i][1] = values[0]
        i++
    }
    return headerStruct

}

func onHttpRequestHeaders(ctx wrapper.HttpContext, config TryPathsConfig, log wrapper.Log) types.Action {
    path := ctx.Path()
    log.Infof("onHttpRequestHeaders path: %s, config: %s", path, config)
    for _, requestPath := range config.tryPaths {
        requestPath = strings.Replace(requestPath, "$uri", path, -1)
        config.client.Get(requestPath, nil,
            func(statusCode int, responseHeaders http.Header, responseBody []byte) {
                if statusCode != config.code {
                    proxywasm.SendHttpResponse(uint32(statusCode), convHttpHeadersToStruct(responseHeaders), responseBody, -1)
                    return
                }
                proxywasm.ResumeHttpRequest()
            }, defaultTimeout)
        return types.ActionPause
    }
    // 需要等待异步回调完成，返回Pause状态，可以被ResumeHttpRequest恢复
    return types.ActionPause
}