package test

import (
	"context"
	"fmt"
	"io"
	"net/http"
	"net/http/httptest"
	"strings"
	"testing"
	"time"

	"queryorchestration/internal/serviceconfig"
	"queryorchestration/internal/serviceconfig/aws"
	"queryorchestration/internal/serviceconfig/objectstore"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestCreateAPINetwork(t *testing.T) {
	if testing.Short() {
		t.Skip("Skipping long test in short mode")
	}
	ctx := context.Background()

	cfg := &FullDepsConfig{}
	SetCfgProvider(t, cfg)

	conn, cleanup := CreateAPINetwork(t, ctx, cfg, &ServiceNetworkConfig{
		API: QueryAPI,
	})

	assert.NotNil(t, conn)
	assert.NotNil(t, cleanup)

	cleanup()
}

func TestCreateBaseConfig(t *testing.T) {
	cfg := &serviceconfig.BaseConfig{}
	SetCfgProvider(t, cfg)
	assert.Equal(t, "test", cfg.AWSKeyID)
	assert.Equal(t, "test", cfg.AWSSecretKey)
	assert.Equal(t, "us-east-1", cfg.AWSRegion)
	assert.Equal(t, aws.Profile(""), cfg.AWSProfile)
	assert.Equal(t, "invalid_user", cfg.DBUser)
	assert.Equal(t, "invalid_pass", cfg.DBSecret)
	assert.Equal(t, "invalid_host", cfg.DBHost)
	assert.Equal(t, 5432, cfg.DBPort)
	assert.Equal(t, "invalid_name", cfg.DBName)
	assert.True(t, cfg.DBNoSSL)
}

type FullDepsConfig struct {
	aws.AWSConfig
	serviceconfig.BaseConfig
	objectstore.ObjectStoreConfig
}

func TestCreateFullDependencies(t *testing.T) {
	if testing.Short() {
		t.Skip("Skipping long test in short mode")
	}
	ctx := context.Background()
	cfg := &FullDepsConfig{}
	SetCfgProvider(t, cfg)

	conn, cleanup := CreateFullDependencies(t, ctx, cfg)

	assert.NotNil(t, conn)
	assert.NotNil(t, cleanup)

	cleanup()
}

func TestCreateNetwork(t *testing.T) {
	if testing.Short() {
		t.Skip("Skipping long test in short mode")
	}
	ctx := context.Background()
	cfg := &FullDepsConfig{}
	SetCfgProvider(t, cfg)

	conn, cleanup := CreateFullNetwork(t, ctx, cfg)

	assert.NotNil(t, conn)
	assert.NotNil(t, cleanup)

	cleanup()
}

func TestCreateMockServer(t *testing.T) {
	if testing.Short() {
		t.Skip("Skipping long test in short mode")
	}
	ctx := context.Background()

	server, cleanup := CreateMockServer(t, ctx, MockServerConfig{
		Network: "hello",
	})

	assert.NotNil(t, server)
	assert.NotNil(t, cleanup)

	cleanup()
}

func TestCreateMockExpectation(t *testing.T) {
	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
	}))
	defer ts.Close()

	server := MockServer{
		Client:   ts.Client(),
		External: Address(ts.URL),
	}
	expectation := MockExpectation{}
	CreateMockExpectation(t, server, expectation)
}

func TestWaitForMockEndpoint(t *testing.T) {
	if testing.Short() {
		t.Skip("Skipping long test in short mode")
	}
	ctx := context.Background()

	server, cleanup := CreateMockServer(t, ctx, MockServerConfig{
		Network: "hello",
	})
	defer cleanup()

	body := strings.NewReader(`{"team":"hello"}`)
	req, err := http.NewRequest("GET", string(server.External), body)
	require.NoError(t, err)
	req.Header.Add("Hidden", "here")

	expectation := MockExpectation{
		Request: MockRequest{
			Method:  "GET",
			Path:    "/",
			Headers: MockHeaders{},
			Query:   MockQueries{},
			Body:    `{"team":"hello"}`,
		},
		Response: MockResponse{
			Code:    200,
			Headers: MockHeaders{},
			Body:    "byebye",
		},
	}

	CreateMockExpectation(t, server, expectation)

	resp, err := server.Client.Do(req)
	require.NoError(t, err)

	respStr, err := io.ReadAll(resp.Body)
	require.NoError(t, err)
	assert.Equal(t, []byte("byebye"), respStr)

	request := WaitForMockEndpoint(t, server, expectation.Request)
	assert.Equal(t, []string([]string{"here"}), request.Headers["Hidden"])
}

func TestWaitForTextractMockEndpoint(t *testing.T) {
	if testing.Short() {
		t.Skip("Skipping long test in short mode")
	}
	ctx := context.Background()
	cfg := &FullDepsConfig{}
	SetCfgProvider(t, cfg)

	deps, cleanup := CreateFullDependencies(t, ctx, cfg)
	defer cleanup()

	clientId := "CLIENTID"
	importKey := objectstore.BucketKey{
		ClientID:  clientId,
		CreatedAt: time.Now().UTC(),
		Location:  objectstore.Import,
	}
	outputKey := objectstore.BucketKey{
		ClientID:  clientId,
		CreatedAt: time.Now().UTC(),
		Location:  objectstore.TextTextract,
	}

	e := CreateStartDocTextDetectionExpectation(t, deps.MockServer, StartDocTextDetectionExpectationParams{
		Bucket: deps.BucketName,
		Key:    importKey,
		JobID:  "hi",
	})

	body := strings.NewReader(fmt.Sprintf(`{"DocumentLocation":{"S3Object":{"Bucket":"%s","Name":"%s"}},"OutputConfig":{"S3Bucket":"%s","S3Prefix":"%s"}}`, deps.BucketName, importKey.String(), deps.BucketName, outputKey.String()))
	req, err := http.NewRequest("POST", string(deps.MockServer.External), body)
	require.NoError(t, err)
	req.Header.Add("X-Amz-Target", "Textract.StartDocumentTextDetection")
	_, err = deps.MockServer.Client.Do(req)
	require.NoError(t, err)

	WaitForMockTextractOutput(t, ctx, cfg, deps.MockServer, TextractOutputParams{
		Request: e.Request,
		File:    strings.NewReader("hello"),
	})
}