#r "Newtonsoft.Json"

using System.Net;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Primitives;
using Newtonsoft.Json;
using Microsoft.Azure.WebJobs;

public static async Task<IActionResult> Run(HttpRequest req, ILogger log, IAsyncCollector<dynamic> outputDocuments)
{
    var requestUtc = DateTime.UtcNow;

    string requestBody = null;
    using (var bodyReader = new StreamReader(req.Body))
    {
        requestBody = await bodyReader.ReadToEndAsync();
    }

    log.LogInformation($"Request body: {requestBody}");

    var formValues = System.Web.HttpUtility.ParseQueryString(requestBody);

    var password = GeneratePassword();

    var outputDocument = new 
    {
        requestUtc,
        Company = "Azure",
        firstName = formValues["firstName"],
        lastName = formValues["lastName"],
        nickname = formValues["nickname"],
        password = password
    };

    await outputDocuments.AddAsync(outputDocument);

    return new ContentResult
    {
        Content = "success",
        ContentType = "text/plain",
        StatusCode = (int)HttpStatusCode.OK
    };
}

public static string GeneratePassword()
{
    var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
    var random = new Random();
    var password = new string(
        Enumerable.Repeat(chars, 6)
                  .Select(s => s[random.Next(s.Length)])
                  .ToArray());

    return "my1P@" + password;
}

const { BlobServiceClient } = require("@azure/storage-blob");
const { DefaultAzureCredential } = require("@azure/identity");
const stream = require("stream");
const csv = require("csv-parser");
const moment = require("moment");
const accountName = "xxxStorageAccxxx";
const containerName = process.env.BlobContainerName;

module.exports = async function (context, documents) {
    context.log(`Cosmos DB trigger function processed ${documents.length} documents`);

    // Create a BlobServiceClient object which will be used to create a container client
    const defaultAzureCredential = new DefaultAzureCredential({
        additionallyAllowedTenants: ["*"]
        });
    const blobServiceClient = new BlobServiceClient(
        `https://${accountName}.blob.core.windows.net/csv/`,
        defaultAzureCredential);

    // Get a reference to a container
    const containerClient = blobServiceClient.getContainerClient(process.env.BlobContainerName);

    // Create a new blob name
    //const directoryName = "addata";
    const blobName = 'data/users.csv';
 
 
 // Check if the file already exists in the container
    const blobClient = containerClient.getBlockBlobClient(blobName);
    const exists = await blobClient.exists();
    let csvData = '';
    if (exists) {
        // If the file exists, download it and append new values
        const downloadResponse = await blobClient.download();
        const existingCsvData = await streamToString(downloadResponse.readableStreamBody);
        csvData = existingCsvData.trim() + '\n';
    } else {
        // If the file does not exist, add the column headers
        csvData = 'id,firstName,lastName,nickname,password\n';
    }

    // Parse the input documents and append them to the CSV data
    for (const document of documents) {
        const csvRow = {
            'id': document.id,
            'firstName': document.firstName,
            'lastName': document.lastName,
            'nickname': document.nickname,
            'password': document.password            
        };
        const values = Object.values(csvRow).join(',');
        csvData += values + '\n';
    }

    // Upload the CSV data to a Storage Blob
    const uploadOptions = { blobHTTPHeaders: { blobContentType: 'text/csv' } };
    await blobClient.upload(csvData, csvData.length, uploadOptions);

    context.log(`Uploaded CSV data to blob: ${blobName}`);
};

// Helper function to convert a ReadableStream to a string
async function streamToString(readableStream) {
    return new Promise((resolve, reject) => {
        const chunks = [];
        readableStream.on("data", (data) => {
            chunks.push(data.toString());
        });
        readableStream.on("end", () => {
            resolve(chunks.join(""));
        });
        readableStream.on("error", reject);
    });
}

const axios = require('axios');

module.exports = async function (context, myBlob) {
    //const PAT = process.env.PersonalAccessToken; // Replace with your Azure DevOps personal access token
    const ORGANIZATION_URL = process.env.AzureDevOpsCollectionURL; // Replace with your Azure DevOps organization URL
    const PROJECT_NAME = process.env.ProjectName; // Replace with your Azure DevOps project name
    const PIPELINE_ID = process.env.definitionId; // Replace with your Azure DevOps build pipeline ID

    const buildUrl = `${ORGANIZATION_URL}/${PROJECT_NAME}/_apis/build/builds?api-version=7.1-preview.7`;

    const requestBody = {
        definition: { id: PIPELINE_ID }
    };
    var axios = require('axios');
    var data = JSON.stringify({
      "definition": {
        "id": 10
      }
    });
    const config = {
      method: 'post',
      maxBodyLength: Infinity,
        url: 'https://dev.azure.com/xxxx/xxxxxxxx/_apis/build/builds?api-version=7.1-preview.7',
        headers: { 
          'Content-Type': 'application/json', 
          'Authorization': 'Basic xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx', 
        },
        data : data
      };
      axios(config)
      .then(function (response) {
        console.log(JSON.stringify(response.data));
      })
      .catch(function (error) {
        console.log(error);
      });
    try {
        const response = await axios.post(buildUrl, requestBody, config);
        context.log(`Build queued with ID: ${response.data.id}`);
    } catch (error) {
        context.log(`Failed to queue build: ${error.message}`);
    }
};