package routes_test

import (
	"bytes"
	"encoding/json"
	"gitea.deepak.science/deepak/gogmagog/models"
	"gitea.deepak.science/deepak/gogmagog/routes"
	"github.com/stretchr/testify/assert"
	"net/http"
	"net/http/httptest"
	"strings"
	"testing"
	"time"
)

func TestCreatePlanRoute(t *testing.T) {
	// set up
	assert := assert.New(t)
	planDate, _ := time.Parse("2006-01-02", "2021-01-01")
	p := &models.Plan{PlanID: 6, PlanDate: &planDate}
	m := getModel([]*models.Plan{p}, []*models.Action{})
	router := routes.NewRouter(m)
	data, _ := json.Marshal(p)
	req, _ := http.NewRequest("POST", "/plans", bytes.NewBuffer(data))
	req.Header.Set("Content-Type", "application/json")

	rr := httptest.NewRecorder()
	// function under test
	router.ServeHTTP(rr, req)

	// check results
	status := rr.Code
	assert.Equal(http.StatusCreated, status)
	// We pass in the date as a time.time so it makes sense that it comes back with a midnight timestamp.
	expected := `{
		"created_plan": {
			"plan_id": 6,
			"plan_date": "2021-01-01T00:00:00Z"
		},
		"id": 0
	}`
	assert.JSONEq(expected, rr.Body.String())
	contentType := rr.Header().Get("Content-Type")
	assert.Equal("application/json", contentType)
}

func TestPureJSON(t *testing.T) {
	// set up
	assert := assert.New(t)
	planDate, _ := time.Parse("2006-01-02", "2021-01-01")
	p := &models.Plan{PlanID: 6, PlanDate: &planDate}
	m := getModel([]*models.Plan{p}, []*models.Action{})
	router := routes.NewRouter(m)
	data := []byte(`{
			"plan_date": "2021-01-01T00:00:00Z",
			"plan_id": 5
		}`)
	req, _ := http.NewRequest("POST", "/plans", bytes.NewBuffer(data))
	req.Header.Set("Content-Type", "application/json")

	rr := httptest.NewRecorder()
	// function under test
	router.ServeHTTP(rr, req)

	// check results
	status := rr.Code
	assert.Equal(http.StatusCreated, status)
	// We pass in the date as a time.time so it makes sense that it comes back with a midnight timestamp.
	expected := `{
		"created_plan": {
			"plan_id": 6,
			"plan_date": "2021-01-01T00:00:00Z"
		},
		"id": 0
	}`
	assert.JSONEq(expected, rr.Body.String())
	contentType := rr.Header().Get("Content-Type")
	assert.Equal("application/json", contentType)
}

func TestExtraFieldJSON(t *testing.T) {
	// set up
	assert := assert.New(t)
	planDate, _ := time.Parse("2006-01-02", "2021-01-01")
	p := &models.Plan{PlanID: 6, PlanDate: &planDate}
	m := getModel([]*models.Plan{p}, []*models.Action{})
	router := routes.NewRouter(m)
	data := []byte(`{
			"plan_date": "2021-01-01T00:00:00Z",
			"plan_id": 5,
			"plan_sabotage": "omg"
		}`)
	req, _ := http.NewRequest("POST", "/plans", bytes.NewBuffer(data))
	req.Header.Set("Content-Type", "application/json")

	rr := httptest.NewRecorder()
	// function under test
	router.ServeHTTP(rr, req)

	// check results
	status := rr.Code
	assert.Equal(http.StatusBadRequest, status)
	// We pass in the date as a time.time so it makes sense that it comes back with a midnight timestamp.
	expected := `Bad Request`
	assert.Equal(expected, strings.TrimSpace(rr.Body.String()))
}
func TestEmptyBody(t *testing.T) {
	// set up
	assert := assert.New(t)
	planDate, _ := time.Parse("2006-01-02", "2021-01-01")
	p := &models.Plan{PlanID: 6, PlanDate: &planDate}
	m := getModel([]*models.Plan{p}, []*models.Action{})
	router := routes.NewRouter(m)
	data := []byte(``)
	req, _ := http.NewRequest("POST", "/plans", bytes.NewBuffer(data))
	req.Header.Set("Content-Type", "application/json")

	rr := httptest.NewRecorder()
	// function under test
	router.ServeHTTP(rr, req)

	// check results
	status := rr.Code
	assert.Equal(http.StatusBadRequest, status)
	// We pass in the date as a time.time so it makes sense that it comes back with a midnight timestamp.
	expected := `Bad Request`
	assert.Equal(expected, strings.TrimSpace(rr.Body.String()))
}

func TestTwoBody(t *testing.T) {
	// set up
	assert := assert.New(t)
	planDate, _ := time.Parse("2006-01-02", "2021-01-01")
	p := &models.Plan{PlanID: 6, PlanDate: &planDate}
	m := getModel([]*models.Plan{p}, []*models.Action{})
	router := routes.NewRouter(m)
	data := []byte(`{
			"plan_date": "2021-01-01T00:00:00Z",
			"plan_id": 5
		}, {
				"plan_date": "2021-01-01T00:00:00Z",
				"plan_id": 6
			}`)
	req, _ := http.NewRequest("POST", "/plans", bytes.NewBuffer(data))
	req.Header.Set("Content-Type", "application/json")

	rr := httptest.NewRecorder()
	// function under test
	router.ServeHTTP(rr, req)

	// check results
	status := rr.Code
	assert.Equal(http.StatusBadRequest, status)
	// We pass in the date as a time.time so it makes sense that it comes back with a midnight timestamp.
	expected := `Bad Request`
	assert.Equal(expected, strings.TrimSpace(rr.Body.String()))
}


func TestErrorCreatePlan(t *testing.T) {
	// set up
	assert := assert.New(t)

	m := getErrorModel("Model always errors")

	router := routes.NewRouter(m)
	planDate, _ := time.Parse("2006-01-02", "2021-01-01")
	p := &models.Plan{PlanID: 6, PlanDate: &planDate}
	data, _ := json.Marshal(p)
	req, _ := http.NewRequest("POST", "/plans", bytes.NewBuffer(data))
	req.Header.Set("Content-Type", "application/json")

	rr := httptest.NewRecorder()

	// function under test
	router.ServeHTTP(rr, req)

	// check results
	status := rr.Code
	assert.Equal(http.StatusInternalServerError, status)
	// We pass in the date as a time.time so it makes sense that it comes back with a midnight timestamp.
	expected := `Internal Server Error`
	assert.Equal(expected, strings.TrimSpace(rr.Body.String()))
}

func TestErrorOnRetrieveCreatePlan(t *testing.T) {
	// set up
	assert := assert.New(t)

	m := getErrorOnGetModel("Model always errors")

	router := routes.NewRouter(m)
	planDate, _ := time.Parse("2006-01-02", "2021-01-01")
	p := &models.Plan{PlanID: 6, PlanDate: &planDate}
	data, _ := json.Marshal(p)
	req, _ := http.NewRequest("POST", "/plans", bytes.NewBuffer(data))
	req.Header.Set("Content-Type", "application/json")
	rr := httptest.NewRecorder()

	// function under test
	router.ServeHTTP(rr, req)

	// check results
	status := rr.Code
	assert.Equal(http.StatusInternalServerError, status)
	// We pass in the date as a time.time so it makes sense that it comes back with a midnight timestamp.
	expected := `Internal Server Error`
	assert.Equal(expected, strings.TrimSpace(rr.Body.String()))
}

func TestErrorWriterCreatePlan(t *testing.T) {
	// set up
	assert := assert.New(t)
	planDate, _ := time.Parse("2006-01-02", "2021-01-01")

	p := &models.Plan{PlanID: 6, PlanDate: &planDate}
	m := getModel([]*models.Plan{p}, []*models.Action{})

	router := routes.NewRouter(m)
	data, _ := json.Marshal(p)
	req, _ := http.NewRequest("POST", "/plans", bytes.NewBuffer(data))
	req.Header.Set("Content-Type", "application/json")

	rr := NewBadWriter()

	// function under test
	router.ServeHTTP(rr, req)

	// check results
	status := rr.Code
	assert.Equal(http.StatusInternalServerError, status)

}