import java.nio.file.Files
import java.nio.file.StandardCopyOption

project.ext.updateNetworkInterceptor = { targetFile ->

    def emitFunctionSignature = 'private void emitNetworkInterceptorEvent(Call call, Response okHttpResponse, byte[] bytes, String stringResponse, long durationMillis, String traceId, String spanId) {'

    if (!targetFile.exists()) return

    def code = targetFile.getText('UTF-8')

    // Add imports only if missing
    if (!code.contains('import android.util.Log;')) {
        code = code.replaceFirst(
            /package com\.toyberman;/,
            """package com.toyberman;

import com.facebook.react.modules.core.DeviceEventManagerModule;
import java.util.UUID;
import okhttp3.HttpUrl;
import com.facebook.react.bridge.Arguments;
import com.facebook.react.bridge.WritableMap;
"""
        )
    }

    // Inject traceId + spanId if not present
    if (!code.contains('String traceId = generateRandomUUID(32);')) {
        code = code.replaceAll(
            /Request request = (.*?);/,
            { fullMatch, originalRequest ->
                return """
String traceId = generateRandomUUID(32);
String spanId = generateRandomUUID(16);
Request request = ${originalRequest}.newBuilder()
    .addHeader("traceparent", String.format("00-%s-%s-01", traceId, spanId))
    .build();"""
            }
        )
    }

    // Ensure callStartTime using nanoTime only (for precise duration in milliseconds)
    if (!code.contains('long callStartNanos')) {
        code = code.replaceFirst(
            /@Override\s+public void onFailure\(Call call, IOException e\)/,
            """
    private long callStartNanos = System.nanoTime();

    @Override
    public void onFailure(Call call, IOException e)
"""
        )
    }

    // Insert emitNetworkInterceptorEvent if not present
    def emitCallLine = 'emitNetworkInterceptorEvent(call, okHttpResponse, bytes, stringResponse, durationMillis, traceId, spanId);'
    if (!code.contains(emitCallLine)) {
        code = code.replaceAll(
            /@Override\s+public void onResponse\(Call call, Response okHttpResponse\) throws IOException \{\s+byte\[\] bytes = okHttpResponse\.body\(\)\.bytes\(\);\s+String stringResponse = new String\(bytes, "UTF-8"\);\s+String responseType = "";/,
            { match ->
                return match + """
        long callEndNanos = System.nanoTime();
        long durationMillis = (callEndNanos - callStartNanos) / 1_000_000;
        ${emitCallLine}
"""
            }
        )
    }

    // Remove existing emit method if present
    def methodPattern = /(?s)private void emitNetworkInterceptorEvent\(Call call, Response okHttpResponse, byte\[\] bytes, String stringResponse, long durationMillis, String traceId, String spanId\) \{.*?\n\s*\}/
    code = code.replaceAll(methodPattern, '')

    // Add emit method and UUID generator if missing
    def includeGenerateMethod = !code.contains('private String generateRandomUUID(int length)')
    def generateMethod = includeGenerateMethod ? """

    private String generateRandomUUID(int length) {
        return UUID.randomUUID().toString().replace("-", "").substring(0, length);
    }
""" : ""

    def emitMethod = """

    ${emitFunctionSignature}
        WritableMap payload = Arguments.createMap();
        HttpUrl url = call.request().url();
        payload.putString("host", url.host());
        payload.putString("scheme", url.scheme());
        payload.putString("method", call.request().method());
        payload.putString("url", url.toString());
        payload.putInt("status_code", okHttpResponse.code());
        payload.putString("status_text", okHttpResponse.message());
        payload.putString("response_content_length", String.valueOf(bytes.length));
        payload.putString("bodyString", stringResponse);
       payload.putDouble("duration", (double) durationMillis);
        payload.putString("traceId", traceId);
        payload.putString("spanId", spanId);

        reactContext
            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
            .emit("NetworkInterceptorEvent", payload);
    }${generateMethod}
"""

    def lastBrace = code.lastIndexOf('}')
    if (lastBrace != -1) {
        code = code.substring(0, lastBrace) + emitMethod + "\n}"
    }

    targetFile.write(code, 'UTF-8')
}