package tests

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

func TestIntegration(t *testing.T) {
	dir := t.TempDir()
	workspace := filepath.Join(dir, "workspace")
	os.MkdirAll(filepath.Join(workspace, "inbox"), 0755)
	os.MkdirAll(filepath.Join(workspace, "outbox"), 0755)
	os.MkdirAll(filepath.Join(workspace, ".ydropbox"), 0755)

	cfg := app.Config{
		Workspace: workspace,
		Token:     "test-token",
	}

	handler, store, err := app.NewHandler(cfg)
	if err != nil {
		t.Fatal(err)
	}
	defer store.Close()

	ts := httptest.NewServer(handler)
	defer ts.Close()

	client := ts.Client()

	loginBody := bytes.NewBufferString(`{"token":"test-token"}`)
	loginRes, err := client.Post(ts.URL+"/api/login", "application/json", loginBody)
	if err != nil || loginRes.StatusCode != 200 {
		t.Fatalf("Login failed: %v, status: %d", err, loginRes.StatusCode)
	}

	body := &bytes.Buffer{}
	writer := multipart.NewWriter(body)
	part, _ := writer.CreateFormFile("file", "test.txt")
	part.Write([]byte("hello world"))
	writer.Close()

	uploadReq, _ := http.NewRequest("POST", ts.URL+"/api/upload", body)
	uploadReq.Header.Set("Content-Type", writer.FormDataContentType())
	for _, cookie := range loginRes.Cookies() {
		uploadReq.AddCookie(cookie)
	}
	uploadRes, err := client.Do(uploadReq)
	if err != nil || uploadRes.StatusCode != 201 {
		t.Fatalf("Upload failed: %v, status: %d", err, uploadRes.StatusCode)
	}

	var uploadResp map[string]any
	json.NewDecoder(uploadRes.Body).Decode(&uploadResp)
	file := uploadResp["file"].(map[string]any)
	fileID := file["id"].(string)

	listReq, _ := http.NewRequest("GET", ts.URL+"/api/files?dir=inbox", nil)
	for _, cookie := range loginRes.Cookies() {
		listReq.AddCookie(cookie)
	}
	listRes, err := client.Do(listReq)
	if err != nil || listRes.StatusCode != 200 {
		t.Fatalf("List failed: %v, status: %d", err, listRes.StatusCode)
	}

	var listResp map[string]any
	json.NewDecoder(listRes.Body).Decode(&listResp)
	files := listResp["files"].([]any)
	if len(files) != 1 {
		t.Errorf("Expected 1 file, got %d", len(files))
	}

	dlReq, _ := http.NewRequest("GET", ts.URL+"/api/files/"+fileID+"/download", nil)
	for _, cookie := range loginRes.Cookies() {
		dlReq.AddCookie(cookie)
	}
	dlRes, err := client.Do(dlReq)
	if err != nil || dlRes.StatusCode != 200 {
		t.Fatalf("Download failed: %v, status: %d", err, dlRes.StatusCode)
	}

	shareReq, _ := http.NewRequest("POST", ts.URL+"/api/files/"+fileID+"/share", bytes.NewBufferString(`{}`))
	shareReq.Header.Set("Content-Type", "application/json")
	for _, cookie := range loginRes.Cookies() {
		shareReq.AddCookie(cookie)
	}
	shareRes, err := client.Do(shareReq)
	if err != nil || shareRes.StatusCode != 201 {
		t.Fatalf("Share create failed: %v, status: %d", err, shareRes.StatusCode)
	}

	var shareResp map[string]any
	json.NewDecoder(shareRes.Body).Decode(&shareResp)
	shareURL := shareResp["url"].(string)

	pubRes, err := client.Get(ts.URL + shareURL)
	if err != nil || pubRes.StatusCode != 200 {
		t.Fatalf("Public share access failed: %v, status: %d", err, pubRes.StatusCode)
	}
}