[HttpPost("file")]
    public async Task<IActionResult> UploadFile([FromBody] FileUpload Upload)
    {
        Config.DefaultResponse response = new Config.DefaultResponse();
        try
        {
            string siteUrl = "";

            var accessTokenResult = await GetAccessToken();

            if (accessTokenResult is ObjectResult accessTokenObjectResult && accessTokenObjectResult.Value is string accessToken)
            {
                string libraryName = "Shared Documents";
                string folderPath = Upload.FolderName;

                string[] folders = folderPath.Trim('/').Split('/');
                var firstFolderPathSet = folders[0] + "/" + folders[1];
                var firstFolderUrl = $"{siteUrl}/_api/web/getfolderbyserverrelativeurl('{libraryName}/{firstFolderPathSet}')/Exists";
                var secondFolderPathSet = folders[0] + "/" + folders[1] + "/" + folders[2];
                var secondFolderUrl = $"{siteUrl}/_api/web/getfolderbyserverrelativeurl('{libraryName}/{secondFolderPathSet}')/Exists";
                var thirdFolderPathSet = folders[0] + "/" + folders[1] + "/" + folders[2] + "/" + folders[3];
                var thirdFolderUrl = $"{siteUrl}/_api/web/getfolderbyserverrelativeurl('{libraryName}/{thirdFolderPathSet}')/Exists";
                var fourthFolderPathSet = folders[0] + "/" + folders[1] + "/" + folders[2] + "/" + folders[3] + "/" + folders[4];
                var fourthFolderUrl = $"{siteUrl}/_api/web/getfolderbyserverrelativeurl('{libraryName}/{fourthFolderPathSet}')/Exists";

                using (var httpClient = new HttpClient())
                {
                    httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
                    httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
                    var checkResponse = await httpClient.GetAsync(firstFolderUrl);
                    if (checkResponse.IsSuccessStatusCode)
                    {
                        var responseText = await checkResponse.Content.ReadAsStringAsync();
                        JObject jsonResponse = JObject.Parse(responseText);
                        bool extractedValue = jsonResponse["value"].Value<bool>();
                        if (!extractedValue)
                        {
                            var createFolderUrl = $"{siteUrl}/_api/web/folders/add('{libraryName}/{firstFolderPathSet}')";
                            using (var createResponse = await httpClient.PostAsync(createFolderUrl, null))
                            {
                                if (!createResponse.IsSuccessStatusCode)
                                {
                                    response = new Config.DefaultResponse(500,"Failed to create folder", "Failed to create folder");
                                    return BadRequest(response);
                                }
                            }
                        }
                    }
                    else
                    {
                        response = new Config.DefaultResponse(500,"Failed", "Failed to check if folder exists");
                        return BadRequest(response);
                    }
                }
                //second folder
                using (var httpClient = new HttpClient())
                {
                    httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
                    httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
                    var checkResponse = await httpClient.GetAsync(secondFolderUrl);
                    if (checkResponse.IsSuccessStatusCode)
                    {
                        var responseText = await checkResponse.Content.ReadAsStringAsync();
                        JObject jsonResponse = JObject.Parse(responseText);
                        bool extractedValue = jsonResponse["value"].Value<bool>();
                        if (!extractedValue)
                        {
                            var createFolderUrl = $"{siteUrl}/_api/web/folders/add('{libraryName}/{secondFolderPathSet}')";
                            using (var createResponse = await httpClient.PostAsync(createFolderUrl, null))
                            {
                                if (!createResponse.IsSuccessStatusCode)
                                {
                                    response = new Config.DefaultResponse(500,"Failed to create folder", "Failed to create folder");
                                    return BadRequest(response);
                                }
                            }
                        }
                    }
                    else
                    {
                        response = new Config.DefaultResponse(500,"Failed", "Failed to check if folder exists");
                        return BadRequest(response);
                    }
                }
                //third folder
                using (var httpClient = new HttpClient())
                {
                    httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
                    httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
                    var checkResponse = await httpClient.GetAsync(thirdFolderUrl);
                    if (checkResponse.IsSuccessStatusCode)
                    {
                        var responseText = await checkResponse.Content.ReadAsStringAsync();
                        JObject jsonResponse = JObject.Parse(responseText);
                        bool extractedValue = jsonResponse["value"].Value<bool>();
                        if (!extractedValue)
                        {
                            var createFolderUrl = $"{siteUrl}/_api/web/folders/add('{libraryName}/{thirdFolderPathSet}')";
                            using (var createResponse = await httpClient.PostAsync(createFolderUrl, null))
                            {
                                if (!createResponse.IsSuccessStatusCode)
                                {
                                    response = new Config.DefaultResponse(500,"Failed to create folder", "Failed to create folder");
                                    return BadRequest(response);
                                }
                            }
                        }
                    }
                    else
                    {
                        response = new Config.DefaultResponse(500,"Failed", "Failed to check if folder exists");
                        return BadRequest(response);
                    }
                }
                //fourth folder
                using (var httpClient = new HttpClient())
                {
                    httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
                    httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
                    var checkResponse = await httpClient.GetAsync(fourthFolderUrl);
                    if (checkResponse.IsSuccessStatusCode)
                    {
                        var responseText = await checkResponse.Content.ReadAsStringAsync();
                        JObject jsonResponse = JObject.Parse(responseText);
                        bool extractedValue = jsonResponse["value"].Value<bool>();
                        if (!extractedValue)
                        {
                            var createFolderUrl = $"{siteUrl}/_api/web/folders/add('{libraryName}/{fourthFolderPathSet}')";
                            using (var createResponse = await httpClient.PostAsync(createFolderUrl, null))
                            {
                                if (!createResponse.IsSuccessStatusCode)
                                {
                                    response = new Config.DefaultResponse(500,"Failed to create folder", "Failed to create folder");
                                    return BadRequest(response);
                                }
                            }
                        }
                    }
                    else
                    {
                        response = new Config.DefaultResponse(500,"Failed", "Failed to check if folder exists");
                        return BadRequest(response);
                    }
                }
                    string fileName = Upload.FileName;
                //var uploadUrl = $"{currentFolderUrl}/files/add(url='{fileName}',overwrite=true)";
                var uploadUrl = $"{siteUrl}/_api/web/getfolderbyserverrelativeurl('{libraryName}{folderPath}')/files/add(overwrite=true,url='{fileName}')";

                //Write filecontent to local file


                using (var httpClient = new HttpClient())
                {
                    httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
                    httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));

                    byte[] fileBytes = Convert.FromBase64String(Upload.FileContent);

                    ByteArrayContent fileContent = new ByteArrayContent(fileBytes);
                    fileContent.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");

                    using (var httpResponse = await httpClient.PostAsync(uploadUrl, fileContent))
                    {
                        var responseText = await httpResponse.Content.ReadAsStringAsync();

                        if (httpResponse.IsSuccessStatusCode)
                        {

                            var fileUrl= siteUrl + "/" + libraryName +folderPath + "/" + fileName;
                            var myData = new
                            {
                                Name = fileName,
                                fileUrl = fileUrl
                            };
                            response = new Config.DefaultResponse(200, "Success", myData);
                            return Ok(response);
                        }
                        else
                        {
                            response = new Config.DefaultResponse(500,"Failed to upload file", responseText);
                            return BadRequest(response);
                        }
                    }
                }
            }
            else
            {
                return BadRequest("Failed to obtain access token");
            }
        }
        catch (Exception ex)
        {
           var exceptionResponse = new Config.DefaultResponse(500,"Failed to upload file", ex.Message);
            return StatusCode(500, exceptionResponse);
        }
    }