{
  "TenantId": "00000000-0000-0000-0000-000000000000",
  "ClientId": "11111111-1111-1111-1111-111111111111",
  "ClientSecret": "YOUR-SECRET",

  "Target": {
    "Hostname": "contoso.sharepoint.com",
    "SiteServerRelativePath": "/sites/ExampleSite",

    "DriveName": "Documents",
    "FolderPath": "Incoming/2026/January",
    "LocalFilePath": "C:\\Temp\\example.pdf",
    "UploadFileName": "example.pdf",

    "Metadata": {
      "Title": "Example document uploaded by Graph",
      "Category": "Engineering"
    }
  }
}

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
using Microsoft.Identity.Client;

internal sealed class RootConfig
{
    public string TenantId { get; set; } = "";
    public string ClientId { get; set; } = "";
    public string ClientSecret { get; set; } = "";
    public TargetConfig Target { get; set; } = new();
}

internal sealed class TargetConfig
{
    public string Hostname { get; set; } = "contoso.sharepoint.com";
    public string SiteServerRelativePath { get; set; } = "/sites/ExampleSite";

    public string DriveName { get; set; } = "Documents";
    public string FolderPath { get; set; } = "Incoming/2026/January";

    public string LocalFilePath { get; set; } = @"C:\Temp\example.pdf";
    public string UploadFileName { get; set; } = "example.pdf";

    public Dictionary<string, string> Metadata { get; set; } = new();
}

internal static class Program
{
    private const string GraphBase = "https://graph.microsoft.com/v1.0";
    private static readonly string[] GraphScopes = new[] { "https://graph.microsoft.com/.default" };

    public static async Task<int> Main()
    {
        try
        {
            var cfg = LoadConfig("appsettings.json");
            Validate(cfg);

            var token = await AcquireAppOnlyTokenAsync(cfg.TenantId, cfg.ClientId, cfg.ClientSecret);

            // 1) Resolve site
            var site = await GetSiteByPathAsync(token, cfg.Target.Hostname, cfg.Target.SiteServerRelativePath);
            Console.WriteLine($"Site: {site.Id}");
            Console.WriteLine($"WebUrl: {site.WebUrl}");
            Console.WriteLine();

            // 2) Find drive (document library)
            var driveId = await FindDriveIdByNameAsync(token, site.Id, cfg.Target.DriveName);
            Console.WriteLine($"Drive '{cfg.Target.DriveName}': {driveId}");
            Console.WriteLine();

            // 3) Ensure folder chain under drive root
            var folderId = await EnsureFolderPathAsync(token, driveId, cfg.Target.FolderPath);
            Console.WriteLine($"Folder '{cfg.Target.FolderPath}' -> ItemId: {folderId}");
            Console.WriteLine();

            // 4) Upload (small <= 250MB or large upload session)
            var localPath = cfg.Target.LocalFilePath;
            if (!File.Exists(localPath))
                throw new FileNotFoundException("LocalFilePath not found.", localPath);

            var uploadedItem = await UploadFileAutoAsync(token, driveId, folderId, localPath, cfg.Target.UploadFileName);
            Console.WriteLine($"Uploaded DriveItemId: {uploadedItem.Id}");
            Console.WriteLine($"Uploaded Name: {uploadedItem.Name}");
            Console.WriteLine();

            // 5) Update metadata (custom columns) on the linked listItem
            if (cfg.Target.Metadata != null && cfg.Target.Metadata.Count > 0)
            {
                await PatchDriveItemListItemFieldsAsync(token, driveId, uploadedItem.Id, cfg.Target.Metadata);
                Console.WriteLine("Metadata updated (listItem/fields).");
                Console.WriteLine();
            }

            // 6) List versions
            var versions = await ListVersionsAsync(token, driveId, uploadedItem.Id);
            Console.WriteLine($"Versions found: {versions.Count}");
            foreach (var v in versions.Take(10))
            {
                Console.WriteLine($"- {v.Id} | lastModifiedDateTime={v.LastModifiedDateTime}");
            }

            return 0;
        }
        catch (Exception ex)
        {
            Console.Error.WriteLine("FAILED:");
            Console.Error.WriteLine(ex);
            return 1;
        }
    }

    // -------------------- Config --------------------

    private static RootConfig LoadConfig(string path)
    {
        var json = File.ReadAllText(path);
        return JsonSerializer.Deserialize<RootConfig>(json, new JsonSerializerOptions
        {
            PropertyNameCaseInsensitive = true
        }) ?? throw new InvalidOperationException("Invalid appsettings.json");
    }

    private static void Validate(RootConfig cfg)
    {
        if (string.IsNullOrWhiteSpace(cfg.TenantId)) throw new ArgumentException("TenantId is required.");
        if (string.IsNullOrWhiteSpace(cfg.ClientId)) throw new ArgumentException("ClientId is required.");
        if (string.IsNullOrWhiteSpace(cfg.ClientSecret)) throw new ArgumentException("ClientSecret is required.");

        if (string.IsNullOrWhiteSpace(cfg.Target.Hostname)) throw new ArgumentException("Target.Hostname is required.");
        if (string.IsNullOrWhiteSpace(cfg.Target.SiteServerRelativePath)) throw new ArgumentException("Target.SiteServerRelativePath is required.");
        if (!cfg.Target.SiteServerRelativePath.StartsWith("/")) throw new ArgumentException("Target.SiteServerRelativePath must start with '/'.");
        if (string.IsNullOrWhiteSpace(cfg.Target.DriveName)) throw new ArgumentException("Target.DriveName is required.");
        if (string.IsNullOrWhiteSpace(cfg.Target.UploadFileName)) throw new ArgumentException("Target.UploadFileName is required.");
        if (string.IsNullOrWhiteSpace(cfg.Target.LocalFilePath)) throw new ArgumentException("Target.LocalFilePath is required.");
    }

    // -------------------- Auth (MSAL) --------------------

    private static async Task<string> AcquireAppOnlyTokenAsync(string tenantId, string clientId, string clientSecret)
    {
        var app = ConfidentialClientApplicationBuilder
            .Create(clientId)
            .WithClientSecret(clientSecret)
            .WithAuthority($"https://login.microsoftonline.com/{tenantId}")
            .Build();

        var result = await app.AcquireTokenForClient(GraphScopes).ExecuteAsync();
        return result.AccessToken;
    }

    // -------------------- HTTP helpers --------------------

    private static HttpClient CreateHttp(string token)
    {
        var http = new HttpClient();
        http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
        http.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
        return http;
    }

    private static async Task<string> SendJsonWithRetryAsync(HttpClient http, HttpMethod method, string url, string? jsonBody = null)
    {
        const int maxAttempts = 6;
        var attempt = 0;

        while (true)
        {
            attempt++;

            using var req = new HttpRequestMessage(method, url);
            if (jsonBody != null)
            {
                req.Content = new StringContent(jsonBody, Encoding.UTF8, "application/json");
            }

            using var resp = await http.SendAsync(req);
            var body = await resp.Content.ReadAsStringAsync();

            if ((int)resp.StatusCode == 429)
            {
                if (attempt >= maxAttempts)
                    throw new HttpRequestException("Too many throttled attempts (429).");

                var delaySeconds = 30;
                if (resp.Headers.RetryAfter?.Delta != null)
                    delaySeconds = (int)Math.Ceiling(resp.Headers.RetryAfter.Delta.Value.TotalSeconds);

                await Task.Delay(TimeSpan.FromSeconds(delaySeconds));
                continue;
            }

            if (!resp.IsSuccessStatusCode)
            {
                throw new HttpRequestException(
                    $"Graph call failed: {(int)resp.StatusCode} {resp.ReasonPhrase}\nURL: {url}\nBODY:\n{body}"
                );
            }

            return body;
        }
    }

    // -------------------- Graph: Site by path --------------------

    private sealed record SiteInfo(string Id, string WebUrl);

    private static async Task<SiteInfo> GetSiteByPathAsync(string token, string hostname, string serverRelativePath)
    {
        // GET /sites/{hostname}:/{server-relative-path}
        var url = $"{GraphBase}/sites/{hostname}:{serverRelativePath}";
        using var http = CreateHttp(token);

        var json = await SendJsonWithRetryAsync(http, HttpMethod.Get, url);
        using var doc = JsonDocument.Parse(json);

        var id = doc.RootElement.GetProperty("id").GetString() ?? "";
        var webUrl = doc.RootElement.TryGetProperty("webUrl", out var w) ? (w.GetString() ?? "") : "";

        if (string.IsNullOrWhiteSpace(id))
            throw new InvalidOperationException("Could not resolve site id.");

        return new SiteInfo(id, webUrl);
    }

    // -------------------- Graph: Drives under site --------------------

    private sealed record DriveInfo(string Id, string Name);

    private static async Task<string> FindDriveIdByNameAsync(string token, string siteId, string driveName)
    {
        // GET /sites/{siteId}/drives
        var url = $"{GraphBase}/sites/{siteId}/drives?$select=id,name";
        using var http = CreateHttp(token);

        var json = await SendJsonWithRetryAsync(http, HttpMethod.Get, url);
        using var doc = JsonDocument.Parse(json);

        foreach (var d in doc.RootElement.GetProperty("value").EnumerateArray())
        {
            var name = d.GetProperty("name").GetString() ?? "";
            var id = d.GetProperty("id").GetString() ?? "";
            if (string.Equals(name, driveName, StringComparison.OrdinalIgnoreCase) && !string.IsNullOrWhiteSpace(id))
                return id;
        }

        // fallback: default drive if name isn't found
        // GET /sites/{siteId}/drive
        var defaultDriveJson = await SendJsonWithRetryAsync(http, HttpMethod.Get, $"{GraphBase}/sites/{siteId}/drive?$select=id,name");
        using var defDoc = JsonDocument.Parse(defaultDriveJson);
        var defId = defDoc.RootElement.GetProperty("id").GetString() ?? "";
        if (!string.IsNullOrWhiteSpace(defId))
            return defId;

        throw new InvalidOperationException($"Drive not found: '{driveName}', and default drive could not be resolved.");
    }

    // -------------------- Graph: Folder chain --------------------

    private static async Task<string> EnsureFolderPathAsync(string token, string driveId, string folderPath)
    {
        // Start at drive root
        var currentId = "root";
        var segments = (folderPath ?? "")
            .Split(new[] { '/', '\\' }, StringSplitOptions.RemoveEmptyEntries)
            .Select(s => s.Trim())
            .Where(s => !string.IsNullOrWhiteSpace(s))
            .ToArray();

        if (segments.Length == 0)
            return "root";

        foreach (var segment in segments)
        {
            var existingChildId = await TryFindChildFolderIdAsync(token, driveId, currentId, segment);
            if (!string.IsNullOrWhiteSpace(existingChildId))
            {
                currentId = existingChildId;
                continue;
            }

            // Create folder
            currentId = await CreateFolderAsync(token, driveId, currentId, segment);
        }

        return currentId;
    }

    private static async Task<string?> TryFindChildFolderIdAsync(string token, string driveId, string parentIdOrRoot, string folderName)
    {
        // GET /drives/{driveId}/items/{itemId}/children  (or /root/children)
        var url = parentIdOrRoot == "root"
            ? $"{GraphBase}/drives/{driveId}/root/children?$select=id,name,folder"
            : $"{GraphBase}/drives/{driveId}/items/{parentIdOrRoot}/children?$select=id,name,folder";

        using var http = CreateHttp(token);
        var json = await SendJsonWithRetryAsync(http, HttpMethod.Get, url);
        using var doc = JsonDocument.Parse(json);

        foreach (var item in doc.RootElement.GetProperty("value").EnumerateArray())
        {
            var name = item.GetProperty("name").GetString() ?? "";
            var isFolder = item.TryGetProperty("folder", out _);
            if (isFolder && string.Equals(name, folderName, StringComparison.OrdinalIgnoreCase))
            {
                return item.GetProperty("id").GetString();
            }
        }

        return null;
    }

    private static async Task<string> CreateFolderAsync(string token, string driveId, string parentIdOrRoot, string folderName)
    {
        // POST /drives/{driveId}/items/{parentId}/children (or /root/children)
        var url = parentIdOrRoot == "root"
            ? $"{GraphBase}/drives/{driveId}/root/children"
            : $"{GraphBase}/drives/{driveId}/items/{parentIdOrRoot}/children";

        var payload = new
        {
            name = folderName,
            folder = new { },
            // If a folder already exists, you may choose: "rename" or "fail".
            // We do a pre-check, so "fail" is acceptable too.
            @microsoft_graph_conflictBehavior = "fail"
        };

        // System.Text.Json can't serialize property names with dots easily; use raw JSON:
        var jsonBody = $"{{\"name\":\"{EscapeJson(folderName)}\",\"folder\":{{}},\"@microsoft.graph.conflictBehavior\":\"fail\"}}";

        using var http = CreateHttp(token);
        var json = await SendJsonWithRetryAsync(http, HttpMethod.Post, url, jsonBody);
        using var doc = JsonDocument.Parse(json);

        var id = doc.RootElement.GetProperty("id").GetString() ?? "";
        if (string.IsNullOrWhiteSpace(id))
            throw new InvalidOperationException("Folder creation succeeded but no id returned.");
        return id;
    }

    private static string EscapeJson(string s) => s.Replace("\\", "\\\\").Replace("\"", "\\\"");

    // -------------------- Graph: Upload (small vs large) --------------------

    private sealed record DriveItemInfo(string Id, string Name);

    private static async Task<DriveItemInfo> UploadFileAutoAsync(string token, string driveId, string parentFolderIdOrRoot, string localFilePath, string uploadName)
    {
        var fi = new FileInfo(localFilePath);

        // Simple upload supports up to 250 MB
        if (fi.Length <= 250L * 1024L * 1024L)
        {
            return await UploadSmallFileAsync(token, driveId, parentFolderIdOrRoot, localFilePath, uploadName);
        }

        return await UploadLargeFileWithSessionAsync(token, driveId, parentFolderIdOrRoot, localFilePath, uploadName);
    }

    private static async Task<DriveItemInfo> UploadSmallFileAsync(string token, string driveId, string parentFolderIdOrRoot, string localFilePath, string uploadName)
    {
        // PUT /drives/{driveId}/items/{parentId}:/{fileName}:/content
        // For root: /drives/{driveId}/root:/{fileName}:/content
        var url = parentFolderIdOrRoot == "root"
            ? $"{GraphBase}/drives/{driveId}/root:/{Uri.EscapeDataString(uploadName)}:/content"
            : $"{GraphBase}/drives/{driveId}/items/{parentFolderIdOrRoot}:/{Uri.EscapeDataString(uploadName)}:/content";

        using var http = new HttpClient();
        http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);

        using var fs = File.OpenRead(localFilePath);
        using var content = new StreamContent(fs);

        // Graph returns the created/updated driveItem JSON
        using var resp = await http.PutAsync(url, content);
        var body = await resp.Content.ReadAsStringAsync();

        if (!resp.IsSuccessStatusCode)
            throw new HttpRequestException($"Small upload failed: {(int)resp.StatusCode} {resp.ReasonPhrase}\n{body}");

        using var doc = JsonDocument.Parse(body);
        var id = doc.RootElement.GetProperty("id").GetString() ?? "";
        var name = doc.RootElement.GetProperty("name").GetString() ?? "";
        return new DriveItemInfo(id, name);
    }

    private static async Task<DriveItemInfo> UploadLargeFileWithSessionAsync(string token, string driveId, string parentFolderIdOrRoot, string localFilePath, string uploadName)
    {
        // POST /drives/{driveId}/items/{parentId}:/{fileName}:/createUploadSession
        // For root: /drives/{driveId}/root:/{fileName}:/createUploadSession
        var createUrl = parentFolderIdOrRoot == "root"
            ? $"{GraphBase}/drives/{driveId}/root:/{Uri.EscapeDataString(uploadName)}:/createUploadSession"
            : $"{GraphBase}/drives/{driveId}/items/{parentFolderIdOrRoot}:/{Uri.EscapeDataString(uploadName)}:/createUploadSession";

        using var http = CreateHttp(token);

        // You can add item properties here; conflictBehavior "replace" overwrites if exists.
        var createBody = "{\"item\":{\"@microsoft.graph.conflictBehavior\":\"replace\"}}";
        var sessionJson = await SendJsonWithRetryAsync(http, HttpMethod.Post, createUrl, createBody);
        using var sessionDoc = JsonDocument.Parse(sessionJson);
        var uploadUrl = sessionDoc.RootElement.GetProperty("uploadUrl").GetString();

        if (string.IsNullOrWhiteSpace(uploadUrl))
            throw new InvalidOperationException("Upload session created but uploadUrl is missing.");

        // Upload in sequential chunks. Docs say max bytes per request must be < 60 MiB.
        const int chunkSize = 10 * 1024 * 1024; // 10 MiB safe chunk
        var fi = new FileInfo(localFilePath);
        long total = fi.Length;

        using var fs = File.OpenRead(localFilePath);
        long offset = 0;

        while (offset < total)
        {
            int toRead = (int)Math.Min(chunkSize, total - offset);
            byte[] buffer = new byte[toRead];
            int read = await fs.ReadAsync(buffer, 0, toRead);
            if (read <= 0) throw new IOException("Unexpected end of file while reading.");

            using var chunkContent = new ByteArrayContent(buffer, 0, read);
            chunkContent.Headers.ContentLength = read;
            chunkContent.Headers.ContentRange = new ContentRangeHeaderValue(offset, offset + read - 1, total);

            using var chunkReq = new HttpRequestMessage(HttpMethod.Put, uploadUrl);
            chunkReq.Content = chunkContent;

            // uploadUrl is a pre-authenticated URL; do not send Authorization header here.
            using var chunkHttp = new HttpClient();
            using var chunkResp = await chunkHttp.SendAsync(chunkReq);
            var chunkBody = await chunkResp.Content.ReadAsStringAsync();

            if (!chunkResp.IsSuccessStatusCode)
            {
                throw new HttpRequestException($"Chunk upload failed: {(int)chunkResp.StatusCode} {chunkResp.ReasonPhrase}\n{chunkBody}");
            }

            // When final chunk completes, the response is the driveItem JSON.
            if (chunkResp.StatusCode == HttpStatusCode.Created || chunkResp.StatusCode == HttpStatusCode.OK)
            {
                using var finalDoc = JsonDocument.Parse(chunkBody);
                var id = finalDoc.RootElement.GetProperty("id").GetString() ?? "";
                var name = finalDoc.RootElement.GetProperty("name").GetString() ?? "";
                return new DriveItemInfo(id, name);
            }

            // Otherwise, 202 Accepted with nextExpectedRanges typically (we don't need it for sequential upload).
            offset += read;
        }

        throw new InvalidOperationException("Upload loop ended without returning a driveItem.");
    }

    // -------------------- Graph: Patch metadata on linked listItem/fields --------------------

    private static async Task PatchDriveItemListItemFieldsAsync(string token, string driveId, string driveItemId, Dictionary<string, string> fields)
    {
        // PATCH /drives/{driveId}/items/{itemId}/listItem/fields
        var url = $"{GraphBase}/drives/{driveId}/items/{driveItemId}/listItem/fields";
        using var http = CreateHttp(token);

        // Build JSON from dictionary
        var obj = new Dictionary<string, object>();
        foreach (var kvp in fields)
            obj[kvp.Key] = kvp.Value;

        var jsonBody = JsonSerializer.Serialize(obj);
        await SendJsonWithRetryAsync(http, HttpMethod.Patch, url, jsonBody);
    }

    // -------------------- Graph: List versions --------------------

    private sealed record DriveItemVersionInfo(string Id, string? LastModifiedDateTime);

    private static async Task<List<DriveItemVersionInfo>> ListVersionsAsync(string token, string driveId, string driveItemId)
    {
        // GET /drives/{driveId}/items/{itemId}/versions
        var url = $"{GraphBase}/drives/{driveId}/items/{driveItemId}/versions?$select=id,lastModifiedDateTime";
        using var http = CreateHttp(token);

        var json = await SendJsonWithRetryAsync(http, HttpMethod.Get, url);
        using var doc = JsonDocument.Parse(json);

        var list = new List<DriveItemVersionInfo>();
        foreach (var v in doc.RootElement.GetProperty("value").EnumerateArray())
        {
            var id = v.GetProperty("id").GetString() ?? "";
            var lmdt = v.TryGetProperty("lastModifiedDateTime", out var dt) ? dt.GetString() : null;
            if (!string.IsNullOrWhiteSpace(id))
                list.Add(new DriveItemVersionInfo(id, lmdt));
        }

        return list;
    }
}