// ==============================================
// DELETE FOLDER PREREQUISITE SCRIPT (FIXED VERSION)
// ==============================================

// Constants with your specific configuration
const API_CONFIG = {
    BASE_URL: "https://293-app-dev-btdocsvc-api.azurewebsites.net",
    DEFAULT_CLIENT_ID: "5BF1C741-8316-490E-0D9B-08DD46082805",
    DEFAULT_TENANT_ID: "8A5F6503-3266-4B10-BC69-364D140357F6"
};

// Helper function to get variables with proper error messaging
const getRequiredVariable = (name, defaultValue) => {
    const value = pm.collectionVariables.get(name) || pm.environment.get(name) || defaultValue;
    if (!value) throw new Error(`Missing required variable: ${name}`);
    return value;
};

// Main function to create a test folder
const createTestFolder = async () => {
    try {
        // Get all required configuration
        const clientId = getRequiredVariable("clientId", API_CONFIG.DEFAULT_CLIENT_ID);
        const tenantId = getRequiredVariable("tenantId", API_CONFIG.DEFAULT_TENANT_ID);
        const authToken = pm.environment.get("oauth_token");
        
        if (!authToken) throw new Error("No OAuth token available - run authentication first");

        const randomFolderName = `TestFolder_${Math.random().toString(36).substring(2, 8)}`;
        const createEndpoint = `${API_CONFIG.BASE_URL}/api/v1/Folders`;
        
        console.log(`Creating test folder at: ${createEndpoint}`);
        console.log(`Using clientId: ${clientId}, tenantId: ${tenantId}`);
        console.log(`Folder name: ${randomFolderName}`);

        const createResponse = await new Promise((resolve) => {
            pm.sendRequest({
                url: createEndpoint,
                method: 'POST',
                header: {
                    'Content-Type': 'application/json',
                    'Authorization': `Bearer ${authToken}`
                },
                body: {
                    mode: 'raw',
                    raw: JSON.stringify({
                        clientId: clientId,
                        folderPaths: [randomFolderName],
                        tenantId: tenantId,
                        modifiedBy: "AutomatedTest"
                    })
                }
            }, (err, res) => {
                if (err) {
                    console.error("Request failed:", err);
                    resolve({ error: err.toString() });
                } else {
                    resolve(res);
                }
            });
        });

        // Handle request errors
        if (createResponse.error) {
            throw new Error(`Request failed: ${createResponse.error}`);
        }

        console.log("Creation response status:", createResponse.code);
        console.log("Response headers:", JSON.stringify(createResponse.headers.toObject(), null, 2));
        console.log("Response body:", createResponse.text());

        // Check for successful response
        if (createResponse.code === 200 || createResponse.code === 207) {
            let folderId;
            try {
                const responseData = createResponse.json();
                console.log("Parsed response data:", JSON.stringify(responseData, null, 2));
                
                // Fixed ID extraction logic to match your API response structure
                folderId = responseData.data?.[0]?.id || 
                          responseData.id || 
                          (responseData[0]?.id) || 
                          (responseData.folders?.[0]?.id) ||
                          (responseData.value?.[0]?.id);
                
                if (!folderId) {
                    console.error("Full response:", JSON.stringify(responseData, null, 2));
                    throw new Error("Folder ID not found in response. Tried paths: data[0].id, id, [0].id, folders[0].id, value[0].id");
                }
            } catch (parseError) {
                console.error("Failed to parse response:", parseError);
                throw new Error("Invalid response format from folder creation");
            }

            console.log(`Successfully created folder with ID: ${folderId}`);
            return folderId;
        } else {
            throw new Error(`API returned ${createResponse.code}: ${createResponse.text()}`);
        }
    } catch (error) {
        console.error("Error in createTestFolder:", error);
        throw error;
    }
};

// Main execution
(async () => {
    try {
        // Check if we already have a folder ID to delete
        let folderIdToDelete = pm.collectionVariables.get("folderIdToDelete");
        
        if (!folderIdToDelete) {
            console.log("No folder ID available - creating test folder...");
            folderIdToDelete = await createTestFolder();
            pm.collectionVariables.set("folderIdToDelete", folderIdToDelete);
            
            // Update the request URL directly to ensure the ID is used
            const deleteEndpoint = `${API_CONFIG.BASE_URL}/api/v1/Folders/${folderIdToDelete}`;
            const currentUrl = pm.request.url.toString();
            
            if (currentUrl.includes("/Folders/{{id}}") || currentUrl.includes("/Folders/:id")) {
                pm.request.url = deleteEndpoint + (pm.request.url.query ? "?" + pm.request.url.query.toString() : "");
            }
            
            console.log(`Delete endpoint set to: ${pm.request.url}`);
        }

        console.log(`Preparing to delete folder with ID: ${folderIdToDelete}`);
        
        // Ensure the Authorization header is set
        pm.request.headers.upsert({
            key: "Authorization",
            value: `Bearer ${pm.environment.get("oauth_token")}`
        });

    } catch (error) {
        console.error("Pre-request script failed:", error);
        postman.setNextRequest(null); // Stop execution
        
        // Create a more user-friendly error message
        const errorMessage = `DELETE PREREQUISITE FAILED:
- Ensure you have a valid oauth_token
- Verify your clientId and tenantId are correct
- Check API availability at ${API_CONFIG.BASE_URL}
- Original error: ${error.message}`;
        
        throw new Error(errorMessage);
    }
})();