public CompressionResult Compress(string originalFileName, string compressedFileName)
        {
            var builder = new CompressionResultBuilder(CompressionMode.Compress);

            _progress.Reset();

            var sw = Stopwatch.StartNew();

            try
            {
                if (!File.Exists(originalFileName))
                {
                    throw new OperationFailedException(ErrorCode.FileDoesNotExist);
                }

                var fileName = compressedFileName.Split(Path.DirectorySeparatorChar).LastOrDefault();
                if (compressedFileName.Any(c => Path.GetInvalidPathChars().Contains(c)) ||
                    string.IsNullOrEmpty(fileName) ||
                    fileName.Any(c => Path.GetInvalidFileNameChars().Contains(c)))
                {
                    throw new OperationFailedException(ErrorCode.InvalidFileName);
                }

                using (var originalFile = new FileStream(originalFileName, FileMode.Open))
                using (var compressedFile = new FileStream(compressedFileName, FileMode.Create))
                {
                    builder.SetInputFileInfo(originalFileName, originalFile.Length);

                    Exception internalException = null;
                    Action<Exception> onException = exception => internalException = exception;

                    using (var writer = CreateChunkWriter(compressedFile, CompressionMode.Compress, onException))
                    using (var compressor = CreateCompressor(writer, Environment.ProcessorCount, CompressionMode.Compress, onException))
                    {
                        var buffer = new byte[ChunkSize];

                        var position = 0L;
                        var readCount = originalFile.Read(buffer, 0, ChunkSize);
                        while (readCount > 0)
                        {
                            if (internalException != null)
                            {
                                writer.Cancel();
                                compressor.Cancel();

                                throw internalException;
                            }

                            compressor.Enqueue(new Chunk(position, buffer.Take(readCount).ToArray()));
                            position = originalFile.Position;
                            readCount = originalFile.Read(buffer, 0, ChunkSize);

                            _progress.SetProgress(CalculateProgress(originalFile.Position, originalFile.Length));
                            builder.SetOutputFileInfo(compressedFileName, compressedFile.Length);
                        }
                    }
                }
            }
            catch (Exception e)
            {
                builder.SetException(e);
            }

            builder.SetLeadTime(sw.Elapsed);

            return builder.Result;
        }