package api

import (
	"bytes"
	"encoding/json"
	"github.com/gin-gonic/gin"
	_ "github.com/jinzhu/gorm/dialects/sqlite"
	. "github.com/smartystreets/goconvey/convey"
	"github.com/stretchr/testify/assert"
	"mastersapi/database"
	"mastersapi/middleware"
	"mastersapi/models"
	"mastersapi/test"
	"net/http"
	"net/http/httptest"
	"os"
	"testing"
)


func TestMain(m *testing.M) {
	//SetupTests()
	gin.SetMode(gin.ReleaseMode)
	retCode := m.Run()
	os.Exit(retCode)
}

func TestRegister(t *testing.T) {
	test.InitDb("register")
	defer test.CloseDb("register")

	email := "chirkin.ivan@gmail.com"
	pass := "123456"

	Convey("Check POST /register method", t, func() {
		r := Setup(middleware.Auth())
		w := httptest.NewRecorder()

		models.PassCost = 1

		data, _ := json.Marshal(RegisterForm{
			Email:    email,
			Password: pass,
		})
		req, _ := http.NewRequest("POST", "/register", bytes.NewBuffer(data))
		r.ServeHTTP(w, req)

		type RegisterResponse struct {
			Success bool
			Code    int
			Data    struct {
				Email string
			}
		}

		var response RegisterResponse

		err := json.Unmarshal([]byte(w.Body.String()), &response)
		So(err, ShouldBeNil)

		Convey("Good request", func() {
			Println(w.Body.String())

			So(w.Code, ShouldEqual, http.StatusOK)
			So(response.Code, ShouldEqual, http.StatusOK)
			So(response.Data.Email, ShouldEqual, email)

			account := models.Account{}
			count := database.Get().First(&account, 1).RowsAffected
			So(count, ShouldEqual, int64(1))
		})

		Convey("Email uniq check", func() {
			Println(w.Body.String())
			So(w.Code, ShouldEqual, http.StatusBadRequest)
			So(response.Code, ShouldEqual, http.StatusBadRequest)

			Reset(func() {
				email = ""
				pass = "12345"
			})
		})

		Convey("Empty email", func() {
			Println(w.Body.String())
			So(w.Code, ShouldEqual, http.StatusBadRequest)
			So(response.Code, ShouldEqual, http.StatusBadRequest)

			Reset(func() {
				email = "chirkin.ivan@gmail.com"
				pass = ""
			})
		})

		Convey("Empty pass", func() {
			Println(w.Body.String())
			So(w.Code, ShouldEqual, http.StatusBadRequest)
			So(response.Code, ShouldEqual, http.StatusBadRequest)

			Reset(func() {
				email = "badEmail"
				pass = "12345"
			})
		})

		Convey("Bad email", func() {
			Println(w.Body.String())
			So(w.Code, ShouldEqual, http.StatusBadRequest)
			So(response.Code, ShouldEqual, http.StatusBadRequest)

			Reset(func() {
				email = "mail@test.ru"
				pass = "12345"
				test.CloseDb("register")
				test.InitDbWithoutMigrate("register")
			})
		})

		Convey("Without table InternalError", func() {
			Println(w.Body.String())
			So(w.Code, ShouldEqual, http.StatusInternalServerError)
			So(response.Code, ShouldEqual, http.StatusInternalServerError)
		})
	})
}


func TestLogin(t *testing.T) {
	test.InitDb("login")
	defer test.CloseDb("login")

	email := "test@mail.ru"
	account := models.Account{
		Email: email,
		LoginErrors: 3,
	}

	password := "123"
	account.SetPassword(password)

	err := database.Get().Create(&account).Error
	assert.Nil(t, err)

	r := Setup(middleware.Auth())

	Convey("Test POST /login method", t, func() {

		w := httptest.NewRecorder()
		data, _ := json.Marshal(LoginForm{
			Email:    email,
			Password: password,
		})
		req, _ := http.NewRequest("POST", "/login", bytes.NewBuffer(data))
		r.ServeHTTP(w, req)

		Convey("Good login", func() {
			So(w.Code, ShouldEqual, http.StatusOK)

			type GoodLoginResponse struct {
				Success bool
				Code    int
				Data    struct {
					Key string
				}
			}

			var response GoodLoginResponse

			err := json.Unmarshal([]byte(w.Body.String()), &response)
			So(err, ShouldBeNil)

			session := models.AccountSession{}

			notFound := database.Get().First(&session, 1).RecordNotFound()
			So(notFound, ShouldBeFalse)
			So(response.Data.Key, ShouldEqual, session.Key)

			err = database.Get().First(&account, 1).Error
			So(err,ShouldBeNil)
			So(account.LoginErrors, ShouldEqual, 0)

			Reset(func() {
				account.LoginErrors = 6
				err = database.Get().Save(&account).Error
				So(err, ShouldBeNil)

				password = "wrong_pass"
			})
		})

		Convey("Bad login", func() {
			So(w.Code, ShouldEqual, http.StatusForbidden)

			type BadLoginResponse struct {
				Success bool
				Code    int
			}

			var response BadLoginResponse

			err = json.Unmarshal([]byte(w.Body.String()), &response)
			So(err, ShouldBeNil)

			So(response.Code, ShouldEqual, http.StatusForbidden)

			var account models.Account
			err = database.Get().First(&account, 1).Error
			So(err, ShouldBeNil)

			So(account.LoginErrors, ShouldEqual, 7)

			Reset(func() {
				password = ""
			})
		})

		Convey("Without pass", func() {
			So(w.Code, ShouldEqual, http.StatusBadRequest)
			Reset(func() {
				email = ""
				password = "123"
			})
		})

		Convey("Without email", func() {
			So(w.Code, ShouldEqual, http.StatusBadRequest)
			Reset(func() {
				email = "badEmail"
				password = "123"
			})
		})

		Convey("With bad email", func() {
			So(w.Code, ShouldEqual, http.StatusBadRequest)
			Reset(func() {
				email = "test@mail.ru"
				password = "123"

				err := database.Get().DropTable("accounts_sessions").Error
				So(err, ShouldBeNil)
			})
		})

		Convey("Without table sessions", func() {
			Println(w.Body.String())
			So(w.Code, ShouldEqual, http.StatusInternalServerError)
			Reset(func() {
				email = "test@mail.ru"
				password = "123"
				err := database.Get().DropTable("accounts").Error
				So(err, ShouldBeNil)
			})
		})

		Convey("Without table account", func() {
			Println(w.Body.String())
			So(w.Code, ShouldEqual, http.StatusInternalServerError)
		})
	})

}

func TestLogout(t *testing.T) {
	test.InitDb("logout")
	defer test.CloseDb("logout")

	r := Setup(middleware.Auth())

	token := test.Token
	test.CreateSession()

	Convey("Test GET /logout method", t, func() {
		w := httptest.NewRecorder()
		req, _ := http.NewRequest("GET", "/logout", nil)
		req.Header.Set("X-Token", token)
		r.ServeHTTP(w, req)

		Convey("Good request", func() {
			So(w.Code, ShouldEqual, http.StatusOK)


			var response SuccessResponse

			err := json.Unmarshal([]byte(w.Body.String()), &response)
			So(err, ShouldBeNil)

			So(response.Code, ShouldEqual, http.StatusOK)

			Reset(func() {
				token = "bad-token"
			})
		})

		Convey("Bad request", func() {
			So(w.Code, ShouldEqual, http.StatusForbidden)

			var response FailureResponse

			err := json.Unmarshal([]byte(w.Body.String()), &response)
			So(err, ShouldBeNil)

			So(response.Code, ShouldEqual, http.StatusForbidden)

		})
	})
}