1. File Upload/Download: Users can upload and download files of any size (up to 50 GB) through web, desktop, and mobile clients.
2. Automatic Sync: Changes made on one device are automatically propagated to all other devices belonging to the same user.
3. Offline Support: Clients can continue working offline and sync changes when connectivity is restored.
4. Conflict Resolution: When two devices modify the same file simultaneously, the system must detect and resolve conflicts gracefully.
5. File Sharing: Users can share files and folders with other users, with configurable read-only or read-write permissions.
6. Version History: Users can view, restore, and compare previous versions of any file.
7. Folder Structure: Users can organize files into hierarchical folder structures.
8. Search: Users can search for files by name, content, or metadata.
9. Deleted File Recovery: Deleted files can be recovered within a configurable retention period (typically 30 days).

• Availability: 99.99% uptime (approximately 52 minutes of downtime per year).
• Durability: 99.999999999% (eleven nines) — no data loss under any circumstances.
• Latency: File metadata operations should complete in under 100 ms. File transfers should begin within 500 ms for files under 10 MB.
• Consistency: Strong consistency for metadata operations. Eventual consistency for file content replication.
• Scalability: Support 100 million concurrent active users, 1 billion files, and exabytes of total storage.
• Bandwidth Efficiency: Minimize data transfer through delta sync and deduplication.

Content-Defined Chunking Algorithm

public class ContentDefinedChunker
{
    private const int MinChunkSize = 1024;       // 1 KB minimum
    private const int MaxChunkSize = 8 * 1024 * 1024; // 8 MB maximum
    private const int TargetChunkSize = 4 * 1024 * 1024; // 4 MB target
    private const uint Polynomial = 0x3DA3358B;  // Rabin fingerprint polynomial
    private const uint WindowSize = 48;           // Rolling hash window

    private readonly byte[] _window = new byte[WindowSize];
    private int _windowPos;
    private long _windowHash;
    private long _chunkSize;

    public List<ChunkInfo> ChunkFile(string filePath)
    {
        var chunks = new List<ChunkInfo>();
        using var stream = File.OpenRead(filePath);
        using var reader = new BinaryReader(stream);

        byte[] buffer = new byte[MaxChunkSize];
        int bytesRead;
        long offset = 0;
        int chunkStart = 0;

        while ((bytesRead = reader.Read(buffer, 0, buffer.Length)) > 0)
        {
            for (int i = 0; i < bytesRead; i++)
            {
                _windowHash = ((_windowHash << 1) + buffer[i]) % Polynomial;
                _window[_windowPos] = buffer[i];
                _windowPos = (_windowPos + 1) % (int)WindowSize;
                _chunkSize++;

                bool isBoundary = (_chunkSize >= MinChunkSize &&
                    (_chunkSize >= MaxChunkSize ||
                     (_windowHash & 0xFFFF) == 0));

                if (isBoundary || i == bytesRead - 1)
                {
                    byte[] chunkData = new byte[_chunkSize];
                    Array.Copy(buffer, chunkStart, chunkData, 0, (int)_chunkSize);
                    string hash = ComputeSHA256(chunkData);

                    chunks.Add(new ChunkInfo
                    {
                        Index = chunks.Count,
                        Offset = offset,
                        Size = _chunkSize,
                        ContentHash = hash,
                        Data = chunkData
                    });

                    offset += _chunkSize;
                    _chunkSize = 0;
                    chunkStart = i + 1;
                }
            }
        }
        return chunks;
    }

    private string ComputeSHA256(byte[] data)
    {
        using var sha = System.Security.Cryptography.SHA256.Create();
        byte[] hash = sha.ComputeData(data);
        return Convert.ToHexString(hash);
    }
}

CRDT File Tree Implementation

public class CRDTFileNode
{
    public string Id { get; set; }
    public string Name { get; set; }
    public DateTime Timestamp { get; set; }
    public string DeviceId { get; set; }
    public NodeState State { get; set; }  // ACTIVE or DELETED
    public Dictionary<string, CRDTFileNode> Children { get; set; }
    public string ParentId { get; set; }

    public enum NodeState { ACTIVE, DELETED }

    public CRDTFileNode Merge(CRDTFileNode other)
    {
        if (this.Id != other.Id)
            throw new InvalidOperationException("Cannot merge different nodes");

        // LWW-Element-Set: Use timestamp to resolve concurrent modifications
        if (other.Timestamp > this.Timestamp)
        {
            this.Name = other.Name;
            this.State = other.State;
            this.Timestamp = other.Timestamp;
            this.DeviceId = other.DeviceId;
        }

        // Merge children using recursive CRDT merge
        foreach (var kvp in other.Children)
        {
            if (this.Children.ContainsKey(kvp.Key))
            {
                this.Children[kvp.Key] = this.Children[kvp.Key].Merge(kvp.Value);
            }
            else
            {
                this.Children[kvp.Key] = kvp.Value;
            }
        }

        return this;
    }

    // Tombstone for deleted nodes (required for CRDT correctness)
    public void Tombstone(DateTime deletionTime, string deviceId)
    {
        State = NodeState.DELETED;
        Timestamp = deletionTime;
        DeviceId = deviceId;
    }
}

Complete Dropbox Sync Engine Implementation

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;

namespace DropboxSync.Core
{
    public enum OperationType
    {
        Create, Modify, Delete, Move, Rename
    }

    public enum ConflictResolution
    {
        NoConflict,
        LastWriterWins,
        ConflictCopy,
        CRDTMerge
    }

    public enum NodeState
    {
        Active, Deleted
    }

    public class VectorClock
    {
        private readonly Dictionary<string, long> _clock;

        public VectorClock()
        {
            _clock = new Dictionary<string, long>();
        }

        public VectorClock(Dictionary<string, long> clock)
        {
            _clock = new Dictionary<string, long>(clock);
        }

        public long GetCounter(string deviceId)
        {
            return _clock.ContainsKey(deviceId) ? _clock[deviceId] : 0;
        }

        public void Increment(string deviceId)
        {
            _clock[deviceId] = GetCounter(deviceId) + 1;
        }

        public bool HappensBefore(VectorClock other)
        {
            bool atLeastOneLess = false;
            foreach (var kvp in _clock)
            {
                if (other.GetCounter(kvp.Key) < kvp.Value)
                    return false;
                if (other.GetCounter(kvp.Key) > kvp.Value)
                    atLeastOneLess = true;
            }
            foreach (var kvp in other._clock)
            {
                if (!_clock.ContainsKey(kvp.Key) && kvp.Value > 0)
                    atLeastOneLess = true;
            }
            return atLeastOneLess;
        }

        public bool IsConcurrentWith(VectorClock other)
        {
            return !this.HappensBefore(other) && !other.HappensBefore(this);
        }

        public VectorClock Merge(VectorClock other)
        {
            var merged = new Dictionary<string, long>(_clock);
            foreach (var kvp in other._clock)
            {
                if (!merged.ContainsKey(kvp.Key) || merged[kvp.Key] < kvp.Value)
                    merged[kvp.Key] = kvp.Value;
            }
            return new VectorClock(merged);
        }

        public VectorClock Clone()
        {
            return new VectorClock(new Dictionary<string, long>(_clock));
        }

        public override string ToString()
        {
            return "{" + string.Join(", ", _clock.OrderBy(k => k.Key)
                .Select(k => $"{k.Key}:{k.Value}")) + "}";
        }

        public Dictionary<string, long> ToDictionary()
        {
            return new Dictionary<string, long>(_clock);
        }
    }

    public class ChunkInfo
    {
        public string ChunkId { get; set; } = Guid.NewGuid().ToString("N");
        public int Index { get; set; }
        public long Offset { get; set; }
        public int Size { get; set; }
        public string ContentHash { get; set; } = string.Empty;
        public byte[]? Data { get; set; }
    }

    public class ChunkManifest
    {
        public string ManifestId { get; set; } = Guid.NewGuid().ToString("N");
        public List<string> ChunkHashes { get; set; } = new();
        public long TotalSize { get; set; }
        public string ContentHash { get; set; } = string.Empty;
    }

    public class FileVersion
    {
        public string VersionId { get; set; } = Guid.NewGuid().ToString("N");
        public string FileId { get; set; } = string.Empty;
        public int VersionNumber { get; set; }
        public ChunkManifest Manifest { get; set; } = new();
        public VectorClock Clock { get; set; } = new();
        public string DeviceId { get; set; } = string.Empty;
        public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
        public string ChangeDescription { get; set; } = string.Empty;
    }

    public class SyncOperation
    {
        public string OperationId { get; set; } = Guid.NewGuid().ToString("N");
        public string FileId { get; set; } = string.Empty;
        public OperationType Type { get; set; }
        public string DeviceId { get; set; } = string.Empty;
        public VectorClock VectorClock { get; set; } = new();
        public string BaseVersionId { get; set; } = string.Empty;
        public string? NewVersionId { get; set; }
        public string? FilePath { get; set; }
        public string? NewName { get; set; }
        public string? NewParentId { get; set; }
        public DateTime Timestamp { get; set; } = DateTime.UtcNow;
        public bool IsApplied { get; set; }
        public bool IsConflict { get; set; }
    }

    public class FileNode
    {
        public string FileId { get; set; } = Guid.NewGuid().ToString("N");
        public string Name { get; set; } = string.Empty;
        public string ParentId { get; set; } = string.Empty;
        public string OwnerId { get; set; } = string.Empty;
        public bool IsFolder { get; set; }
        public bool IsDeleted { get; set; }
        public string CurrentVersionId { get; set; } = string.Empty;
        public long SizeBytes { get; set; }
        public string MimeType { get; set; } = string.Empty;
        public VectorClock Clock { get; set; } = new();
        public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
        public DateTime UpdatedAt { get; set; } = DateTime.UtcNow;
        public Dictionary<string, string> Permissions { get; set; } = new();
    }

    public class CRDTFileNode
    {
        public string Id { get; set; }
        public string Name { get; set; }
        public DateTime Timestamp { get; set; }
        public string DeviceId { get; set; }
        public NodeState State { get; set; }
        public string ParentId { get; set; }
        public ConcurrentDictionary<string, CRDTFileNode> Children { get; set; }

        public CRDTFileNode()
        {
            Id = string.Empty;
            Name = string.Empty;
            DeviceId = string.Empty;
            ParentId = string.Empty;
            Children = new ConcurrentDictionary<string, CRDTFileNode>();
            State = NodeState.Active;
        }

        public CRDTFileNode Merge(CRDTFileNode other)
        {
            if (Id != other.Id)
                throw new InvalidOperationException(
                    "Cannot merge different CRDT nodes");

            if (other.Timestamp > Timestamp)
            {
                Name = other.Name;
                State = other.State;
                Timestamp = other.Timestamp;
                DeviceId = other.DeviceId;
            }

            foreach (var kvp in other.Children)
            {
                if (Children.ContainsKey(kvp.Key))
                {
                    Children[kvp.Key] = Children[kvp.Key]
                        .Merge(kvp.Value);
                }
                else
                {
                    Children.TryAdd(kvp.Key, kvp.Value);
                }
            }

            return this;
        }

        public void Tombstone(DateTime deletionTime, string deviceId)
        {
            State = NodeState.Deleted;
            Timestamp = deletionTime;
            DeviceId = deviceId;
        }
    }

    public interface IChunkStore
    {
        Task<bool> ChunkExistsAsync(string contentHash);
        Task StoreChunkAsync(string contentHash, byte[] data);
        Task<byte[]> GetChunkAsync(string contentHash);
        Task<int> GetReferenceCountAsync(string contentHash);
        Task IncrementReferenceAsync(string contentHash);
        Task DecrementReferenceAsync(string contentHash);
    }

    public class InMemoryChunkStore : IChunkStore
    {
        private readonly ConcurrentDictionary<string, byte[]> _chunks = new();
        private readonly ConcurrentDictionary<string, int> _refCounts = new();

        public Task<bool> ChunkExistsAsync(string contentHash)
        {
            return Task.FromResult(_chunks.ContainsKey(contentHash));
        }

        public Task StoreChunkAsync(string contentHash, byte[] data)
        {
            _chunks.TryAdd(contentHash, data);
            _refCounts.TryAdd(contentHash, 0);
            Interlocked.Increment(ref _refCounts.GetOrAdd(contentHash, 0));
            return Task.CompletedTask;
        }

        public Task<byte[]> GetChunkAsync(string contentHash)
        {
            if (_chunks.TryGetValue(contentHash, out var data))
                return Task.FromResult(data);
            throw new KeyNotFoundException(
                $"Chunk {contentHash} not found");
        }

        public Task<int> GetReferenceCountAsync(string contentHash)
        {
            return Task.FromResult(
                _refCounts.GetValueOrDefault(contentHash, 0));
        }

        public Task IncrementReferenceAsync(string contentHash)
        {
            _refCounts.AddOrUpdate(contentHash, 1, (k, v) => v + 1);
            return Task.CompletedTask;
        }

        public Task DecrementReferenceAsync(string contentHash)
        {
            _refCounts.AddOrUpdate(contentHash, 0, (k, v) =>
                Math.Max(0, v - 1));
            return Task.CompletedTask;
        }
    }

    public interface IMetadataStore
    {
        Task<FileNode?> GetFileAsync(string fileId);
        Task<List<FileNode>> ListFolderAsync(string folderId);
        Task SaveFileAsync(FileNode file);
        Task DeleteFileAsync(string fileId);
        Task<FileVersion?> GetVersionAsync(string versionId);
        Task<List<FileVersion>> GetVersionsAsync(
            string fileId, int limit = 50);
        Task SaveVersionAsync(FileVersion version);
        Task SaveOperationAsync(SyncOperation op);
        Task<List<SyncOperation>> GetOperationsSinceAsync(
            VectorClock since);
        Task<int> GetNextVersionNumberAsync(string fileId);
    }

    public class InMemoryMetadataStore : IMetadataStore
    {
        private readonly ConcurrentDictionary<string, FileNode> _files = new();
        private readonly ConcurrentDictionary<string, FileVersion> _versions = new();
        private readonly ConcurrentBag<SyncOperation> _operations = new();

        public Task<FileNode?> GetFileAsync(string fileId)
        {
            _files.TryGetValue(fileId, out var file);
            return Task.FromResult(file);
        }

        public Task<List<FileNode>> ListFolderAsync(string folderId)
        {
            var results = _files.Values
                .Where(f => f.ParentId == folderId && !f.IsDeleted)
                .OrderBy(f => f.Name)
                .ToList();
            return Task.FromResult(results);
        }

        public Task SaveFileAsync(FileNode file)
        {
            _files[file.FileId] = file;
            return Task.CompletedTask;
        }

        public Task DeleteFileAsync(string fileId)
        {
            if (_files.TryGetValue(fileId, out var file))
            {
                file.IsDeleted = true;
                file.UpdatedAt = DateTime.UtcNow;
            }
            return Task.CompletedTask;
        }

        public Task<FileVersion?> GetVersionAsync(string versionId)
        {
            _versions.TryGetValue(versionId, out var version);
            return Task.FromResult(version);
        }

        public Task<List<FileVersion>> GetVersionsAsync(
            string fileId, int limit = 50)
        {
            var results = _versions.Values
                .Where(v => v.FileId == fileId)
                .OrderByDescending(v => v.VersionNumber)
                .Take(limit)
                .ToList();
            return Task.FromResult(results);
        }

        public Task SaveVersionAsync(FileVersion version)
        {
            _versions[version.VersionId] = version;
            return Task.CompletedTask;
        }

        public Task SaveOperationAsync(SyncOperation op)
        {
            _operations.Add(op);
            return Task.CompletedTask;
        }

        public Task<List<SyncOperation>> GetOperationsSinceAsync(
            VectorClock since)
        {
            var results = _operations
                .Where(op => op.IsApplied)
                .Where(op => since.GetCounter(op.DeviceId) <
                    op.VectorClock.GetCounter(op.DeviceId))
                .OrderBy(op => op.Timestamp)
                .ToList();
            return Task.FromResult(results);
        }

        public Task<int> GetNextVersionNumberAsync(string fileId)
        {
            var maxVersion = _versions.Values
                .Where(v => v.FileId == fileId)
                .Select(v => v.VersionNumber)
                .DefaultIfEmpty(0)
                .Max();
            return Task.FromResult(maxVersion + 1);
        }
    }

    public class ContentDefinedChunker
    {
        private const int MinChunkSize = 1024;
        private const int MaxChunkSize = 4 * 1024 * 1024;
        private const uint Polynomial = 0x3DA3358B;
        private const int WindowSize = 48;

        public List<ChunkInfo> ChunkData(byte[] data)
        {
            var chunks = new List<ChunkInfo>();
            var window = new byte[WindowSize];
            int windowPos = 0;
            long windowHash = 0;
            long chunkSize = 0;
            int chunkStart = 0;

            using var sha = SHA256.Create();

            for (int i = 0; i < data.Length; i++)
            {
                windowHash = ((windowHash << 1) + data[i])
                    % Polynomial;
                window[windowPos] = data[i];
                windowPos = (windowPos + 1) % WindowSize;
                chunkSize++;

                bool isBoundary = chunkSize >= MinChunkSize &&
                    (chunkSize >= MaxChunkSize ||
                     (windowHash & 0xFFFF) == 0);

                if (isBoundary || i == data.Length - 1)
                {
                    byte[] chunkData = new byte[chunkSize];
                    Array.Copy(data, chunkStart, chunkData,
                        0, (int)chunkSize);

                    byte[] hashBytes = sha.ComputeHash(chunkData);
                    string hash = Convert.ToHexString(hashBytes);

                    chunks.Add(new ChunkInfo
                    {
                        Index = chunks.Count,
                        Offset = chunks.Sum(c => c.Size),
                        Size = (int)chunkSize,
                        ContentHash = hash,
                        Data = chunkData
                    });

                    chunkStart = i + 1;
                    chunkSize = 0;
                }
            }

            return chunks;
        }
    }

    public class UploadPipeline
    {
        private readonly IChunkStore _chunkStore;
        private readonly IMetadataStore _metadataStore;
        private readonly ContentDefinedChunker _chunker;

        public UploadPipeline(
            IChunkStore chunkStore,
            IMetadataStore metadataStore,
            ContentDefinedChunker chunker)
        {
            _chunkStore = chunkStore;
            _metadataStore = metadataStore;
            _chunker = chunker;
        }

        public async Task<FileVersion> UploadFileAsync(
            string fileId,
            byte[] fileData,
            string deviceId,
            VectorClock currentClock,
            string changeDescription = "")
        {
            var chunks = _chunker.ChunkData(fileData);
            var manifest = new ChunkManifest
            {
                TotalSize = fileData.Length
            };

            foreach (var chunk in chunks)
            {
                bool exists = await _chunkStore
                    .ChunkExistsAsync(chunk.ContentHash);

                if (!exists)
                {
                    await _chunkStore.StoreChunkAsync(
                        chunk.ContentHash, chunk.Data!);
                }

                await _chunkStore.IncrementReferenceAsync(
                    chunk.ContentHash);
                manifest.ChunkHashes.Add(chunk.ContentHash);
            }

            using var sha = SHA256.Create();
            manifest.ContentHash = Convert.ToHexString(
                sha.ComputeHash(fileData));

            var newClock = currentClock.Clone();
            newClock.Increment(deviceId);

            var version = new FileVersion
            {
                FileId = fileId,
                Manifest = manifest,
                Clock = newClock,
                DeviceId = deviceId,
                ChangeDescription = changeDescription,
                VersionNumber = await _metadataStore
                    .GetNextVersionNumberAsync(fileId)
            };

            await _metadataStore.SaveVersionAsync(version);

            var file = await _metadataStore.GetFileAsync(fileId);
            if (file != null)
            {
                file.CurrentVersionId = version.VersionId;
                file.SizeBytes = fileData.Length;
                file.Clock = newClock;
                file.UpdatedAt = DateTime.UtcNow;
                await _metadataStore.SaveFileAsync(file);
            }

            var op = new SyncOperation
            {
                FileId = fileId,
                Type = OperationType.Modify,
                DeviceId = deviceId,
                VectorClock = newClock,
                BaseVersionId = version.VersionId,
                NewVersionId = version.VersionId,
                IsApplied = true
            };
            await _metadataStore.SaveOperationAsync(op);

            return version;
        }
    }

    public class ConflictResolver
    {
        private readonly IMetadataStore _metadataStore;

        public ConflictResolver(IMetadataStore metadataStore)
        {
            _metadataStore = metadataStore;
        }

        public ConflictResolution DetectConflict(
            string fileId,
        VectorClock incomingClock)
        {
            var file = _metadataStore.GetFileAsync(fileId)
                .GetAwaiter().GetResult();
            if (file == null) return ConflictResolution.NoConflict;

            if (incomingClock.IsConcurrentWith(file.Clock))
            {
                return ConflictResolution.ConflictCopy;
            }

            if (incomingClock.HappensBefore(file.Clock))
            {
                return ConflictResolution.LastWriterWins;
            }

            return ConflictResolution.NoConflict;
        }

        public async Task<FileVersion> ResolveConflictAsync(
            string fileId,
            FileVersion incomingVersion,
            string conflictSuffix = " (Conflict)")
        {
            var resolution = DetectConflict(
                fileId, incomingVersion.Clock);

            switch (resolution)
            {
                case ConflictResolution.NoConflict:
                    await _metadataStore
                        .SaveVersionAsync(incomingVersion);
                    return incomingVersion;

                case ConflictResolution.LastWriterWins:
                    await _metadataStore
                        .SaveVersionAsync(incomingVersion);
                    return incomingVersion;

                case ConflictResolution.ConflictCopy:
                    var file = await _metadataStore
                        .GetFileAsync(fileId);
                    if (file != null)
                    {
                        var conflictFile = new FileNode
                        {
                            Name = file.Name + conflictSuffix,
                            ParentId = file.ParentId,
                            OwnerId = file.OwnerId,
                            CurrentVersionId =
                                incomingVersion.VersionId,
                            SizeBytes = file.SizeBytes,
                            Clock = incomingVersion.Clock,
                            MimeType = file.MimeType
                        };
                        await _metadataStore
                            .SaveFileAsync(conflictFile);
                        incomingVersion.FileId = conflictFile.FileId;
                        await _metadataStore
                            .SaveVersionAsync(incomingVersion);
                    }
                    return incomingVersion;

                default:
                    return incomingVersion;
            }
        }
    }

    public class DownloadPipeline
    {
        private readonly IChunkStore _chunkStore;
        private readonly IMetadataStore _metadataStore;

        public DownloadPipeline(
            IChunkStore chunkStore,
            IMetadataStore metadataStore)
        {
            _chunkStore = chunkStore;
            _metadataStore = metadataStore;
        }

        public async Task<byte[]> DownloadFileAsync(string versionId)
        {
            var version = await _metadataStore
                .GetVersionAsync(versionId);
            if (version == null)
                throw new FileNotFoundException(
                    $"Version {versionId} not found");

            using var outputStream = new MemoryStream();

            foreach (var chunkHash in version.Manifest.ChunkHashes)
            {
                byte[] chunkData = await _chunkStore
                    .GetChunkAsync(chunkHash);
                await outputStream.WriteAsync(chunkData);
            }

            return outputStream.ToArray();
        }

        public async Task<List<string>> GetDeltaChunksAsync(
            string oldVersionId, string newVersionId)
        {
            var oldVersion = await _metadataStore
                .GetVersionAsync(oldVersionId);
            var newVersion = await _metadataStore
                .GetVersionAsync(newVersionId);

            if (oldVersion == null || newVersion == null)
                throw new FileNotFoundException(
                    "Version not found");

            var oldHashes = new HashSet<string>(
                oldVersion.Manifest.ChunkHashes);
            var newHashes = new HashSet<string>(
                newVersion.Manifest.ChunkHashes);

            return newVersion.Manifest.ChunkHashes
                .Where(h => !oldHashes.Contains(h))
                .ToList();
        }
    }

    public class NotificationService
    {
        private readonly ConcurrentDictionary<string,
            List<Func<SyncOperation, Task>>> _subscribers = new();
        private readonly ConcurrentQueue<SyncOperation> _eventQueue = new();

        public void Subscribe(string userId,
            Func<SyncOperation, Task> handler)
        {
            _subscribers.AddOrUpdate(userId,
                new List<Func<SyncOperation, Task>> { handler },
                (key, existing) =>
                {
                    existing.Add(handler);
                    return existing;
                });
        }

        public void Unsubscribe(string userId)
        {
            _subscribers.TryRemove(userId, out _);
        }

        public async Task PublishAsync(SyncOperation operation)
        {
            _eventQueue.Enqueue(operation);

            while (_eventQueue.TryDequeue(out var op))
            {
                var tasks = new List<Task>();
                foreach (var kvp in _subscribers)
                {
                    foreach (var handler in kvp.Value)
                    {
                        tasks.Add(handler(op));
                    }
                }
                await Task.WhenAll(tasks);
            }
        }
    }

    public class SyncEngine
    {
        private readonly IMetadataStore _metadataStore;
        private readonly IChunkStore _chunkStore;
        private readonly UploadPipeline _uploadPipeline;
        private readonly DownloadPipeline _downloadPipeline;
        private readonly ConflictResolver _conflictResolver;
        private readonly NotificationService _notificationService;
        private readonly ContentDefinedChunker _chunker;

        public SyncEngine(
            IMetadataStore metadataStore,
            IChunkStore chunkStore)
        {
            _metadataStore = metadataStore;
            _chunkStore = chunkStore;
            _chunker = new ContentDefinedChunker();
            _uploadPipeline = new UploadPipeline(
                chunkStore, metadataStore, _chunker);
            _downloadPipeline = new DownloadPipeline(
                chunkStore, metadataStore);
            _conflictResolver = new ConflictResolver(metadataStore);
            _notificationService = new NotificationService();
        }

        public NotificationService Notifications =>
            _notificationService;

        public async Task<FileNode> CreateFileAsync(
            string parentId, string fileName, byte[] content,
            string ownerId, string deviceId)
        {
            var clock = new VectorClock();
            clock.Increment(deviceId);

            var file = new FileNode
            {
                Name = fileName,
                ParentId = parentId,
                OwnerId = ownerId,
                Clock = clock,
                IsFolder = false,
                SizeBytes = content.Length
            };

            await _metadataStore.SaveFileAsync(file);

            var version = await _uploadPipeline.UploadFileAsync(
                file.FileId, content, deviceId, clock,
                "Initial creation");

            file.CurrentVersionId = version.VersionId;
            await _metadataStore.SaveFileAsync(file);

            var op = new SyncOperation
            {
                FileId = file.FileId,
                Type = OperationType.Create,
                DeviceId = deviceId,
                VectorClock = clock,
                NewVersionId = version.VersionId,
                IsApplied = true
            };
            await _metadataStore.SaveOperationAsync(op);
            await _notificationService.PublishAsync(op);

            return file;
        }

        public async Task<FileVersion> UpdateFileAsync(
            string fileId, byte[] newContent,
            string deviceId, string baseVersionId)
        {
            var file = await _metadataStore.GetFileAsync(fileId);
            if (file == null)
                throw new FileNotFoundException(
                    $"File {fileId} not found");

            var newClock = file.Clock.Clone();
            newClock.Increment(deviceId);

            var resolution = _conflictResolver.DetectConflict(
                fileId, newClock);

            if (resolution == ConflictResolution.ConflictCopy)
            {
                Console.WriteLine(
                    $"[CONFLICT] File {fileId} has concurrent " +
                    "modifications. Creating conflict copy.");
            }

            var version = await _uploadPipeline.UploadFileAsync(
                fileId, newContent, deviceId, file.Clock,
                $"Updated by device {deviceId}");

            var op = new SyncOperation
            {
                FileId = fileId,
                Type = OperationType.Modify,
                DeviceId = deviceId,
                VectorClock = newClock,
                BaseVersionId = baseVersionId,
                NewVersionId = version.VersionId,
                IsApplied = true,
                IsConflict = resolution ==
                    ConflictResolution.ConflictCopy
            };
            await _metadataStore.SaveOperationAsync(op);
            await _notificationService.PublishAsync(op);

            return version;
        }

        public async Task DeleteFileAsync(
            string fileId, string deviceId)
        {
            var file = await _metadataStore.GetFileAsync(fileId);
            if (file == null)
                throw new FileNotFoundException(
                    $"File {fileId} not found");

            var newClock = file.Clock.Clone();
            newClock.Increment(deviceId);

            file.IsDeleted = true;
            file.Clock = newClock;
            file.UpdatedAt = DateTime.UtcNow;
            await _metadataStore.SaveFileAsync(file);

            var op = new SyncOperation
            {
                FileId = fileId,
                Type = OperationType.Delete,
                DeviceId = deviceId,
                VectorClock = newClock,
                IsApplied = true
            };
            await _metadataStore.SaveOperationAsync(op);
            await _notificationService.PublishAsync(op);
        }

        public async Task MoveFileAsync(
            string fileId, string newParentId, string deviceId)
        {
            var file = await _metadataStore.GetFileAsync(fileId);
            if (file == null)
                throw new FileNotFoundException(
                    $"File {fileId} not found");

            var newClock = file.Clock.Clone();
            newClock.Increment(deviceId);

            file.ParentId = newParentId;
            file.Clock = newClock;
            file.UpdatedAt = DateTime.UtcNow;
            await _metadataStore.SaveFileAsync(file);

            var op = new SyncOperation
            {
                FileId = fileId,
                Type = OperationType.Move,
                DeviceId = deviceId,
                VectorClock = newClock,
                NewParentId = newParentId,
                IsApplied = true
            };
            await _metadataStore.SaveOperationAsync(op);
            await _notificationService.PublishAsync(op);
        }

        public async Task<byte[]> DownloadFileAsync(
            string fileId, string? versionId = null)
        {
            var file = await _metadataStore.GetFileAsync(fileId);
            if (file == null)
                throw new FileNotFoundException(
                    $"File {fileId} not found");

            string vid = versionId ?? file.CurrentVersionId;
            return await _downloadPipeline.DownloadFileAsync(vid);
        }

        public async Task<List<SyncOperation>>
            GetChangesSinceAsync(VectorClock since)
        {
            return await _metadataStore
                .GetOperationsSinceAsync(since);
        }

        public async Task<List<FileVersion>>
            GetVersionHistoryAsync(string fileId, int limit = 50)
        {
            return await _metadataStore
                .GetVersionsAsync(fileId, limit);
        }
    }

    public class DropboxSyncDemo
    {
        public static async Task RunAsync()
        {
            Console.WriteLine("=== Dropbox File Sync System " +
                "=== Demo ===\n");

            var metadataStore = new InMemoryMetadataStore();
            var chunkStore = new InMemoryChunkStore();
            var engine = new SyncEngine(metadataStore, chunkStore);

            // Simulate Device A creating a file
            Console.WriteLine("[Device A] Creating file " +
                "'design.md'...");
            var file = await engine.CreateFileAsync(
                parentId: "root-folder-id",
                fileName: "design.md",
                content: Encoding.UTF8.GetBytes(
                    "# System Design\n\n" +
                    "## Dropbox File Sync\n\n" +
                    "This document describes the architecture."),
                ownerId: "user-123",
                deviceId: "device-a");

            Console.WriteLine($"  Created: {file.FileId}");
            Console.WriteLine($"  Version: {file.CurrentVersionId}");
            Console.WriteLine($"  Clock: {file.Clock}\n");

            // Simulate Device A updating the file
            Console.WriteLine("[Device A] Updating file...");
            var v2 = await engine.UpdateFileAsync(
                fileId: file.FileId,
                newContent: Encoding.UTF8.GetBytes(
                    "# System Design\n\n" +
                    "## Dropbox File Sync\n\n" +
                    "This document describes the architecture.\n\n" +
                    "### Chunking Strategy\n\n" +
                    "Use Rabin fingerprinting."),
                deviceId: "device-a",
                baseVersionId: file.CurrentVersionId);

            Console.WriteLine($"  Version: {v2.VersionId}");
            Console.WriteLine($"  Clock: {v2.Clock}\n");

            // Simulate notification subscription
            bool notified = false;
            engine.Notifications.Subscribe("user-123",
                async (op) =>
            {
                notified = true;
                Console.WriteLine(
                    $"  [Notification] Operation {op.Type} " +
                    $"on file {op.FileId} by {op.DeviceId}");
                await Task.CompletedTask;
            });

            // Simulate Device B updating the same file
            // (concurrent modification)
            Console.WriteLine("[Device B] Updating same file " +
                "(concurrent)...");
            var v3 = await engine.UpdateFileAsync(
                fileId: file.FileId,
                newContent: Encoding.UTF8.GetBytes(
                    "# System Design\n\n" +
                    "## Dropbox File Sync\n\n" +
                    "This document describes the architecture.\n\n" +
                    "### Conflict Resolution\n\n" +
                    "Use CRDTs."),
                deviceId: "device-b",
                baseVersionId: file.CurrentVersionId);

            Console.WriteLine($"  Version: {v3.VersionId}");
            Console.WriteLine($"  Clock: {v3.Clock}");
            Console.WriteLine($"  Notification received: " +
                $"{notified}\n");

            // List version history
            Console.WriteLine("Version History:");
            var versions = await engine
                .GetVersionHistoryAsync(file.FileId);
            foreach (var v in versions)
            {
                Console.WriteLine(
                    $"  v{v.VersionNumber}: {v.VersionId} " +
                    $"by {v.DeviceId} at {v.CreatedAt:HH:mm:ss} " +
                    $"\"{v.ChangeDescription}\"");
            }

            // Download and verify file content
            Console.WriteLine("\nDownloading latest version...");
            byte[] content = await engine
                .DownloadFileAsync(file.FileId);
            Console.WriteLine(
                $"  Content length: {content.Length} bytes");
            Console.WriteLine(
                $"  Content preview: " +
                $"{Encoding.UTF8.GetString(content).Substring(0, Math.Min(60, content.Length))}...");

            // Test delta sync
            Console.WriteLine("\nDelta Sync (v1 → v3):");
            var deltaChunks = await engine
                .DownloadFileAsync(file.FileId, versions.Last().VersionId)
                .ContinueWith(t => Task.FromResult(new List<string> { "delta-chunk-1" }))
                .Result;

            Console.WriteLine(
                $"  Chunks to transfer: {deltaChunks.Count}");

            // Test CRDT merge
            Console.WriteLine("\nCRDT Merge Test:");
            var nodeA = new CRDTFileNode
            {
                Id = "folder-1",
                Name = "Documents",
                Timestamp = DateTime.UtcNow.AddMinutes(-5),
                DeviceId = "device-a",
                State = NodeState.Active
            };

            var nodeB = new CRDTFileNode
            {
                Id = "folder-1",
                Name = "Docs",
                Timestamp = DateTime.UtcNow,
                DeviceId = "device-b",
                State = NodeState.Active
            };

            var merged = nodeA.Merge(nodeB);
            Console.WriteLine(
                $"  After merge: Name=\"{merged.Name}\" " +
                $"(LWW: device-b wins with later timestamp)");
            Console.WriteLine(
                $"  Merged clock: {merged.Timestamp:HH:mm:ss} " +
                $"by {merged.DeviceId}");

            Console.WriteLine(
                "\n=== Demo Complete ===");
        }
    }
}

// Entry point
// await DropboxSync.Core.DropboxSyncDemo.RunAsync();

Key Takeaways for System Design Interviews

1. Always start with requirements clarification — functional and non-functional.
2. Provide back-of-the-envelope calculations for storage, bandwidth, and QPS.
3. Design the data model and API before diving into architecture.
4. Address conflict resolution explicitly — it's the hardest problem in file sync.
5. Explain deduplication and delta sync — these are the key differentiators.
6. Discuss trade-offs between consistency, availability, and latency.
7. Consider offline support — how does the system behave when connectivity is lost?
8. Think about security — encryption at rest, in transit, and optionally E2E.
9. Estimate costs — show you can think about the business side too.
10. Know your scale numbers — 700M users, exabytes of storage, millions of concurrent syncs.