// Copyright (c) 2021. Huawei Technologies Co., Ltd. All rights reserved.

// Package common define common utils
package common

import (
"bytes"
"encoding/json"
"errors"
"github.com/gin-gonic/gin"
"github.com/stretchr/testify/assert"
"huawei.com/mindxdl/base/common/constants"
"huawei.com/npu-exporter/hwlog"
"io"
"io/ioutil"
"net/http"
"net/http/httptest"
"testing"
)

const (
// PUT is Put method
PUT = "PUT"
// GET is Get method
GET = "GET"
// POST is Post method
POST = "POST"
// DELETE is Delete method
DELETE = "DELETE"
// PATCH is Patch method
PATCH = "PATCH"
)

var (
// RoleCode is roleRode
RoleCode = constants.NormalUserRole
)

// TestSuccess if status is ok, pass
func TestSuccess(t *testing.T, getRes []byte, successWay string) {
var response ResultMsg
if err := json.Unmarshal(getRes, &response); err != nil {
hwlog.RunLog.Errorf("Unmarshal param happen err : %v", err)
return
}
status := response.Status
assert.Equal(t, successWay, status)
}

// TestSuccessData need response.Data is right
func TestSuccessData(t *testing.T, getRes []byte, data interface{}) {
var response ResultMsg
if err := json.Unmarshal(getRes, &response); err != nil {
hwlog.RunLog.Errorf("Unmarshal param happen err : %v", err)
return
}
assert.Equal(t, response.Data, data)
}

func performRequest(r *gin.Engine, method, path string, body io.Reader) *httptest.ResponseRecorder {
req, err := http.NewRequest(method, path, body)
if err != nil {
hwlog.RunLog.Errorf("NewRequest happen err : %v", err)
return nil
}
req.Header.Set("Content-Type", "application/json;charset=UTF-8")
req.Header.Set("sessionid", "123456")
req.Header.Set("userid", "654321")
req.Header.Set("groupid", "111111")
req.Header.Set("roleid", "2")
req.Header.Set("roleCode", RoleCode)
w := httptest.NewRecorder()
r.ServeHTTP(w, req)
return w
}

// Get request get
func Get(router *gin.Engine, uri string) []byte {
w := performRequest(router, "GET", uri, nil)
result := w.Result()
defer result.Body.Close()
body, err := ioutil.ReadAll(result.Body)
if err != nil {
hwlog.RunLog.Errorf("Get IOUtil readAll happen err : %v", err)
return nil
}
return body
}

// Delete request delete
func Delete(router *gin.Engine, uri string) []byte {
w := performRequest(router, "DELETE", uri, nil)
result := w.Result()
defer result.Body.Close()
body, err := ioutil.ReadAll(result.Body)
if err != nil {
hwlog.RunLog.Errorf("Delete IOUtil readAll happen err : %v", err)
return nil
}
return body
}

// Put request put
func Put(router *gin.Engine, uri string, param map[string]interface{}) []byte {
jsonByte, err := json.Marshal(param)
if err != nil {
hwlog.RunLog.Errorf("Put Marshal param happen err : %v", err)
return nil
}
w := performRequest(router, "PUT", uri, bytes.NewReader(jsonByte))
result := w.Result()
defer result.Body.Close()
body, err := ioutil.ReadAll(result.Body)
if err != nil {
hwlog.RunLog.Errorf("Delete IOUtil readAll happen err : %v", err)
return nil
}
return body
}

// RestfulAPI include post get put delete for ut
func RestfulAPI(router *gin.Engine, operate, uri string, param map[string]interface{}) []byte {
header := map[string]string{
"Content-Type": "application/json;charset=UTF-8",
"requestid": "123456",
"userid": "654321",
"groupid": "111111",
"roleid": "2",
"roleCode": RoleCode,
}
return RestfulAPIV2(router, operate, uri, header, param)
}

// RestfulAPIV2 RestfulAPIV2
func RestfulAPIV2(router *gin.Engine, operate, uri string, header map[string]string,
param map[string]interface{}) []byte {
var paramStr string
if len(param) != 0 {
jsonByte, err := json.Marshal(param)
if err != nil {
hwlog.RunLog.Errorf("%s Marshal param happen err : %v", operate, err)
return nil
}
paramStr = string(jsonByte)
}

handler := new(HTTPHandler)
req, err := handler.NewRequest(operate, uri, paramStr)
if err != nil {
hwlog.RunLog.Errorf("NewRequest happen err : %v", err)
return nil
}
handler.SetHeader(req, header)

res := httptest.NewRecorder()
router.ServeHTTP(res, req)

result := res.Result()
defer result.Body.Close()
body, err := ioutil.ReadAll(result.Body)
if err != nil {
hwlog.RunLog.Errorf("%s IOUtil readAll happen err : %v", operate, err)
return nil
}
return body
}

// ParseResponseToStruct parse response to struct
func ParseResponseToStruct(rspBytes []byte) (*ResultMsg, error) {
if len(rspBytes) == 0 {
return nil, errors.New("no response")
}
var response ResultMsg
if err := json.Unmarshal(rspBytes, &response); err != nil {
hwlog.RunLog.Errorf("Unmarshal param happen err : %v", err)
return nil, err
}
return &response, nil
}