package v1

import (
	"bytes"
	"encoding/json"
	"mime/multipart"
	"net/http"
	"net/http/httptest"
	"os"
	"path/filepath"
	"testing"

	"github.com/gin-gonic/gin"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"gorm.io/driver/sqlite"
	"gorm.io/gorm"
	"gorm.io/gorm/logger"

	"github.com/gochat/gochat/internal/config"
	"github.com/gochat/gochat/internal/model"
	"github.com/gochat/gochat/internal/repository"
	"github.com/gochat/gochat/internal/service"
)

// mockUploadService implements a mock for UploadService handler tests.
// We can't easily mock UploadService because it's a concrete type, not an interface.
// Instead, we test the handler layer by checking HTTP status codes and response shapes.

func setupUploadHandlerRouter(h *UploadHandler) *gin.Engine {
	gin.SetMode(gin.TestMode)
	r := gin.New()

	// Account upload route
	api := r.Group("/api/v1/accounts/:account_id")
	api.POST("/upload", h.Upload)

	// Account direct upload route
	api.POST("/direct_uploads", h.AccountDirectUpload)

	// Widget direct upload route
	widget := r.Group("/widget")
	widget.POST("/direct_uploads", h.DirectUpload)
	widget.PUT("/direct_uploads/:upload_uuid", h.CompleteWidgetDirectUpload)

	chatwootWidget := r.Group("/api/v1/widget")
	chatwootWidget.POST("/direct_uploads", h.DirectUpload)
	chatwootWidget.PUT("/direct_uploads/:upload_uuid", h.CompleteWidgetDirectUpload)

	return r
}

// makeMultipartUploadBody creates a multipart form body with a file field.
func makeMultipartUploadBody(filename string, content []byte) (body *bytes.Buffer, contentType string, err error) {
	body = &bytes.Buffer{}
	writer := multipart.NewWriter(body)
	part, err := writer.CreateFormFile("file", filename)
	if err != nil {
		return nil, "", err
	}
	part.Write(content)
	writer.Close()
	return body, writer.FormDataContentType(), nil
}

func TestUploadHandler_Upload_NoFile(t *testing.T) {
	// Create handler with nil service — we only test validation before service call
	h := &UploadHandler{svc: nil}
	r := setupUploadHandlerRouter(h)

	// Send request without file (no multipart body)
	req, _ := http.NewRequest("POST", "/api/v1/accounts/1/upload", nil)
	req.Header.Set("Content-Type", "application/json")
	w := httptest.NewRecorder()

	// Set account_id in context (simulating middleware)
	r.ServeHTTP(w, req)

	assert.Equal(t, http.StatusBadRequest, w.Code)
}

func TestUploadHandler_DirectUpload_NoFile(t *testing.T) {
	// Create handler with nil service — we only test validation before service call
	h := &UploadHandler{svc: nil}
	r := setupUploadHandlerRouter(h)

	req, _ := http.NewRequest("POST", "/widget/direct_uploads", nil)
	req.Header.Set("Content-Type", "multipart/form-data")
	w := httptest.NewRecorder()

	r.ServeHTTP(w, req)

	assert.Equal(t, http.StatusBadRequest, w.Code)
}

func TestUploadHandler_WidgetActiveStorageDirectUploadFlow(t *testing.T) {
	gin.SetMode(gin.TestMode)
	tmpDir := t.TempDir()
	db, err := gorm.Open(sqlite.Open("file::memory:"), &gorm.Config{Logger: logger.Default.LogMode(logger.Silent)})
	require.NoError(t, err)
	require.NoError(t, db.AutoMigrate(
		&model.Account{},
		&model.Inbox{},
		&model.Contact{},
		&model.ContactInbox{},
		&model.DirectUpload{},
	))

	account := &model.Account{Name: "Widget Upload Org", Status: "active"}
	require.NoError(t, db.Create(account).Error)
	channelConfig, err := json.Marshal(service.WebWidgetConfig{WebsiteToken: "upload_ws_token"})
	require.NoError(t, err)
	inbox := &model.Inbox{AccountID: account.ID, Name: "Upload Widget", ChannelType: "web_widget", Enabled: true, ChannelConfig: string(channelConfig)}
	require.NoError(t, db.Create(inbox).Error)
	contact := &model.Contact{AccountID: account.ID, Name: "Uploader"}
	require.NoError(t, db.Create(contact).Error)
	contactInbox := &model.ContactInbox{ContactID: contact.ID, InboxID: inbox.ID, PubsubToken: "upload_pubsub_token"}
	require.NoError(t, db.Create(contactInbox).Error)

	uploadSvc := service.NewUploadService(repository.NewDirectUploadRepo(db), &config.Config{
		Storage: config.StorageConfig{LocalPath: tmpDir, MaxFileSize: 50 << 20},
	}).WithWidgetAuth(repository.NewInboxRepo(db), repository.NewContactInboxRepo(db))
	router := setupUploadHandlerRouter(NewUploadHandler(uploadSvc))

	metadataBody, err := json.Marshal(map[string]any{
		"blob": map[string]any{
			"filename":     "visitor.png",
			"byte_size":    11,
			"checksum":     "checksum-token",
			"content_type": "image/png",
			"metadata":     map[string]any{"identified": true},
		},
	})
	require.NoError(t, err)

	wCreate := httptest.NewRecorder()
	reqCreate, _ := http.NewRequest("POST", "/api/v1/widget/direct_uploads?website_token=upload_ws_token", bytes.NewReader(metadataBody))
	reqCreate.Header.Set("Content-Type", "application/json")
	reqCreate.Header.Set("X-Auth-Token", "upload_pubsub_token")
	router.ServeHTTP(wCreate, reqCreate)
	require.Equal(t, http.StatusOK, wCreate.Code)

	var createResp map[string]any
	require.NoError(t, json.Unmarshal(wCreate.Body.Bytes(), &createResp))
	signedID, ok := createResp["signed_id"].(string)
	require.True(t, ok)
	require.NotEmpty(t, signedID)
	assert.Equal(t, "visitor.png", createResp["filename"])
	directUpload := createResp["direct_upload"].(map[string]any)
	assert.Equal(t, "/api/v1/widget/direct_uploads/"+signedID, directUpload["url"])

	wPut := httptest.NewRecorder()
	reqPut, _ := http.NewRequest("PUT", directUpload["url"].(string), bytes.NewReader([]byte("hello image")))
	reqPut.Header.Set("Content-Type", "image/png")
	router.ServeHTTP(wPut, reqPut)
	require.Equal(t, http.StatusOK, wPut.Code)

	var upload model.DirectUpload
	require.NoError(t, db.Where("upload_uuid = ?", signedID).First(&upload).Error)
	assert.Equal(t, account.ID, upload.AccountID)
	storedBytes, err := os.ReadFile(filepath.Join(tmpDir, "widget_direct", signedID+".png"))
	require.NoError(t, err)
	assert.Equal(t, []byte("hello image"), storedBytes)
}

func TestUploadHandler_AccountDirectUpload_NoFile(t *testing.T) {
	// Create handler with nil service — we only test validation before service call
	h := &UploadHandler{svc: nil}
	r := setupUploadHandlerRouter(h)

	// Send request without file (no multipart body)
	req, _ := http.NewRequest("POST", "/api/v1/accounts/1/direct_uploads", nil)
	req.Header.Set("Content-Type", "application/json")
	w := httptest.NewRecorder()

	r.ServeHTTP(w, req)

	assert.Equal(t, http.StatusBadRequest, w.Code)
}

func TestUploadHandler_AccountDirectUpload_NoAccountID(t *testing.T) {
	// Create handler with nil service — we only test validation before service call
	h := &UploadHandler{svc: nil}
	r := setupUploadHandlerRouter(h)

	// Use a non-numeric account_id so getAccountID returns 0
	req, _ := http.NewRequest("POST", "/api/v1/accounts/abc/direct_uploads", nil)
	req.Header.Set("Content-Type", "application/json")
	w := httptest.NewRecorder()

	r.ServeHTTP(w, req)

	assert.Equal(t, http.StatusBadRequest, w.Code)
}

func TestUploadHandler_AccountDirectUpload_WithFileButNilService(t *testing.T) {
	// Create handler with nil service — request passes validation but service call panics.
	// This test verifies that account_id extraction + file extraction work correctly
	// before the service call. In real integration tests, we use a real service.
	h := &UploadHandler{svc: nil}
	r := setupUploadHandlerRouter(h)

	body, contentType, err := makeMultipartUploadBody("test.png", []byte("fake png"))
	assert.NoError(t, err)

	req, _ := http.NewRequest("POST", "/api/v1/accounts/1/direct_uploads", body)
	req.Header.Set("Content-Type", contentType)
	w := httptest.NewRecorder()

	// This will panic because svc is nil, but it proves validation passes.
	// We recover the panic and verify the request got past the validation checks.
	defer func() {
		if r := recover(); r != nil {
			// Expected: nil service causes panic after validation passes
			t.Logf("Recovered expected panic from nil service: %v", r)
		}
	}()
	r.ServeHTTP(w, req)
}

func TestUploadHandler_ResponseStructure(t *testing.T) {
	// Verify UploadResponse DTO structure matches expected JSON keys
	resp := service.UploadResponse{
		UploadID:     1,
		UploadUUID:   "abc-123",
		OriginalName: "test.png",
		FileType:     "image",
		MimeType:     "image/png",
		FileSize:     1024,
		FileURL:      "/uploads/account/1/test.png",
		ThumbURL:     "/uploads/account/1/test.png",
		Status:       "pending",
	}

	data, err := json.Marshal(resp)
	assert.NoError(t, err)

	var parsed map[string]interface{}
	assert.NoError(t, json.Unmarshal(data, &parsed))

	assert.Equal(t, float64(1), parsed["upload_id"])
	assert.Equal(t, "abc-123", parsed["upload_uuid"])
	assert.Equal(t, "test.png", parsed["original_name"])
	assert.Equal(t, "image", parsed["file_type"])
	assert.Equal(t, "image/png", parsed["mime_type"])
	assert.Equal(t, float64(1024), parsed["file_size"])
	assert.Equal(t, "/uploads/account/1/test.png", parsed["file_url"])
	assert.Equal(t, "/uploads/account/1/test.png", parsed["thumb_url"])
	assert.Equal(t, "pending", parsed["status"])
}