package bhomedbapi

import (
	"basic.com/valib/bhomebus.git"
	"encoding/json"
	"errors"
	"strconv"
)

type SBusClient struct {
	nodes []bhomebus.NetNode
}

type ProcInfo struct {
	Name 			string 				`json:"name"` // 进程名称
	ID   			string 				`json:"id"`   // 进程唯一标识
	Info 			string 				`json:"info"` // 进程的描述信息，用于区分同一进程名称下多个进程
}

type MsgInfo struct {
	SrcProc  		ProcInfo   			`json:"srcProc"`    	// 源进程基本信息
	MsgType   		string 				`json:"msgType"`        // 数据类型，可为请求、发布、订阅、应答等
	Topic 			string				`json:"topic"`			//请求主题
	Body 			[]byte				`json:"body"`			//请求内容或者反馈结果
}

type Request struct {
	Path        			string              	`json:"path"`
	Method      			string              	`json:"method"`
	ContentType 			string              	`json:"contentType"`
	HeaderMap   			map[string][]string 	`json:"headerMap"`
	QueryMap    			map[string][]string 	`json:"queryMap"`
	FormMap     			map[string][]string 	`json:"formMap"`
	PostFormMap 			map[string][]string 	`json:"postFormMap"`
	Body        			[]byte              	`json:"body"`
}

type reply struct {
	Success 			bool 						`json:"success"`
	Msg 				string 						`json:"msg"`
	Data 				interface{} 				`json:"data"`
}

func (sc SBusClient) DoGetRequest(url string, params map[string]string, headers map[string]string) ([]byte, error) {
	if sc.nodes == nil || len(sc.nodes) == 0 {
		return nil, errors.New("invalid netNodes")
	}

	req := Request{
		Path:        url,
		Method:      "GET",
		ContentType: CONTENT_TYPE_JSON,
	}
	fillParam(&req, headers, params, nil)

	rb, err := json.Marshal(req)
	if err !=nil {
		return nil,err
	}
	rMsg := MsgInfo{
		Topic: req.Path,
		Body: rb,
	}
	rData, err := json.Marshal(rMsg)
	if err != nil {
		return nil, err
	}

	return busReq(rData, sc.nodes)
	//return doReq(req, sc.nodes)
}

func (sc SBusClient) DoPostRequest(url string, contentType string, body map[string]interface{}, params map[string]string, headers map[string]string) ([]byte, error) {
	if sc.nodes == nil || len(sc.nodes) == 0 {
		return nil, errors.New("invalid port")
	}
	req := Request{
		Path:        url,
		Method:      "POST",
		ContentType: contentType,
	}
	fillParam(&req, headers, params, body)
	if contentType == CONTENT_TYPE_FORM || contentType == CONTENT_TYPE_MULFORM {
		if body != nil {
			req.PostFormMap = make(map[string][]string)
			for k,v := range body {
				switch v.(type) {
				case string:
					req.FormMap[k] = []string{v.(string)}
					req.PostFormMap[k] = []string{v.(string)}
				case int:
					req.FormMap[k] = []string{strconv.Itoa(v.(int))}
					req.PostFormMap[k] = []string{strconv.Itoa(v.(int))}
				case bool:
					req.FormMap[k] = []string{strconv.FormatBool(v.(bool))}
					req.PostFormMap[k] = []string{strconv.FormatBool(v.(bool))}
				default:
					logPrint("fill FORM or MultiForm,unknown value type,type is ", v)
				}

			}
		}
	} else if contentType == CONTENT_TYPE_JSON {
		bs, err := json.Marshal(body)
		if err != nil {
			logPrint("fill json body err:", err)
		} else {
			req.Body = bs
		}
	}

	rb, err := json.Marshal(req)
	if err !=nil {
		return nil,err
	}
	rMsg := MsgInfo{
		Topic: req.Path,
		Body: rb,
	}
	rData, err := json.Marshal(rMsg)
	if err != nil {
		return nil, err
	}

	return busReq(rData, sc.nodes)
}

func (sc SBusClient) DoPutRequest(url string, contentType string, body map[string]interface{}, headers map[string]string) ([]byte, error) {
	if sc.nodes == nil || len(sc.nodes) == 0 {
		return nil, errors.New("invalid port")
	}
	req := Request{
		Path:        url,
		Method:      "PUT",
		ContentType: contentType,
	}
	fillParam(&req, headers, nil, body)

	rb, err := json.Marshal(req)
	if err !=nil {
		return nil,err
	}
	rMsg := MsgInfo{
		Topic: req.Path,
		Body: rb,
	}
	rData, err := json.Marshal(rMsg)
	if err != nil {
		return nil, err
	}

	return busReq(rData, sc.nodes)
}

func (sc SBusClient) DoDeleteRequest(url string, contentType string, body map[string]interface{}, headers map[string]string) ([]byte, error) {
	if sc.nodes == nil || len(sc.nodes) == 0 {
		return nil, errors.New("invalid port")
	}
	req := Request{
		Path:        url,
		Method:      "DELETE",
		ContentType: contentType,
	}
	fillParam(&req, headers, nil, body)

	rb, err := json.Marshal(req)
	if err !=nil {
		return nil,err
	}
	rMsg := MsgInfo{
		Topic: req.Path,
		Body: rb,
	}
	rData, err := json.Marshal(rMsg)
	if err != nil {
		return nil, err
	}

	return busReq(rData, sc.nodes)
}

func fillParam(req *Request,headers map[string]string, params map[string]string, body map[string]interface{}) {
	headerMap := make(map[string][]string)
	queryMap := make(map[string][]string)
	if headers != nil {
		for k,v := range headers {
			headerMap[k] = []string{v}
		}
	}
	if params != nil {
		for k,v := range params {
			queryMap[k] = []string{v}
		}
	}
	req.HeaderMap = headerMap
	req.QueryMap = queryMap
	b, err := json.Marshal(body)
	if err != nil {
		logPrint("marshal body err:", err)
	} else {
		req.Body = b
	}

}

//在此处使用OpenSocket会在Ctrl-C的时候，导致socket并未成功Close，共享内存块不会释放.
//所以控制共享内存块的成功回收需要在上层做,然后调InitDoReq将函数指针传递进来
//func doReq(req Request, nodes []bhomebus.NetNode) ([]byte,error) {
//	rb, err := json.Marshal(req)
//	if err !=nil {
//		return nil,err
//	}
//	rMsg := MsgInfo{
//		Topic: req.Path,
//		Body: rb,
//	}
//	data, err := json.Marshal(rMsg)
//	if err != nil {
//		return nil, err
//	}
//	s := bhomebus.OpenSocket()
//	defer s.Close()
//	var ret []bhomebus.Mesg
//	if n := s.SendandrecvTimeout(nodes, data, &ret, 5000);n == 0 {  //n==0表示没有请求成功
//		return nil, fmt.Errorf("doReq s.SendandrecvTimeout result n:%d", n)
//	} else {
//		if len(ret) > 0 {
//			return ret[0].Data, nil
//		}
//		return nil, fmt.Errorf("no any response")
//	}
//}