package requests

import (
	"net/http"
	"net/url"
	"regexp"
	"strings"
	"testing"
	"time"

	"github.com/tidwall/gjson"
)

func TestNewSession(t *testing.T) {
	ses := NewSession()
	if ses == nil {
		t.Error("session create fail, value is nil")
	}
}

func TestSession_Get(t *testing.T) {
	type fields struct {
		client *http.Client
	}
	type args struct {
		url string
	}
	tests := []struct {
		name   string
		fields fields
		args   args
	}{
		{
			name:   "Get test",
			fields: fields{client: &http.Client{}},
			args:   args{url: "http://httpbin.org/get"},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			ses := &Session{
				client: tt.fields.client,
			}
			resp, err := ses.Get(tt.args.url).Execute()
			if err != nil {
				t.Error(err)
			}
			if len(resp.Content()) <= 150 {
				t.Error(resp.Content())
			}
		})
	}
}

func TestSession_Post(t *testing.T) {
	type args struct {
		params []interface{}
	}

	tests := []struct {
		name string
		args args
		want *regexp.Regexp
	}{
		{
			name: "Post test",
			args: args{params: nil},
			want: regexp.MustCompile(`"form": \{\}`),
		},
		{
			name: "Post data",
			args: args{params: []interface{}{[]byte("a=1&b=2")}},
			want: regexp.MustCompile(`"form": \{[^"]+"a": "1"[^"]+"b": "2"[^\}]+\}`),
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			ses := NewSession()
			got, err := ses.Post("http://httpbin.org/post").SetBodyAuto(tt.args.params...).Execute()

			if err != nil {
				t.Errorf("Metchod error = %v", err)
				return
			}

			if tt.want.MatchString(got.readContent) == false {
				t.Errorf("Metchod = %v, want %v", got, tt.want)
			}

		})
	}
}

func TestSession_Setparams(t *testing.T) {
	type fields struct {
		client *http.Client
		params *Body
	}
	type args struct {
		params []interface{}
	}
	tests := []struct {
		name    string
		fields  fields
		args    args
		want    *regexp.Regexp
		wantErr bool
	}{
		{
			name: "test Setparams",
			args: args{params: []interface{}{map[string]string{"a": "1", "b": "2"}}},
			want: regexp.MustCompile(`"form": \{[^"]+"a": "1"[^"]+"b": "2"[^\}]+\}`),
		},
		{
			name: "test json",
			args: args{params: []interface{}{`{"a":"1","b":"2"}`, TypeJSON}},
			want: regexp.MustCompile(`"json": \{[^"]+"a": "1"[^"]+"b": "2"[^\}]+\}`),
		},
		{
			name:   "test xml",
			fields: fields{client: &http.Client{}, params: NewBody()},
			args:   args{params: []interface{}{`<request><parameters><password>test</password></parameters></request>`, TypeXML}},
			want:   regexp.MustCompile(`"data": "<request><parameters><password>test</password></parameters></request>"`),
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			ses := NewSession()

			got, err := ses.Post("http://httpbin.org/post").SetBodyAuto(tt.args.params...).Execute()
			if (err != nil) != tt.wantErr {
				t.Errorf("Metchod error = %v, wantErr %v", err, tt.wantErr)
				return
			}

			if tt.want.MatchString(got.readContent) == false {
				t.Errorf("Metchod = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestSession_PostUploadFile(t *testing.T) {
	type args struct {
		params interface{}
	}

	tests := []struct {
		name string
		args args
		want *regexp.Regexp
	}{
		{
			name: "test post uploadfile glob",
			args: args{params: "tests/*.js"},
			want: regexp.MustCompile(`"file0": "data:application/octet-stream;base64`),
		},
		{
			name: "test post uploadfile only one file",
			args: args{params: "tests/json.file"},
			want: regexp.MustCompile(`"file0": "json.file.+jsonjsonjsonjson"`),
		},
		{
			name: "test post uploadfile key values",
			args: args{params: map[string]string{"a": "32"}},
			want: regexp.MustCompile(`"a": "32"`),
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			ses := NewSession()
			got, err := ses.Post("http://httpbin.org/post").SetBodyAuto(tt.args.params, TypeFormData).Execute()

			if err != nil {
				t.Errorf("Metchod error = %v", err)
				return
			}

			if tt.want.MatchString(got.readContent) == false {
				t.Errorf("Metchod = %v, want %v", got, tt.want)
			}

		})
	}
}

func TestSession_Put(t *testing.T) {
	type args struct {
		params interface{}
	}

	tests := []struct {
		name string
		args args
		want *regexp.Regexp
	}{
		{
			name: "test post uploadfile glob",
			args: args{params: "tests/*.js"},
			want: regexp.MustCompile(`"file0": "data:application/octet-stream;base64`),
		},
		{
			name: "test post uploadfile only one file",
			args: args{params: "tests/json.file"},
			want: regexp.MustCompile(`"file0": "json.file.+jsonjsonjsonjson"`),
		},
		{
			name: "test post uploadfile key values",
			args: args{params: map[string]string{"a": "32"}},
			want: regexp.MustCompile(`"a": "32"`),
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			ses := NewSession()
			got, err := ses.Put("http://httpbin.org/put").SetBodyAuto(tt.args.params, TypeFormData).Execute()

			if err != nil {
				t.Errorf("Metchod error = %v", err)
				return
			}

			if tt.want.MatchString(got.readContent) == false {
				t.Errorf("Metchod = %v, want %v", got, tt.want)
			}

		})
	}
}

func TestSession_Patch(t *testing.T) {
	type args struct {
		params interface{}
	}

	tests := []struct {
		name string
		args args
		want *regexp.Regexp
	}{
		{
			name: "test post uploadfile glob",
			args: args{params: "tests/*.js"},
			want: regexp.MustCompile(`"file0": "data:application/octet-stream;base64`),
		},
		{
			name: "test post uploadfile only one file",
			args: args{params: "tests/json.file"},
			want: regexp.MustCompile(`"file0": "json.file.+jsonjsonjsonjson"`),
		},
		{
			name: "test post uploadfile key values",
			args: args{params: map[string]string{"a": "32"}},
			want: regexp.MustCompile(`"a": "32"`),
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			ses := NewSession()
			got, err := ses.Patch("http://httpbin.org/patch").SetBodyAuto(tt.args.params, TypeFormData).Execute()

			if err != nil {
				t.Errorf("Metchod error = %v", err)
				return
			}

			if tt.want.MatchString(got.readContent) == false {
				t.Errorf("Metchod = %v, want %v", got, tt.want)
			}

		})
	}
}

func TestSession_SetConfig(t *testing.T) {

	type args struct {
		typeConfig TypeConfig
		values     interface{}
	}
	tests := []struct {
		name    string
		args    args
		wantErr bool
	}{
		{
			name:    "test timeout",
			args:    args{typeConfig: CRequestTimeout, values: 0.0001},
			wantErr: true,
		},

		{
			name:    "test not timeout",
			args:    args{typeConfig: CRequestTimeout, values: 5},
			wantErr: false,
		},

		{
			name:    "test proxy",
			args:    args{typeConfig: CProxy, values: "http://" + ProxyAddress},
			wantErr: false,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			ses := NewSession()
			ses.SetConfig(tt.args.typeConfig, tt.args.values)
			_, err := ses.Get("http://httpbin.org/get").Execute()

			if (err != nil) != tt.wantErr {
				t.Errorf("Metchod error = %v", err)
				return
			}

		})
	}
}

func TestSession_SetConfigInsecure(t *testing.T) {

	ses := NewSession()
	ses.SetConfig(CInsecure, true)

	for _, badSSL := range []string{
		"https://self-signed.badssl.com/",
		"https://expired.badssl.com/",
		"https://wrong.host.badssl.com/",
	} {
		resp, err := ses.Get(badSSL).Execute()
		if err != nil {
			t.Error("Unable to make request", err)
		}
		if resp.readResponse.StatusCode != 200 {
			t.Error("Request did not return OK, is ", resp.readResponse.StatusCode)
		}
	}

}

func TestSession_Cookies(t *testing.T) {
	ses := NewSession()

	t.Run("set cookie", func(t *testing.T) {
		resp, err := ses.Get("http://httpbin.org/cookies/set").AddKVCookie("a", "1").Execute()
		if err != nil {
			t.Error("cookies set error", err)
		}

		if !regexp.MustCompile(`"a": "1"`).MatchString(resp.readContent) {
			t.Error(resp.readContent)
		}
	})
}

func TestSession_Header(t *testing.T) {
	chromeua := "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3497.100 Safari/537.36"
	ses := NewSession()

	t.Run("ua header test", func(t *testing.T) {

		ses.Header.Add(HeaderKeyUA, chromeua)
		resp, err := ses.Get("https://www.baidu.com").Execute()
		if err != nil {
			t.Error("cookies set error", err)
		}

		if len(resp.readContent) <= 5000 {
			t.Error(resp.readContent, len(resp.readContent))
		}

		ses = NewSession()
		resp, err = ses.Get("https://www.baidu.com").AddHeader(HeaderKeyUA, chromeua).Execute()
		if err != nil {
			t.Error("cookies set error", err)
		}

		if len(resp.readContent) <= 5000 {
			t.Error(resp.readContent, len(resp.readContent))
		}
	})
}

func TestSession_ConfigEx(t *testing.T) {
	ses := NewSession()
	ses.SetConfig(CRequestTimeout, time.Microsecond)
	resp, err := ses.Get("http://httpbin.org/get").Execute()
	if err == nil {
		t.Error(resp)
	} else {
		if strings.LastIndex(err.Error(), "Client.Timeout exceeded while awaiting headers") < 0 {
			t.Error(err)
		}
	}

	ses.SetConfig(CRequestTimeout, float32(0.0000001))
	resp, err = ses.Get("http://httpbin.org/get").Execute()
	if err == nil {
		t.Error(resp)
	} else {
		if strings.LastIndex(err.Error(), "Client.Timeout exceeded while awaiting headers") < 0 {
			t.Error(err)
		}
	}

	ses.SetConfig(CKeepAlives, true)
	ses.SetConfig(CRequestTimeout, int64(5))
	// jar, _ := cookiejar.New(&cookiejar.Options{PublicSuffixList: publicsuffix.List})
	u, err := url.Parse("http://httpbin.org")
	if err != nil {
		t.Error(err)
	} else {
		// jar.SetCookies(u, []*http.Cookie{&http.Cookie{Name: "Request", Value: "Cookiejar"}})
		ses.SetConfig(CIsWithCookiejar, false)
		ses.SetConfig(CIsWithCookiejar, true)
		ses.SetCookies(u, []*http.Cookie{&http.Cookie{Name: "Request", Value: "Cookiejar"}, &http.Cookie{Name: "eson", Value: "bad"}})
		resp, err = ses.Get("http://httpbin.org/get").Execute()
		if err != nil {
			t.Error(err)
		}

		if gjson.Get(resp.Content(), "headers.Cookie").String() != "Request=Cookiejar; eson=bad" {
			t.Error(resp.Content())
		}

		if resp.GetSrcResponse().Header["Connection"][0] != "keep-alive" {
			t.Error("CKeepAlive is error")
		}
	}

	ses.SetConfig(CProxy, nil)
	if u, err := url.Parse("http://" + ProxyAddress); err != nil {
		t.Error(err)
	} else {
		ses.SetConfig(CProxy, u)
	}

	resp, err = ses.Get("http://httpbin.org/get").Execute()
	if err != nil {
		t.Error(err)
	}

	ses.DelCookies(u, "eson")
	resp, err = ses.Get("http://httpbin.org/cookies").Execute()
	if err != nil {
		t.Error(err)
	}
	cookies := ses.GetCookies(u)
	if len(cookies) != 1 && cookies[0].String() != "Request=Cookiejar" {
		t.Error("cookies del get error please check it")
	}

	ses.ClearCookies()
	resp, err = ses.Get("http://httpbin.org/cookies").Execute()
	if err != nil {
		t.Error(err)
	}
	if gjson.Get(resp.Content(), "cookies").String() != "{}" {
		t.Error(resp.Content())
	}
}

func TestSession_SetQuery(t *testing.T) {
	ses := NewSession()
	ses.SetQuery(url.Values{"query": []string{"a", "b"}})
	resp, err := ses.Get("http://httpbin.org/get").Execute()
	if err != nil {
		t.Error(err)
	}
	query := gjson.Get(resp.Content(), "args.query").Array()
	for _, q := range query {
		if !(q.String() == "a" || q.String() == "b") {
			t.Error("query error, ", resp.Content())
		}
	}
}

func TestSession_SetHeader(t *testing.T) {
	ses := NewSession()
	var header http.Header
	header = make(http.Header)
	header["xx-xx"] = []string{"Header"}
	ses.SetHeader(header)

	resp, err := ses.Get("http://httpbin.org/headers").Execute()
	if err != nil {
		t.Error(err)
	}

	if gjson.Get(resp.Content(), "headers.Xx-Xx").String() != "Header" {
		t.Error("Xx-Xx is not exists", resp.Content())
	}

	if ses.GetHeader()["xx-xx"][0] != "Header" {
		t.Error("header error")
	}
}

func TestSession_SetBasicAuth(t *testing.T) {
	ses := NewSession()
	ses.SetConfig(CBasicAuth, &BasicAuth{User: "eson", Password: "123456"})
	resp, err := ses.Get("http://httpbin.org/basic-auth/eson/123456").Execute()
	if err != nil {
		t.Error(err)
	}
	if resp.GetSrcResponse().StatusCode != 200 {
		t.Error("code != 200, code = ", resp.GetStatue())
	}

	ses.SetConfig(CBasicAuth, BasicAuth{User: "eson", Password: "12345"})
	resp, err = ses.Get("http://httpbin.org/basic-auth/eson/123456").Execute()
	if err != nil {
		t.Error(err)
	}

	if resp.GetSrcResponse().StatusCode != 401 {
		t.Error("code != 401, code = ", resp.GetStatue())
	}

	resp, err = ses.Get("http://httpbin.org/basic-auth/eson/123456").Execute()
	if err != nil {
		t.Error(err)
	}

	if resp.GetSrcResponse().StatusCode != 401 {
		t.Error("code != 401, code = ", resp.GetStatue())
	}

	ses.SetConfig(CBasicAuth, []string{"son", "123456"})
	resp, err = ses.Get("http://httpbin.org/basic-auth/eson/123456").Execute()
	if err != nil {
		t.Error(err)
	}
	if resp.GetSrcResponse().StatusCode != 401 {
		t.Error("code != 401, code = ", resp.GetStatue())
	}

	ses.SetConfig(CBasicAuth, nil)
	resp, err = ses.Get("http://httpbin.org/basic-auth/eson/123456").Execute()
	if err != nil {
		t.Error(err)
	}
	if resp.GetSrcResponse().StatusCode != 401 {
		t.Error("code != 401, code = ", resp.GetStatue())
	}
}