package client

import (
	"bytes"
	"context"
	"encoding/json"
	"errors"
	"io"
	"io/ioutil"
	"mime"
	"net/http"
	"net/url"
	"os"
	"reflect"
	"strings"
	"time"
	"vamicro/api-gateway/auth"
	"vamicro/api-gateway/models"
	"vamicro/api-gateway/traces"
	"vamicro/config"
	"vamicro/extend/code"
	"vamicro/extend/util"

	"basic.com/valib/bhomeclient.git"
	"basic.com/valib/c_bhomebus.git/proto/source/bhome_msg"
	"basic.com/valib/logger.git"
	"github.com/gin-gonic/gin"
	"github.com/goinggo/mapstructure"
)

type Client struct {
	ms *bhomeclient.MicroNode
}

var (
	procName = "api-gateway"
	proc     = bhomeclient.ProcInfo{
		Name: procName, //进程名称
		ID:   procName, //进程id
		Info: "",       //进程的描述信息，用于区分同一进程名称下多个进程
	}
	firstCall = true
)

func NewClient(ctx context.Context, q chan os.Signal) (*Client, error) {
	var reg = &bhomeclient.RegisterInfo{
		Proc:     proc,
		Channel:  nil,
		PubTopic: []string{},
		SubTopic: []string{},
	}
	ms, err := bhomeclient.NewMicroNode(ctx, q, config.Server.AnalyServerId, reg, logger.Debug)
	if err != nil {
		logger.Debug("NewMicroNode err:", err)
		return nil, err
	}
	ms.StartClient()

	return &Client{
		ms: ms,
	}, nil
}

func (c *Client) PublishNetTimeout(nodes []bhome_msg.BHAddress, topic string, msg []byte, timeout int) int {
	return c.ms.PublishNetTimeout(nodes, topic, msg, timeout)
}

func (c *Client) DeRegister() {
	if c != nil && c.ms != nil {
		c.ms.DeRegister()
	}
}

func (c *Client) Free() {
	if c != nil && c.ms != nil {
		c.ms.Free()
	}
}

//过期后允许通过的url
var expired_NoAuthUrls = []string{
	"/data/api-v/authorize",
	"/data/api-v/token",
	"/data/api-v/newClient",
	"/data/api-u/users/current",
	"/data/api-u/sysmenus/me",
	"/data/api-v/clients",
	"/data/api-u/sys/login",
	"/data/api-u/sys/logout",
	"/data/api-v/info/getServerName",
	"/data/api-v/license/show",
	"/data/api-u/users/profile",
	"/data/api-v/gb28181/findAreaByParentId",
	"/data/api-v/sysinit/getInitInfo",
	"/data/api-v/sysinit/savePassword",
	"/data/api-v/sysinit/networkList",
	"/data/api-v/sysinit/initNetwork",
	"/data/api-v/sysinit/saveRegInfo",
	"/data/api-v/sysinit/getRegInfo",
}

func (c *Client) AnyRequest(ctx *gin.Context) {
	contentType := ctx.Request.Header.Get("Content-Type")
	// RFC 7231, section 3.1.1.5 - empty type
	//   MAY be treated as application/octet-stream
	if contentType == "" {
		contentType = "application/octet-stream"
	}

	if util.SysExpired {
		//试用过期之后，只允许登录入系统做更新授权处理
		up := ctx.Request.URL.Path
		if util.ArrayContains(expired_NoAuthUrls, up) {
			//授权过期之后，只允许指定的url通过
			logger.Info("expired!!!! current url:", up)
		} else {
			ctx.JSON(http.StatusBadRequest, "使用已过期，请购买授权")
			return
		}
	}
	if ctx.Request.URL.Path == "/data/api-u/users/current" {
		authDriver := auth.GenerateAuthDriver()
		user := (*authDriver).User(ctx)
		if user != nil {
			ctx.JSON(http.StatusOK, user)
		} else {
			ctx.JSON(http.StatusUnauthorized, "")
		}
		return
	} else if ctx.Request.URL.Path == "/data/api-u/sysmenus/me" {
		authDriver := auth.GenerateAuthDriver()
		userM := (*authDriver).User(ctx)
		if userM != nil {
			menus := userM["permissions"]
			util.ResponseFormat(ctx, code.Success, menus)
		} else {
			util.ResponseFormat(ctx, code.NotLogin, "")
		}
		return
	} else if ctx.Request.URL.Path == "/data/api-v/authorize" {
		err := auth.Oauth2Serv.HandleAuthorizeRequest(ctx.Writer, ctx.Request)
		if err != nil {
			ctx.JSON(http.StatusBadRequest, err)
		}
		return
	} else if ctx.Request.URL.Path == "/data/api-v/token" {
		err := auth.Oauth2Serv.HandleTokenRequest(ctx.Writer, ctx.Request)
		if err != nil {
			ctx.JSON(http.StatusInternalServerError, err)
		}
		return
	} else if ctx.Request.URL.Path == "/data/api-v/newClient" {
		err := auth.NewClient(ctx.Request.FormValue("domain"), ctx.Request.FormValue("intro"))
		if err != nil {
			util.ResponseFormat(ctx, code.SaveFail, err)
		} else {
			util.ResponseFormat(ctx, code.Success, "")
		}
		return
	} else if ctx.Request.URL.Path == "/data/api-v/clients" {
		var oauth2Model models.Oauth2Client
		oauth2Clients, err := oauth2Model.FindAll()
		if err != nil {
			util.ResponseFormat(ctx, code.DdSelectNotFindError, "")
		} else {
			util.ResponseFormat(ctx, code.Success, oauth2Clients)
		}
		return
	} else if ctx.Request.URL.Path == "/data/api-v/delClient" {
		err := auth.DelClient(ctx.Request.FormValue("id"))
		if err != nil {
			util.ResponseFormat(ctx, code.DeleteFail, "")
		} else {
			util.ResponseFormat(ctx, code.Success, "")
		}
		return
	}

	t := time.Now()
	var buffer = new(bytes.Buffer)
	buffer.ReadFrom(ctx.Request.Body)
	//ctx.Request.ParseForm()
	pfValues, parseE := parsePostForm(ctx.Request, buffer.Bytes())
	formValues, _ := url.ParseQuery(ctx.Request.URL.RawQuery)
	/** 日志modules和operations **/
	/**
	if ctx.Request.URL.Path == "/data/api-v/log/modules" {
		var moduleMod models.Modules
		modules,err := moduleMod.FindAll()
		if nil == err {
			util.ResponseFormat(ctx,code.Success,modules)
		} else {
			util.ResponseFormat(ctx,code.DdSelectNotFindError,err.Error())
		}
		return
	} else if ("/data/api-v/log/operations" == ctx.Request.URL.Path) {
		var opModel models.Operations
		mod,ok := ctx.Request.URL.Query()["module"]
		if ok {
			opers,err := opModel.FindAll(mod[0])
			if nil == err {
				util.ResponseFormat(ctx,code.Success,opers)
			} else {
				util.ResponseFormat(ctx,code.DdSelectNotFindError,err.Error())
			}
		} else {
			util.ResponseFormat(ctx,code.DdSelectNotFindError,"")
		}
		return
	}**/
	/** modules和operations结束 **/

	//if parseMultiErr := ctx.Request.ParseMultipartForm(32 << 20);parseMultiErr != nil && parseMultiErr.Error() != "request Content-Type isn't multipart/form-data" {
	//	logger.Debug("ParseMultipartForm err:", parseMultiErr)
	//}
	req := bhomeclient.Request{
		Path:        ctx.Request.URL.Path,
		Method:      ctx.Request.Method,
		ContentType: ctx.ContentType(),
		HeaderMap:   ctx.Request.Header,
		QueryMap:    ctx.Request.URL.Query(),
		FormMap:     formValues,
		PostFormMap: pfValues,
		//Body:        buffer.Bytes(),
	}
	if req.FormMap == nil {
		req.FormMap = make(map[string][]string)
	}
	if req.PostFormMap == nil {
		req.PostFormMap = make(map[string][]string)
	}

	//gin框架的body参数只允许读取一次
	if strings.HasPrefix(contentType, "multipart/form-data") {
		logger.Debug("equal, contentType:", contentType)
		ctx.Request.Body = ioutil.NopCloser(buffer)
		pe := ctx.Request.ParseMultipartForm(defaultMultipartMemory)
		if pe != nil {
			logger.Error("r.ParseMultipartForm err:", pe)
		} else {
			appendSignleFileArgs(ctx, &req)

			appendMultiArgs(ctx, &req)
		}
	} else {
		req.Body = buffer.Bytes()
	}

	if len(req.PostFormMap) > 0 {
		copyValues(req.FormMap, req.PostFormMap)
	}

	if _, exist := req.HeaderMap["Authorization"]; exist {
		delete(req.HeaderMap, "Authorization")
	}

	logger.Debug("请求解析完成耗时：", time.Since(t))
	logger.Debug("ParseForm err:", parseE, " postForm:", req.PostFormMap, " queryMap:", req.QueryMap)
	t = time.Now()
	timeOut := 15 * 1000
	if req.Path == "/data/api-v/sdk/sdkDownload" ||
		req.Path == "/data/api-v/sysset/upgrade" ||
		req.Path == "/data/api-v/sysset/getDeviceInfo" ||
		req.Path == "/data/api-v/sysset/getDeviceAuthInfo" ||
		req.Path == "/data/api-v/sdk/install" ||
		req.Path == "/data/api-v/sdk/upload" ||
		req.Path == "/data/api-v/dbperson/searchByPhoto" ||
		req.Path == "/data/api-v/cluster/joinCluster" {
		timeOut = 60 * 1000
	}
	if req.Path == "/data/api-v/sdk/findAllSdk" ||
		req.Path == "/data/api-v/app/findAllApp" {
		timeOut = 20 * 1000
	}

	rewriteUploadPath(&req)
	r, err := c.ms.Request(config.Server.AnalyServerId, req, timeOut)
	if r != nil {
		logger.Debug("请求服务耗时：", time.Since(t), " reqSize:", SizeOf(req), " repSize:", SizeOf(*r))
	} else {
		logger.Debug("请求服务耗时：", time.Since(t), " reqPath:", req.Path, " err:", err, " r:", r)
	}
	if (req.Path == "/data/api-v/sdk/upload" || req.Path == "/data/api-v/sysset/patchUpdate") && strings.EqualFold(req.Method, "GET") {
		//这两个方法前端返回的内容是特殊的，只有状态码和内容
		if err != nil {
			ctx.JSON(500, gin.H{
				"code":    500,
				"success": false,
				"msg":     err.Error(),
				"data":    "",
			})
		} else {
			if r.Success {
				if r.Data.(string) == "found" {
					ctx.String(http.StatusOK, "found")
				} else {
					ctx.String(http.StatusNoContent, "")
				}

				// readme: 目的是为日志统计的时候格式统一
				r.Success = true
			} else {
				ctx.JSON(500, gin.H{
					"code":    500,
					"success": false,
					"msg":     r.Msg,
					"data":    r.Data,
				})
			}
		}
	} else {
		if err != nil {
			ctx.JSON(500, gin.H{
				"code":    500,
				"success": false,
				"msg":     err.Error(),
				"data":    "",
			})
		} else {
			if ctx.Request.URL.Path == "/data/api-u/sys/login" && r.Success {
				loginedM := util.Struct2Map(r.Data)
				tokenM := make(map[string]interface{}, 5)
				tokenM["id"] = loginedM["id"]
				tokenM["username"] = loginedM["username"]
				tokenM["permissions"] = loginedM["permissions"]
				tokenM["roleName"] = loginedM["roleName"]
				tokenM["roles"] = loginedM["sysRoles"]
				//tokenM["headpic"] = loginedM["headpic"]
				tokenM["headpic"] = ""
				authDriver := auth.GenerateAuthDriver()
				tokenStr := (*authDriver).Login(ctx.Request, ctx.Writer, tokenM)

				userId := loginedM["id"].(string)
				auth.RemoveOutUser(userId)

				ctx.JSON(200, map[string]interface{}{
					"userInfo":      loginedM,
					"access_token":  tokenStr,
					"refresh_token": tokenStr,
					"scope":         "app",
					"token_type":    "Bearer",
					"expires_in":    time.Now().Add(time.Hour * 8).Unix(),
				})
			} else {
				cod := 200
				if !r.Success {
					cod = 500
				}
				ctx.JSON(cod, gin.H{
					"code":    cod,
					"success": r.Success,
					"msg":     r.Msg,
					"data":    r.Data,
				})
			}
		}

		op := &traces.OperationPara{
			Context: ctx,
			Error:   err,
			Reply:   r,
		}
		traces.TraceOperation(op)
	}
}

func SizeOf(d interface{}) int {
	b, _ := json.Marshal(d)
	return len(b)
}

func rewriteUploadPath(req *bhomeclient.Request) {
	if req.Path == "/data/api-v/sdk/upload" && strings.EqualFold(req.Method, "POST") {
		req.Path = "/data/api-v/sdk/uploadPack"
	} else if req.Path == "/data/api-v/sysset/patchUpdate" && strings.EqualFold(req.Method, "POST") {
		req.Path = "/data/api-v/sysset/patchUpdatePack"
	}
}

func copyValues(dst, src url.Values) {
	for k, vs := range src {
		dst[k] = append(dst[k], vs...)
	}
}

type maxBytesReader struct {
	w   http.ResponseWriter
	r   io.ReadCloser // underlying reader
	n   int64         // max bytes remaining
	err error         // sticky error
}

func (l *maxBytesReader) Read(p []byte) (n int, err error) {
	if l.err != nil {
		return 0, l.err
	}
	if len(p) == 0 {
		return 0, nil
	}
	// If they asked for a 32KB byte read but only 5 bytes are
	// remaining, no need to read 32KB. 6 bytes will answer the
	// question of the whether we hit the limit or go past it.
	if int64(len(p)) > l.n+1 {
		p = p[:l.n+1]
	}
	n, err = l.r.Read(p)

	if int64(n) <= l.n {
		l.n -= int64(n)
		l.err = err
		return n, err
	}

	n = int(l.n)
	l.n = 0

	// The server code and client code both use
	// maxBytesReader. This "requestTooLarge" check is
	// only used by the server code. To prevent binaries
	// which only using the HTTP Client code (such as
	// cmd/go) from also linking in the HTTP server, don't
	// use a static type assertion to the server
	// "*response" type. Check this interface instead:
	type requestTooLarger interface {
		requestTooLarge()
	}
	if res, ok := l.w.(requestTooLarger); ok {
		res.requestTooLarge()
	}
	l.err = errors.New("http: request body too large")
	return n, l.err
}

func (l *maxBytesReader) Close() error {
	return l.r.Close()
}

func parsePostForm(r *http.Request, bufferBytes []byte) (vs url.Values, err error) {
	if r.Body == nil {
		err = errors.New("missing form body")
		return
	}
	ct := r.Header.Get("Content-Type")
	// RFC 7231, section 3.1.1.5 - empty type
	//   MAY be treated as application/octet-stream
	if ct == "" {
		ct = "application/octet-stream"
	}
	ct, _, err = mime.ParseMediaType(ct)
	logger.Debug("ct:", ct)
	switch {
	case ct == "application/x-www-form-urlencoded":
		//var reader io.Reader = r.Body
		//maxFormSize := int64(1<<63 - 1)
		//if _, ok := r.Body.(*maxBytesReader); !ok {
		//	maxFormSize = int64(10 << 20) // 10 MB is a lot of text.
		//	reader = io.LimitReader(r.Body, maxFormSize+1)
		//}
		//b, e := ioutil.ReadAll(reader)
		//logger.Debug("ReadAll body:", string(b), " e:", e)
		//
		//var buffer = new(bytes.Buffer)
		//buffer.ReadFrom(r.Body)
		//logger.Debug("buffer:", string(buffer.Bytes()))
		//
		//if e != nil {
		//	if err == nil {
		//		err = e
		//	}
		//	break
		//}
		//if int64(len(b)) > maxFormSize {
		//	err = errors.New("http: POST too large")
		//	return
		//}
		var e error
		vs, e = url.ParseQuery(string(bufferBytes))
		if err == nil {
			err = e
		}
	case ct == "multipart/form-data":
		// handled by ParseMultipartForm (which is calling us, or should be)
		// TODO(bradfitz): there are too many possible
		// orders to call too many functions here.
		// Clean this up and write more tests.
		// request_test.go contains the start of this,
		// in TestParseMultipartFormOrder and others.
	}
	return
}

const defaultMultipartMemory = 32 << 20 // 32 MB
func parseMultipartForm(r *http.Request) {

}

//处理请求中的上传文件参数
func appendSignleFileArgs(ctx *gin.Context, req *bhomeclient.Request) {
	//single file arg
	file, header, err := ctx.Request.FormFile("file")

	if file != nil && header != nil && err == nil {
		logger.Debug("single file header.Filename:", header.Filename)

		defer file.Close()
		fileBytes, err := ioutil.ReadAll(file)
		if err != nil {
			logger.Debug("ioutil.ReadAll err:", err)
			return
		}
		req.File = bhomeclient.FileArg{
			Name:  header.Filename,
			Size:  header.Size,
			Bytes: fileBytes,
		}
	} else {
		logger.Debug("single FormFile err:", err)
	}
}

func appendMultiArgs(ctx *gin.Context, req *bhomeclient.Request) {
	//multi file arg
	form, err := ctx.MultipartForm()
	if err != nil {
		logger.Debug("appendFileArgs err:", err)
		return
	}
	for _, fhs := range form.File {
		if len(fhs) > 0 {
			for _, fh := range fhs {
				f, err := fh.Open()
				if err != nil {
					logger.Debug("fh.Open err:", err)
					continue
				}
				fileBytes, err := ioutil.ReadAll(f)
				if err != nil {
					logger.Debug("ioutil.ReadAll err:", err)
					f.Close()
					continue
				}
				req.MultiFiles = append(req.MultiFiles, bhomeclient.FileArg{
					Name:  fh.Filename,
					Size:  fh.Size,
					Bytes: fileBytes,
				})
				f.Close()
			}
		}
	}

	if len(form.Value) > 0 {
		for k, v := range form.Value {
			req.PostFormMap[k] = v
		}
	}
}

func (c *Client) ModuleMapInit() {
	var operations models.Operations
	req := bhomeclient.Request{
		Path:        "/data/api-v/log/operations",
		Method:      "POST",
		ContentType: "application/x-www-form-urlencoded",
		HeaderMap:   make(map[string][]string),
		QueryMap:    make(map[string][]string),
		FormMap:     make(map[string][]string),
		PostFormMap: make(map[string][]string),
		//Body:        buffer.Bytes(),
	}
	timeOut := 5 * 1000
	r, err := c.ms.Request(config.Server.AnalyServerId, req, timeOut)
	if nil == err && r.Success {
		logger.Debug(r)
		logger.Debug("operations map kind", reflect.TypeOf(r.Data).Kind())
		//list := r.Data.([]models.Operations)
		//traces.SetBlockMethod(list)
		setBlockMethod(r.Data.([]interface{}))
	} else {
		for {
			time.Sleep(3 * time.Second)
			r, err := c.ms.Request(config.Server.AnalyServerId, req, timeOut)
			if nil == err && r.Success {
				logger.Debug(r)
				logger.Debug("operations map kind", reflect.TypeOf(r.Data).Kind())
				//list := r.Data.([]models.Operations)
				//traces.SetBlockMethod(list)
				setBlockMethod(r.Data.([]interface{}))
				break
			}
		}
	}
	operations.Name = "test"

	req = bhomeclient.Request{
		Path:        "/data/api-v/log/find_all_modules_map",
		Method:      "POST",
		ContentType: "application/x-www-form-urlencoded",
		HeaderMap:   make(map[string][]string),
		QueryMap:    make(map[string][]string),
		FormMap:     make(map[string][]string),
		PostFormMap: make(map[string][]string),
		//Body:        buffer.Bytes(),
	}
	timeOut = 5 * 1000
	r, err = c.ms.Request(config.Server.AnalyServerId, req, timeOut)
	if nil == err && r.Success {
		//logger.Debug(r)
		//logger.Debug("module map kind",reflect.TypeOf(r.Data).Kind())
		setModuleMap(r.Data.(map[string]interface{}))
		//traces.SetModuleMap((r.Data).(map[string]string))
	} else {
		for {
			time.Sleep(3 * time.Second)
			r, err := c.ms.Request(config.Server.AnalyServerId, req, timeOut)
			if nil == err && r.Success {
				//logger.Debug(r)
				//logger.Debug("module map kind",reflect.TypeOf(r.Data).Kind())
				setModuleMap(r.Data.(map[string]interface{}))
				break
			}
			logger.Error(err.Error())
		}
	}
}

func setModuleMap(mapItem map[string]interface{}) {
	moduleMap := make(map[string]string)
	for key, item := range mapItem {
		moduleMap[key] = item.(string)
	}
	logger.Debug(moduleMap)
	traces.SetModuleMap(moduleMap)
}

func setBlockMethod(res []interface{}) {
	var operations []models.Operations
	for _, item := range res {
		operation, err := transOperationsStruct(item.(map[string]interface{}))
		if nil == err {
			operations = append(operations, operation)
		}
	}
	logger.Debug("operation extract")
	logger.Debug(operations)
	traces.SetBlockMethod(operations)
	auth.AclInit(operations)
}

func transOperationsStruct(mapitem map[string]interface{}) (models.Operations, error) {
	var operation models.Operations
	if err := mapstructure.Decode(mapitem, &operation); err != nil {
		return operation, err
	}

	return operation, nil
}

/*
func (c *Client) Forward(ctx *gin.Context) {
	targetHost := &TargetHost{
		Host:    "localhost",
		IsHttps: false,
	}
	HostReverseProxy(ctx.Writer, ctx.Request, targetHost)
}

func GetVerTLSConfig(CAPath string) (*tls.Config, error) {
	caData, err := ioutil.ReadFile(CAPath)
	if err != nil {
		return nil, err
	}
	pool := x509.NewCertPool()
	pool.AppendCertsFromPEM(caData)
	tlsConfig := &tls.Config{
		RootCAs: pool,
	}
	return tlsConfig, nil
}

func HostReverseProxy(w http.ResponseWriter, req *http.Request, targetHost *TargetHost) {
	host := ""
	if targetHost.IsHttps {
		host = host + "https://"
	} else {
		host = host + "http://"
	}
	remote, err := url.Parse(host + targetHost.Host)
	if err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		return
	}
	proxy := httputil.NewSingleHostReverseProxy(remote)
	if targetHost.IsHttps {
		tls, err := GetVerTLSConfig(targetHost.CAPath)
		if err != nil {
			w.WriteHeader(http.StatusInternalServerError)
			return
		}
		var pTransport http.RoundTripper = &http.Transport{
			Dial: func(netw, addr string) (net.Conn, error) {
				c, err := net.DialTimeout(netw, addr, time.Second * 5)
				if err != nil {
					return nil, err
				}
				return c, nil
			},
			ResponseHeaderTimeout: time.Second * 3,
			TLSClientConfig:       tls,
		}
		proxy.Transport = pTransport
	}
	proxy.ServeHTTP(w, req)
}

type TargetHost struct {
	Host    string
	IsHttps bool
	CAPath  string
}*/