/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package service

import (
	"encoding/json"
	"fmt"
	"io/ioutil"
	"os/exec"
	"strings"
	"time"

	"github.com/apisix/manager-api/conf"
	"github.com/apisix/manager-api/errno"
	"github.com/apisix/manager-api/log"
	"github.com/apisix/manager-api/utils"
	uuid "github.com/satori/go.uuid"
)

const (
	ContentType      = "application/json"
	HTTP             = "http"
	HTTPS            = "https"
	SCHEME           = "scheme"
	WEBSOCKET        = "websocket"
	REDIRECT         = "redirect"
	PROXY_REWRIETE   = "proxy-rewrite"
	UPATHTYPE_STATIC = "static"
	UPATHTYPE_REGX   = "regx"
	UPATHTYPE_KEEP   = "keep"
)

var logger = log.GetLogger()

func (r *RouteRequest) Parse(body interface{}) error {
	if err := json.Unmarshal(body.([]byte), r); err != nil {
		r = nil
		return err
	} else {
		if r.Uris == nil || len(r.Uris) < 1 {
			r.Uris = []string{"/*"}
		}
		if len(strings.Trim(r.RouteGroupId, "")) > 0 {
			routeGroup := &RouteGroupDao{}
			if err, _ := routeGroup.FindRouteGroup(r.RouteGroupId); err != nil {
				return err
			}
			r.RouteGroupName = routeGroup.Name
		}
	}
	return nil
}

func (arr *ApisixRouteRequest) Parse(r *RouteRequest) {
	arr.Desc = r.Desc
	arr.Priority = r.Priority
	arr.Methods = r.Methods
	arr.Uris = r.Uris
	arr.Hosts = r.Hosts
	arr.Vars = r.Vars
	arr.Upstream = r.Upstream
	arr.Plugins = r.Plugins
}

func (rd *Route) Parse(r *RouteRequest, arr *ApisixRouteRequest) error {
	//rd.Name = arr.Name
	rd.Description = arr.Desc
	rd.UpstreamId = r.UpstreamId
	rd.RouteGroupId = r.RouteGroupId
	rd.RouteGroupName = r.RouteGroupName
	rd.Status = r.Status
	if content, err := json.Marshal(r); err != nil {
		return err
	} else {
		rd.Content = string(content)
	}
	if script, err := json.Marshal(r.Script); err != nil {
		return err
	} else {
		rd.Script = string(script)
	}
	timestamp := time.Now().Unix()
	rd.CreateTime = timestamp
	rd.Priority = r.Priority
	return nil
}

func (arr *ApisixRouteRequest) FindById(rid string) (*ApisixRouteResponse, error) {
	url := fmt.Sprintf("%s/routes/%s", conf.BaseUrl, rid)
	if resp, err := utils.Get(url); err != nil {
		logger.Error(err.Error())
		return nil, err
	} else {
		var arresp ApisixRouteResponse
		if err := json.Unmarshal(resp, &arresp); err != nil {
			logger.Error(err.Error())
			return nil, err
		} else {
			return &arresp, nil
		}
	}
}

func (arr *ApisixRouteRequest) Update(rid string) (*ApisixRouteResponse, error) {
	url := fmt.Sprintf("%s/routes/%s", conf.BaseUrl, rid)
	if b, err := json.Marshal(arr); err != nil {
		return nil, err
	} else {
		fmt.Println(string(b))
		if resp, err := utils.Put(url, b); err != nil {
			logger.Error(err.Error())
			return nil, err
		} else {
			var arresp ApisixRouteResponse
			if err := json.Unmarshal(resp, &arresp); err != nil {
				logger.Error(err.Error())
				return nil, err
			} else {
				return &arresp, nil
			}
		}
	}
}

func (arr *ApisixRouteRequest) Create(rid string) (*ApisixRouteResponse, error) {
	url := fmt.Sprintf("%s/routes/%s", conf.BaseUrl, rid)
	if b, err := json.Marshal(arr); err != nil {
		return nil, err
	} else {
		fmt.Println(string(b))
		if resp, err := utils.Put(url, b); err != nil {
			logger.Error(err.Error())
			return nil, err
		} else {
			var arresp ApisixRouteResponse
			if err := json.Unmarshal(resp, &arresp); err != nil {
				logger.Error(err.Error())
				return nil, err
			} else {
				return &arresp, nil
			}
		}
	}
}

func (arr *ApisixRouteRequest) Delete(rid string) (*ApisixRouteResponse, error) {
	url := fmt.Sprintf("%s/routes/%s", conf.BaseUrl, rid)
	if resp, err := utils.Delete(url); err != nil {
		logger.Error(err.Error())
		return nil, err
	} else {
		var arresp ApisixRouteResponse
		if err := json.Unmarshal(resp, &arresp); err != nil {
			logger.Error(err.Error())
			return nil, err
		} else {
			return &arresp, nil
		}
	}
}

type RouteRequest struct {
	ID               string                 `json:"id,omitempty"`
	Name             string                 `json:"name"`
	Desc             string                 `json:"desc,omitempty"`
	Priority         int64                  `json:"priority,omitempty"`
	Methods          []string               `json:"methods,omitempty"`
	Uris             []string               `json:"uris"`
	Hosts            []string               `json:"hosts,omitempty"`
	Protocols        []string               `json:"protocols,omitempty"`
	Redirect         *Redirect              `json:"redirect,omitempty"`
	Vars             [][]string             `json:"vars,omitempty"`
	Upstream         *Upstream              `json:"upstream,omitempty"`
	UpstreamId       string                 `json:"upstream_id,omitempty"`
	UpstreamProtocol string                 `json:"upstream_protocol,omitempty"`
	UpstreamPath     *UpstreamPath          `json:"upstream_path,omitempty"`
	UpstreamHeader   map[string]string      `json:"upstream_header,omitempty"`
	Plugins          map[string]interface{} `json:"plugins"`
	Script           map[string]interface{} `json:"script"`
	RouteGroupId     string                 `json:"route_group_id"`
	RouteGroupName   string                 `json:"route_group_name"`
	Status           bool                   `json:"status"`
}

func (r *ApisixRouteResponse) Parse() (*RouteRequest, error) {
	o := r.Node.Value

	//Protocols from vars and upstream
	protocols := make([]string, 0)
	if o.Upstream != nil && o.Upstream.EnableWebsocket {
		protocols = append(protocols, WEBSOCKET)
	}
	if o.UpstreamId != "" {
		protocols = append(protocols, WEBSOCKET)
	}
	flag := true
	for _, t := range o.Vars {
		if t[0] == SCHEME {
			flag = false
			protocols = append(protocols, t[2])
		}
	}
	if flag {
		protocols = append(protocols, HTTP)
		protocols = append(protocols, HTTPS)
	}
	//Redirect from plugins
	redirect := &Redirect{}
	upstreamProtocol := UPATHTYPE_KEEP
	upstreamHeader := make(map[string]string)
	upstreamPath := &UpstreamPath{}
	for k, v := range o.Plugins {
		if k == REDIRECT {
			if bytes, err := json.Marshal(v); err != nil {
				return nil, err
			} else {
				if err := json.Unmarshal(bytes, redirect); err != nil {
					return nil, err
				}
			}

		}
		if k == PROXY_REWRIETE {
			pr := &ProxyRewrite{}
			if bytes, err := json.Marshal(v); err != nil {
				return nil, err
			} else {
				if err := json.Unmarshal(bytes, pr); err != nil {
					return nil, err
				} else {
					if pr.Scheme != "" {
						upstreamProtocol = pr.Scheme
					}
					upstreamHeader = pr.Headers
					if (pr.RegexUri == nil || len(pr.RegexUri) < 2) && pr.Uri == "" {
						upstreamPath = nil
					} else if pr.RegexUri == nil || len(pr.RegexUri) < 2 {
						upstreamPath.UPathType = UPATHTYPE_STATIC
						upstreamPath.To = pr.Uri
					} else {
						upstreamPath.UPathType = UPATHTYPE_REGX
						upstreamPath.From = pr.RegexUri[0]
						upstreamPath.To = pr.RegexUri[1]
					}
				}
			}
		}
	}
	//Vars
	requestVars := make([][]string, 0)
	for _, t := range o.Vars {
		if t[0] != SCHEME {
			requestVars = append(requestVars, t)
		}
	}
	//Plugins
	requestPlugins := utils.CopyMap(o.Plugins)
	delete(requestPlugins, REDIRECT)
	delete(requestPlugins, PROXY_REWRIETE)

	// check if upstream is not exist
	if o.Upstream == nil && o.UpstreamId == "" {
		upstreamProtocol = ""
		upstreamHeader = nil
		upstreamPath = nil
	}
	if upstreamPath != nil && upstreamPath.UPathType == "" {
		upstreamPath = nil
	}
	result := &RouteRequest{
		ID:               o.Id,
		Desc:             o.Desc,
		Priority:         o.Priority,
		Methods:          o.Methods,
		Uris:             o.Uris,
		Hosts:            o.Hosts,
		Redirect:         redirect,
		Upstream:         o.Upstream,
		UpstreamId:       o.UpstreamId,
		RouteGroupId:     o.RouteGroupId,
		UpstreamProtocol: upstreamProtocol,
		UpstreamPath:     upstreamPath,
		UpstreamHeader:   upstreamHeader,
		Protocols:        protocols,
		Vars:             requestVars,
		Plugins:          requestPlugins,
	}
	return result, nil
}

type Redirect struct {
	HttpToHttps bool   `json:"http_to_https,omitempty"`
	Code        int64  `json:"code,omitempty"`
	Uri         string `json:"uri,omitempty"`
}

type ProxyRewrite struct {
	Uri      string            `json:"uri"`
	RegexUri []string          `json:"regex_uri"`
	Scheme   string            `json:"scheme"`
	Host     string            `json:"host"`
	Headers  map[string]string `json:"headers"`
}

func (r ProxyRewrite) MarshalJSON() ([]byte, error) {
	m := make(map[string]interface{})
	if r.RegexUri != nil {
		m["regex_uri"] = r.RegexUri
	}
	if r.Uri != "" {
		m["uri"] = r.Uri
	}
	if r.Scheme != UPATHTYPE_KEEP && r.Scheme != "" {
		m["scheme"] = r.Scheme
	}
	if r.Host != "" {
		m["host"] = r.Host
	}
	if r.Headers != nil && len(r.Headers) > 0 {
		m["headers"] = r.Headers
	}
	if result, err := json.Marshal(m); err != nil {
		return nil, err
	} else {
		return result, nil
	}
}

func (r Redirect) MarshalJSON() ([]byte, error) {
	m := make(map[string]interface{})
	if r.HttpToHttps {
		m["http_to_https"] = true
	} else if r.Uri != "" {
		m["code"] = r.Code
		m["uri"] = r.Uri
	}
	if result, err := json.Marshal(m); err != nil {
		return nil, err
	} else {
		return result, nil
	}
}

type Upstream struct {
	UType           string                 `json:"type"`
	Nodes           map[string]int64       `json:"nodes"`
	Timeout         UpstreamTimeout        `json:"timeout"`
	EnableWebsocket bool                   `json:"enable_websocket"`
	Checks          map[string]interface{} `json:"checks,omitempty"`
	HashOn          string                 `json:"hash_on,omitempty"`
	Key             string                 `json:"key,omitempty"`
}

type UpstreamTimeout struct {
	Connect int64 `json:"connect"`
	Send    int64 `json:"send"`
	Read    int64 `json:"read"`
}

type UpstreamPath struct {
	UPathType string `json:"type"`
	From      string `json:"from"`
	To        string `json:"to"`
}

type ApisixRouteRequest struct {
	Desc       string                 `json:"desc,omitempty"`
	Priority   int64                  `json:"priority"`
	Methods    []string               `json:"methods,omitempty"`
	Uris       []string               `json:"uris,omitempty"`
	Hosts      []string               `json:"hosts,omitempty"`
	Vars       [][]string             `json:"vars,omitempty"`
	Upstream   *Upstream              `json:"upstream,omitempty"`
	UpstreamId string                 `json:"upstream_id,omitempty"`
	Plugins    map[string]interface{} `json:"plugins,omitempty"`
	Script     string                 `json:"script,omitempty"`
	//Name     string                 `json:"name"`
}

// ApisixRouteResponse is response from apisix admin api
type ApisixRouteResponse struct {
	Action string `json:"action"`
	Node   *Node  `json:"node"`
}

type Node struct {
	Value         Value  `json:"value"`
	ModifiedIndex uint64 `json:"modifiedIndex"`
}

type Value struct {
	Id             string                 `json:"id"`
	Name           string                 `json:"name"`
	Desc           string                 `json:"desc,omitempty"`
	Priority       int64                  `json:"priority"`
	Methods        []string               `json:"methods"`
	Uris           []string               `json:"uris"`
	Hosts          []string               `json:"hosts"`
	Vars           [][]string             `json:"vars"`
	Upstream       *Upstream              `json:"upstream,omitempty"`
	UpstreamId     string                 `json:"upstream_id,omitempty"`
	Plugins        map[string]interface{} `json:"plugins"`
	RouteGroupId   string                 `json:"route_group_id"`
	RouteGroupName string                 `json:"route_group_name"`
	Status         bool                   `json:"status"`
}

type Route struct {
	Base
	Name            string `json:"name"`
	Description     string `json:"description,omitempty"`
	Hosts           string `json:"hosts"`
	Uris            string `json:"uris"`
	UpstreamNodes   string `json:"upstream_nodes"`
	UpstreamId      string `json:"upstream_id"`
	Priority        int64  `json:"priority"`
	Content         string `json:"content"`
	Script          string `json:"script"`
	ContentAdminApi string `json:"content_admin_api"`
	RouteGroupId    string `json:"route_group_id"`
	RouteGroupName  string `json:"route_group_name"`
	Status          bool   `json:"status"`
}

type RouteResponse struct {
	Base
	Name           string    `json:"name"`
	Description    string    `json:"description,omitempty"`
	Hosts          []string  `json:"hosts,omitempty"`
	Uris           []string  `json:"uris,omitempty"`
	Upstream       *Upstream `json:"upstream,omitempty"`
	UpstreamId     string    `json:"upstream_id,omitempty"`
	Priority       int64     `json:"priority"`
	RouteGroupId   string    `json:"route_group_id"`
	RouteGroupName string    `json:"route_group_name"`
	Status         bool      `json:"status"`
}

type RouteResponseWithUrl struct {
	RouteRequest
	Url string `json:"url"`
}

type ListResponse struct {
	Count int         `json:"count"`
	Data  interface{} `json:"data"`
}

func (rr *RouteResponse) Parse(r *Route) {
	rr.Base = r.Base
	rr.Name = r.Name
	rr.Description = r.Description
	rr.UpstreamId = r.UpstreamId
	rr.Priority = r.Priority
	rr.RouteGroupId = r.RouteGroupId
	rr.RouteGroupName = r.RouteGroupName
	rr.Status = r.Status
	// hosts
	if len(r.Hosts) > 0 {
		var hosts []string
		if err := json.Unmarshal([]byte(r.Hosts), &hosts); err == nil {
			rr.Hosts = hosts
		} else {
			logger.Error(err.Error())
		}
	}

	// uris
	if len(r.Uris) > 0 {
		var uris []string
		if err := json.Unmarshal([]byte(r.Uris), &uris); err == nil {
			rr.Uris = uris
		}
	}

	// uris
	var resp ApisixRouteResponse
	if err := json.Unmarshal([]byte(r.ContentAdminApi), &resp); err == nil {
		rr.Upstream = resp.Node.Value.Upstream
	}
}

// RouteRequest -> ApisixRouteRequest
func ToApisixRequest(routeRequest *RouteRequest) *ApisixRouteRequest {
	// redirect -> plugins
	plugins := utils.CopyMap(routeRequest.Plugins)
	redirect := routeRequest.Redirect
	if redirect != nil {
		plugins["redirect"] = redirect
	}

	logger.Info(routeRequest.Plugins)

	// scheme https and not http -> vars ['scheme', '==', 'https']
	pMap := utils.Set2Map(routeRequest.Protocols)

	arr := &ApisixRouteRequest{}
	arr.Parse(routeRequest)

	// protocols[websokect] -> upstream
	if pMap[WEBSOCKET] == 1 && arr.Upstream != nil {
		arr.Upstream.EnableWebsocket = true
	}
	vars := utils.CopyStrings(routeRequest.Vars)
	if pMap[HTTP] != 1 || pMap[HTTPS] != 1 {
		if pMap[HTTP] == 1 {
			vars = append(vars, []string{SCHEME, "==", HTTP})
		}
		if pMap[HTTPS] == 1 {
			vars = append(vars, []string{SCHEME, "==", HTTPS})
		}
	}
	if len(vars) > 0 {
		arr.Vars = vars
	} else {
		arr.Vars = nil
	}
	// upstreamId
	arr.UpstreamId = routeRequest.UpstreamId
	// upstream protocol
	if arr.Upstream != nil || arr.UpstreamId != "" {
		pr := &ProxyRewrite{}
		pr.Scheme = routeRequest.UpstreamProtocol
		// upstream path
		proxyPath := routeRequest.UpstreamPath
		if proxyPath != nil {
			if proxyPath.UPathType == UPATHTYPE_STATIC || proxyPath.UPathType == "" {
				pr.Uri = proxyPath.To
				pr.RegexUri = nil
			} else {
				pr.RegexUri = []string{proxyPath.From, proxyPath.To}
			}
		}
		// upstream headers
		pr.Headers = routeRequest.UpstreamHeader
		if proxyPath != nil || pr.Scheme != UPATHTYPE_KEEP || (pr.Headers != nil && len(pr.Headers) > 0) {
			plugins[PROXY_REWRIETE] = pr
		}
	}

	if plugins != nil && len(plugins) > 0 {
		arr.Plugins = plugins
	} else {
		arr.Plugins = nil
	}

	if routeRequest.Script != nil {
		arr.Script, _ = generateLuaCode(routeRequest.Script)
	}

	return arr
}

func generateLuaCode(script map[string]interface{}) (string, error) {
	scriptString, err := json.Marshal(script)
	if err != nil {
		return "", err
	}

	cmd := exec.Command("sh", "-c",
		"cd /go/manager-api/dag-to-lua/ && lua cli.lua "+
			"'"+string(scriptString)+"'")

	logger.Info("generate conf:", string(scriptString))

	stdout, _ := cmd.StdoutPipe()
	defer stdout.Close()
	if err := cmd.Start(); err != nil {
		logger.Info("generate err:", err)
		return "", err
	}

	result, _ := ioutil.ReadAll(stdout)
	resData := string(result)

	logger.Info("generated code:", resData)

	return resData, nil
}

func ToRoute(routeRequest *RouteRequest,
	arr *ApisixRouteRequest,
	u4 uuid.UUID,
	resp *ApisixRouteResponse) (*Route, *errno.ManagerError) {
	rd := &Route{}
	if err := rd.Parse(routeRequest, arr); err != nil {
		e := errno.FromMessage(errno.DBRouteCreateError, err.Error())
		return nil, e
	}
	if rd.Name == "" {
		rd.Name = routeRequest.Name
	}
	rd.ID = u4
	// content_admin_api
	if resp != nil {
		resp.Node.Value.RouteGroupId = rd.RouteGroupId
		resp.Node.Value.Status = rd.Status
		if respStr, err := json.Marshal(resp); err != nil {
			e := errno.FromMessage(errno.DBRouteCreateError, err.Error())
			return nil, e
		} else {
			rd.ContentAdminApi = string(respStr)
		}
	}
	// hosts
	hosts := routeRequest.Hosts
	if hb, err := json.Marshal(hosts); err != nil {
		e := errno.FromMessage(errno.DBRouteCreateError, err.Error())
		logger.Warn(e.Msg)
	} else {
		rd.Hosts = string(hb)
	}
	// uris
	uris := routeRequest.Uris
	if ub, err := json.Marshal(uris); err != nil {
		e := errno.FromMessage(errno.DBRouteCreateError, err.Error())
		logger.Warn(e.Msg)
	} else {
		rd.Uris = string(ub)
	}
	// upstreamNodes
	if routeRequest.Upstream != nil {
		nodes := routeRequest.Upstream.Nodes
		ips := make([]string, 0)
		for k, _ := range nodes {
			ips = append(ips, k)
		}
		if nb, err := json.Marshal(ips); err != nil {
			e := errno.FromMessage(errno.DBRouteCreateError, err.Error())
			logger.Warn(e.Msg)
		} else {
			rd.UpstreamNodes = string(nb)
		}
	}
	// upstreamId
	rd.UpstreamId = arr.UpstreamId
	return rd, nil
}