#!/usr/bin/env julia
# Test script for large payload testing using binary transport
# Tests sending a large file (> 1MB) via smartsend with binary type
# Updated to match NATSBridge.jl API

using NATS, JSON, UUIDs, Dates, PrettyPrinting, DataFrames, Arrow, HTTP


# workdir = 

# Include the bridge module
include("../src/NATSBridge.jl")
using .NATSBridge

# Configuration
const SUBJECT = "/NATSBridge_test"
const NATS_URL = "nats.yiem.cc"
const FILESERVER_URL = "http://192.168.88.104:8080"

# Create correlation ID for tracing
correlation_id = string(uuid4())


# ------------------------------------------------------------------------------------------------ #
#                                        test file transfer                                        #
# ------------------------------------------------------------------------------------------------ #


# Helper: Log with correlation ID
function log_trace(message)
    timestamp = Dates.now()
    println("[$timestamp] [Correlation: $correlation_id] $message")
end

# File upload handler for plik server
function plik_upload_handler(fileserver_url::String, dataname::String, data::Vector{UInt8})::Dict{String, Any}
    # Get upload ID
    url_getUploadID = "$fileserver_url/upload"
    headers = ["Content-Type" => "application/json"]
    body = """{ "OneShot" : true }"""
    httpResponse = HTTP.request("POST", url_getUploadID, headers, body; body_is_form=false)
    responseJson = JSON.parse(String(httpResponse.body))
    uploadid = responseJson["id"]
    uploadtoken = responseJson["uploadToken"]
    
    # Upload file
    file_multipart = HTTP.Multipart(dataname, IOBuffer(data), "application/octet-stream")
    url_upload = "$fileserver_url/file/$uploadid"
    headers = ["X-UploadToken" => uploadtoken]
    
    form = HTTP.Form(Dict("file" => file_multipart))
    httpResponse = HTTP.post(url_upload, headers, form)
    responseJson = JSON.parse(String(httpResponse.body))
    
    fileid = responseJson["id"]
    url = "$fileserver_url/file/$uploadid/$fileid/$dataname"
    
    return Dict("status" => httpResponse.status, "uploadid" => uploadid, "fileid" => fileid, "url" => url)
end

# Sender: Send large binary file via smartsend
function test_large_binary_send()
    # Read the large file as binary data
    
    # test data 1
    file_path1 = "./testFile_large.zip"
    file_data1 = read(file_path1)
    filename1 = basename(file_path1)
    data1 = (filename1, file_data1, "binary")

    # test data 2
    file_path2 = "./testFile_small.zip"
    file_data2 = read(file_path2)
    filename2 = basename(file_path2)
    data2 = (filename2, file_data2, "binary")
    
    
    
    # Use smartsend with binary type - will automatically use link transport
    # if file size exceeds the threshold (1MB by default)
    # API: smartsend(subject, [(dataname, data, type), ...]; keywords...)
    env = NATSBridge.smartsend(
        SUBJECT,
        [data1, data2];  # List of (dataname, data, type) tuples
        nats_url = NATS_URL;
        fileserver_url = FILESERVER_URL,
        fileserverUploadHandler = plik_upload_handler,
        size_threshold = 1_000_000,
        correlation_id = correlation_id,
        msg_purpose = "chat",
        sender_name = "sender",
        receiver_name = "",
        receiver_id = "",
        reply_to = "",
        reply_to_msg_id = ""
    )
    
    log_trace("Sent message with transport: $(env.payloads[1].transport)")
    log_trace("Envelope type: $(env.payloads[1].type)")
    
    # Check if link transport was used
    if env.payloads[1].transport == "link"
        log_trace("Using link transport - file uploaded to HTTP server")
        log_trace("URL: $(env.payloads[1].data)")
    else
        log_trace("Using direct transport - payload sent via NATS")
    end
end

# Run the test
println("Starting large binary payload test...")
println("Correlation ID: $correlation_id")

# Run sender first
println("start smartsend")
test_large_binary_send()

# Run receiver
# println("testing smartreceive")
# test_large_binary_receive()

println("Test completed.")