package test

import (
	"github.com/stretchr/testify/require"

	"bytes"
	"encoding/hex"
	"fmt"
	"io"
	"math/rand"
	"net/http"
	"net/http/httptest"
	"testing"

	"mstore/app/router"
	"mstore/app/server"
)

func TestFileLife(t *testing.T) {
	var tester FileTester
	tester.MakeServer(t)
	tester.TestServiceHello(t)
	tester.TestPutFile(t)
	tester.TestFileExists(t)
	tester.TestGetFile(t)
	tester.TestDeleteFile(t)
	tester.TestFileNotExists(t)
}

type FileTester struct {
	srv *server.Server
}

func (tester *FileTester) MakeServer(t *testing.T) {
	var err error

	fmt.Printf("=== MakeServer ===\n")

	srv, err := server.NewServer()
	require.NoError(t, err)

	err = srv.Configure()
	require.NoError(t, err)

	err = srv.Build()
	require.NoError(t, err)

	tester.srv = srv
}

func (tester *FileTester) TestPutFile(t *testing.T) {
	var err error

	fmt.Printf("=== PutFile ===\n")

	srv := tester.srv
	require.NotNil(t, srv)

	reqPath := `/v3/api/file/foo/bare`
	routePath := `/v3/api/file/{filepath}`

	rout := router.NewRouter()
	hand := srv.Handler()
	require.NotNil(t, hand)

	rout.Put(routePath, hand.PutFile)

	datasize := 16
	filedata := make([]byte, datasize)
	_, err = rand.Read(filedata)
	require.NoError(t, err)

	filedata = []byte(hex.EncodeToString(filedata))

	source := bytes.NewReader(filedata)

	request, err := http.NewRequest("PUT", reqPath, source)
	require.NoError(t, err)

	request.Header.Set("Content-Length", fmt.Sprintf("%d", datasize))
	request.Header.Set("Content-Type", "application/octet-stream")

	recorder := httptest.NewRecorder()
	rout.ServeHTTP(recorder, request)
	require.Equal(t, http.StatusOK, recorder.Code)

	fmt.Printf("Response code: %d\n", recorder.Code)

	bodyReader := recorder.Body
	bodyBytes, err := io.ReadAll(bodyReader)

	fmt.Printf("Response body: %s\n", string(bodyBytes))
}

func (tester *FileTester) TestFileExists(t *testing.T) {
	var err error
	fmt.Printf("=== FileExists ===\n")

	srv := tester.srv

	require.NotNil(t, srv)

	reqPath := `/v3/api/file/foo/bare`
	routePath := `/v3/api/file/{filepath}`

	rout := router.NewRouter()
	hand := srv.Handler()
	require.NotNil(t, hand)

	rout.Head(routePath, hand.FileExists)

	request, err := http.NewRequest("HEAD", reqPath, nil)
	require.NoError(t, err)

	recorder := httptest.NewRecorder()
	rout.ServeHTTP(recorder, request)
	require.Equal(t, http.StatusOK, recorder.Code)

	fmt.Printf("Response code: %d\n", recorder.Code)

	bodyReader := recorder.Body
	bodyBytes, err := io.ReadAll(bodyReader)

	fmt.Printf("Response body: %s\n", string(bodyBytes))
}

func (tester *FileTester) TestGetFile(t *testing.T) {
	var err error

	fmt.Printf("=== GetFile ===\n")

	srv := tester.srv
	require.NotNil(t, srv)

	reqPath := `/v3/api/file/foo/bare`
	routePath := `/v3/api/file/{filepath}`

	rout := router.NewRouter()
	hand := srv.Handler()
	require.NotNil(t, hand)

	rout.Get(routePath, hand.GetFile)

	request, err := http.NewRequest("GET", reqPath, nil)
	require.NoError(t, err)

	recorder := httptest.NewRecorder()
	rout.ServeHTTP(recorder, request)
	require.Equal(t, http.StatusOK, recorder.Code)

	fmt.Printf("Response code: %d\n", recorder.Code)

	bodyReader := recorder.Body
	bodyBytes, err := io.ReadAll(bodyReader)

	fmt.Printf("Response body: %s\n", string(bodyBytes))
}

func (tester *FileTester) TestDeleteFile(t *testing.T) {
	var err error

	fmt.Printf("=== DeleteFile ===\n")

	srv := tester.srv
	require.NotNil(t, srv)

	reqPath := `/v3/api/file/foo/bare`
	routePath := `/v3/api/file/{filepath}`

	rout := router.NewRouter()
	hand := srv.Handler()
	require.NotNil(t, hand)

	rout.Delete(routePath, hand.DeleteFile)

	request, err := http.NewRequest("DELETE", reqPath, nil)
	require.NoError(t, err)

	recorder := httptest.NewRecorder()
	rout.ServeHTTP(recorder, request)
	require.Equal(t, http.StatusOK, recorder.Code)

	fmt.Printf("Response code: %d\n", recorder.Code)

	bodyReader := recorder.Body
	bodyBytes, err := io.ReadAll(bodyReader)

	fmt.Printf("Response body: %s\n", string(bodyBytes))
}

func (tester *FileTester) TestFileNotExists(t *testing.T) {
	var err error
	fmt.Printf("=== FileNotExists ===\n")

	srv := tester.srv

	require.NotNil(t, srv)

	reqPath := `/v3/api/file/foo/bare`
	routePath := `/v3/api/file/{filepath}`

	rout := router.NewRouter()
	hand := srv.Handler()
	require.NotNil(t, hand)

	rout.Head(routePath, hand.FileExists)

	request, err := http.NewRequest("HEAD", reqPath, nil)
	require.NoError(t, err)

	recorder := httptest.NewRecorder()
	rout.ServeHTTP(recorder, request)
	require.Equal(t, http.StatusNotFound, recorder.Code)

	fmt.Printf("Response code: %d\n", recorder.Code)

	bodyReader := recorder.Body
	bodyBytes, err := io.ReadAll(bodyReader)

	fmt.Printf("Response body: %s\n", string(bodyBytes))
}

func (tester *FileTester) TestServiceHello(t *testing.T) {
	var err error

	fmt.Printf("=== ServiceHello ===\n")

	srv := tester.srv
	require.NotNil(t, srv)

	reqPath := "/service/hello"
	routePath := "/service/hello"

	rout := router.NewRouter()
	hand := srv.Handler()
	rout.Get(routePath, hand.SendHello)

	request, err := http.NewRequest("GET", reqPath, nil)
	require.NoError(t, err)

	recorder := httptest.NewRecorder()
	rout.ServeHTTP(recorder, request)
	require.Equal(t, http.StatusOK, recorder.Code)

	fmt.Printf("Response code: %d\n", recorder.Code)

	bodyReader := recorder.Body
	bodyBytes, err := io.ReadAll(bodyReader)

	fmt.Printf("Response body: %s\n", string(bodyBytes))
}