package test

import (
	"net/http"
	"testing"

	"github.com/lucasvmiguel/integration"
	"github.com/lucasvmiguel/integration/call"
	"github.com/lucasvmiguel/integration/expect"
)

func init() {
	http.HandleFunc("/ping", func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte("pong"))
	})

	go http.ListenAndServe(":8080", nil)
}

func TestPingEndpoint(t *testing.T) {
	err := integration.Test(&integration.HTTPTestCase{
		Description: "Testing ping endpoint",
		Request: call.Request{
			URL:    "http://localhost:8080/ping",
			Method: http.MethodGet,
		},
		Response: expect.Response{
			StatusCode: http.StatusOK,
			Body:       "pong",
		},
	})

	if err != nil {
		t.Fatal(err)
	}
}

integration.HTTPTestCase{
	Description: "Example",
	Request: call.Request{
		URL:    "http://localhost:8080/posts/1",
	},
	Response: expect.Response{
		StatusCode: http.StatusOK,
		Body: `{
			"title": "some title",
			"code": "<<PRESENCE>>"
		}`,
	},
	Assertions: []assertion.Assertion{
		&assertion.HTTP{
			Request: expect.Request{
				URL:    "https://jsonplaceholder.typicode.com/posts/1",
				Method: http.MethodGet,
			},
		},
	},
}

integration.GRPCTestCase{
	Description: "Example",
	Call: call.Call{
		ServiceClient: c,
		Function:      "SayHello",
		Message: &chat.Message{
			Id:      1,
			Body:    "Hello From Client!",
			Comment: "Whatever",
		},
	},
	Output: expect.Output{
		Message: &chat.Message{
			Id:      1,
			Body:    "Hello From the Server!",
			Comment: "<<PRESENCE>>",
		},
	},
	Assertions: []assertion.Assertion{
		&assertion.HTTP{
			Request: expect.Request{
				URL:    "https://jsonplaceholder.typicode.com/posts/1",
			},
		},
	},
}

integration.WebsocketTestCase{
	Description: "Example",
	Call: call.Websocket{
		URL:    "localhost:8080",
		Path:   "/websocket",
		Message: `{
			"title": "some title",
			"userId": 1
		}`,
	},
	Receive: &expect.Message{
		Content: `{
			"title": "some title",
			"description": "<<PRESENCE>>",
			"userId": 1,
			"comments": [
				{ "id": 1, "text": "foo" },
				{ "id": 2, "text": "bar" }
			]
		}`,
	},
	Assertions: []assertion.Assertion{
		&assertion.HTTP{
			Request: expect.Request{
				URL:    "https://jsonplaceholder.typicode.com/posts/1",
			},
		},
	},
}

initialTestCase := &integration.WebsocketTestCase{
	Description: "First test case with a new connection"
	Call: call.Websocket{
		URL:     "localhost:8080",
		Message:    `ping 1`,
	},
}

err := integration.Test(initialTestCase)
if err != nil {
	t.Fatal(err)
}

// Get the connection established in the first test case
conn := initialTestCase.Connection()

// Use the connection in a second test case
err = integration.Test(&integration.WebsocketTestCase{
	Description: "Second test case with the same connection",
	Call: call.Websocket{
		Connection: conn,
		Message:    `ping 2`,
	},
})
if err != nil {
	t.Fatal(err)
}

integration.HTTPTestCase{
	Description: "Example",
	Request: call.Request{
		URL:    "http://localhost:8080/test",
	},
	Response: expect.Response{
		StatusCode: http.StatusOK,
	},
	Assertions: []assertion.Assertion{
		&assertion.SQL{
			DB: db,
			Query: call.Query{
				Statement: `
				SELECT id, title, description, category_id FROM products
				`,
			},
			Result: expect.Result{
				{"id": 1, "title": "foo1", "description": "bar1", "category_id": 1},
				{"id": 2, "title": "foo2", "description": "bar2", "category_id": 1},
			},
		},
	},
}

integration.HTTPTestCase{
	Description: "Example",
	Request: call.Request{
		URL:    "http://localhost:8080/test",
	},
	Response: expect.Response{
		StatusCode: http.StatusOK,
	},
	Assertions: []assertion.Assertion{
		&assertion.HTTP{
			Request: expect.Request{
				URL:    "https://jsonplaceholder.typicode.com/posts",
				Method: http.MethodPost,
				Body: `{
					"title": "foo",
					"body": "bar",
					"userId": "<<PRESENCE>>"
				}`,
			},
			Response: mock.Response{
				StatusCode: http.StatusOK,
				Body: `{
					"id": 1,
					"title": "foo bar"
				}`,
			},
		},
	},
}