public class PdfProcessor : IDocumentProcessor
{
    private readonly IOcrEngine _ocrEngine;
 
    public PdfProcessor(IOcrEngine ocrEngine)
    {
        _ocrEngine = ocrEngine ?? throw new ArgumentNullException(nameof(ocrEngine));
    }
 
    public async Task<WordDocument> ConvertToWordAsync(string pdfPath)
    {
        // Validate file exists and is a PDF
        if (!File.Exists(pdfPath) || !pdfPath.EndsWith(".pdf", StringComparison.OrdinalIgnoreCase))
            throw new ArgumentException("Invalid PDF file path", nameof(pdfPath));
 
        // Create PDF reader
        using var reader = new PdfReader(pdfPath);
        var document = new WordDocument();
 
        // Process each page
        for (int i = 1; i <= reader.NumberOfPages; i++)
        {
            var strategy = new SimpleTextExtractionStrategy();
            string text = PdfTextExtractor.GetTextFromPage(reader, i, strategy);
 
            // If minimal text was extracted, the page might be an image
            if (string.IsNullOrWhiteSpace(text) || text.Length < 50)
            {
                // Extract image and perform OCR
                var pageImage = ExtractPageAsImage(reader, i);
                text = await _ocrEngine.RecognizeTextAsync(pageImage);
            }
 
            // Add content to Word document
            document.AddPage(text, ExtractImages(reader, i));
        }
 
        return document;
    }
 
    private Bitmap ExtractPageAsImage(PdfReader reader, int pageNumber)
    {
        // Implementation to render PDF page as image
        // ...
    }
 
    private List<ImageData> ExtractImages(PdfReader reader, int pageNumber)
    {
        // Implementation to extract embedded images
        // ...
    }
}

public class TesseractOcrEngine : IOcrEngine
{
    private readonly TesseractEngine _engine;
 
    public TesseractOcrEngine(string dataPath, string language = "eng")
    {
        _engine = new TesseractEngine(dataPath, language, EngineMode.Default);
        _engine.SetVariable("tessedit_char_whitelist", "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.,;:!?()[]{}\"'`-–—/\\@#$%^&*+=<>|~_");
    }
 
    public async Task<string> RecognizeTextAsync(Bitmap image)
    {
        return await Task.Run(() => {
            // Pre-process image for better OCR results
            using var processedImage = PreprocessImage(image);
 
            // Perform OCR
            using var page = _engine.Process(processedImage);
            string text = page.GetText();
 
            // Post-process text to fix common OCR errors
            return PostprocessText(text);
        });
    }
 
    private Bitmap PreprocessImage(Bitmap original)
    {
        // Implementation of image preprocessing:
        // - Convert to grayscale
        // - Increase contrast
        // - Remove noise
        // - Deskew if needed
        // ...
    }
 
    private string PostprocessText(string text)
    {
        // Fix common OCR errors
        // - Correct 'rn' misrecognized as 'm'
        // - Fix common number/letter confusions (0/O, 1/I, etc.)
        // - Correct spacing issues
        // ...
 
        return text;
    }
}

public class WordDocumentGenerator : IDocumentGenerator
{
    public async Task<string> GenerateDocumentAsync(WordDocument document, string outputPath)
    {
        return await Task.Run(() => {
            using var wordDoc = WordprocessingDocument.Create(outputPath, WordprocessingDocumentType.Document);
 
            // Add main document part
            var mainPart = wordDoc.AddMainDocumentPart();
            mainPart.Document = new Document();
            var body = mainPart.Document.AppendChild(new Body());
 
            // Process each page
            foreach (var page in document.Pages)
            {
                // Add text with appropriate formatting
                var paragraph = new Paragraph();
                var run = new Run();
                var text = new Text(page.Content);
                run.AppendChild(text);
                paragraph.AppendChild(run);
                body.AppendChild(paragraph);
 
                // Add images
                foreach (var image in page.Images)
                {
                    AddImageToDocument(mainPart, body, image);
                }
            }
 
            // Save the document
            mainPart.Document.Save();
            return outputPath;
        });
    }
 
    private void AddImageToDocument(MainDocumentPart mainPart, Body body, ImageData image)
    {
        // Implementation to add images to the Word document
        // ...
    }
}

public class SpeechSynthesizer : ITextToSpeech
{
    private readonly System.Speech.Synthesis.SpeechSynthesizer _synthesizer;
    private readonly ConcurrentDictionary<string, SpeechPrompt> _promptCache;
 
    public SpeechSynthesizer()
    {
        _synthesizer = new System.Speech.Synthesis.SpeechSynthesizer();
        _promptCache = new ConcurrentDictionary<string, SpeechPrompt>();
 
        // Configure default settings
        _synthesizer.Rate = 0; // Normal speed
        _synthesizer.Volume = 100; // Maximum volume
    }
 
    public IEnumerable<VoiceInfo> GetAvailableVoices()
    {
        return _synthesizer.GetInstalledVoices()
            .Select(v => new VoiceInfo
            {
                Id = v.VoiceInfo.Id,
                Name = v.VoiceInfo.Name,
                Gender = v.VoiceInfo.Gender.ToString(),
                Age = v.VoiceInfo.Age.ToString(),
                Culture = v.VoiceInfo.Culture.Name
            });
    }
 
    public void SetVoice(string voiceId)
    {
        _synthesizer.SelectVoice(voiceId);
    }
 
    public void SetRate(int rate)
    {
        _synthesizer.Rate = Math.Clamp(rate, -10, 10);
    }
 
    public async Task<AudioData> SynthesizeSpeechAsync(string text)
    {
        // Check cache first
        if (_promptCache.TryGetValue(text, out var cachedPrompt))
            return cachedPrompt.AudioData;
 
        return await Task.Run(() => {
            using var stream = new MemoryStream();
            _synthesizer.SetOutputToWaveStream(stream);
 
            // Pre-process text for better pronunciation
            string processedText = PreprocessTextForSpeech(text);
 
            // Generate speech
            _synthesizer.Speak(processedText);
 
            // Create audio data with timing information
            var audioData = new AudioData
            {
                AudioBytes = stream.ToArray(),
                Format = new WaveFormat(22050, 16, 1),
                TextTimings = ExtractTimingInformation()
            };
 
            // Cache the result
            _promptCache.TryAdd(text, new SpeechPrompt { Text = text, AudioData = audioData });
 
            return audioData;
        });
    }
 
    private string PreprocessTextForSpeech(string text)
    {
        // Improve pronunciation of technical terms, abbreviations, etc.
        // ...
 
        return text;
    }
 
    private List<TextTiming> ExtractTimingInformation()
    {
        // Extract timing information for text-to-audio synchronization
        // ...
    }
}

<Window x:Class="PdfReader.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="PDF Reader with Audio Output" Height="600" Width="800">
    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="*"/>
            <RowDefinition Height="Auto"/>
        </Grid.RowDefinitions>
 
        <!-- Menu and toolbar -->
        <ToolBar Grid.Row="0">
            <Button Command="{Binding OpenFileCommand}" ToolTip="Open PDF">
                <Image Source="/Images/open.png" Width="16" Height="16"/>
            </Button>
            <Separator/>
            <Button Command="{Binding PlayCommand}" ToolTip="Play">
                <Image Source="/Images/play.png" Width="16" Height="16"/>
            </Button>
            <Button Command="{Binding PauseCommand}" ToolTip="Pause">
                <Image Source="/Images/pause.png" Width="16" Height="16"/>
            </Button>
            <Button Command="{Binding StopCommand}" ToolTip="Stop">
                <Image Source="/Images/stop.png" Width="16" Height="16"/>
            </Button>
            <Separator/>
            <ComboBox ItemsSource="{Binding AvailableVoices}" 
                      SelectedItem="{Binding SelectedVoice}"
                      Width="150"/>
            <Slider Minimum="-5" Maximum="5" Value="{Binding SpeechRate}"
                    Width="100" TickFrequency="1" IsSnapToTickEnabled="True"/>
        </ToolBar>
 
        <!-- Document viewer -->
        <FlowDocumentReader Grid.Row="1" Document="{Binding CurrentDocument}"/>
 
        <!-- Status bar -->
        <StatusBar Grid.Row="2">
            <TextBlock Text="{Binding StatusMessage}"/>
            <ProgressBar Width="100" Value="{Binding ProcessingProgress}"/>
        </StatusBar>
    </Grid>
</Window>

public class MainViewModel : INotifyPropertyChanged
{
    private readonly IDocumentProcessor _documentProcessor;
    private readonly ITextToSpeech _textToSpeech;
    private readonly IAudioPlayer _audioPlayer;
 
    private FlowDocument _currentDocument;
    private VoiceInfo _selectedVoice;
    private int _speechRate;
    private string _statusMessage;
    private double _processingProgress;
 
    // Commands
    public ICommand OpenFileCommand { get; }
    public ICommand PlayCommand { get; }
    public ICommand PauseCommand { get; }
    public ICommand StopCommand { get; }
 
    // Properties with change notification
    public FlowDocument CurrentDocument
    {
        get => _currentDocument;
        set
        {
            _currentDocument = value;
            OnPropertyChanged();
        }
    }
 
    public IEnumerable<VoiceInfo> AvailableVoices => _textToSpeech.GetAvailableVoices();
 
    public VoiceInfo SelectedVoice
    {
        get => _selectedVoice;
        set
        {
            _selectedVoice = value;
            _textToSpeech.SetVoice(value.Id);
            OnPropertyChanged();
        }
    }
 
    public int SpeechRate
    {
        get => _speechRate;
        set
        {
            _speechRate = value;
            _textToSpeech.SetRate(value);
            OnPropertyChanged();
        }
    }
 
    // Implementation of INotifyPropertyChanged
    public event PropertyChangedEventHandler PropertyChanged;
 
    protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
 
    // Command implementations
    private async void OpenFile()
    {
        var dialog = new OpenFileDialog
        {
            Filter = "PDF Files (*.pdf)|*.pdf",
            Title = "Select a PDF File"
        };
 
        if (dialog.ShowDialog() == true)
        {
            StatusMessage = "Processing document...";
            ProcessingProgress = 0;
 
            try
            {
                // Process the PDF in a background task
                var wordDoc = await _documentProcessor.ConvertToWordAsync(dialog.FileName);
 
                // Convert to FlowDocument for display
                CurrentDocument = ConvertToFlowDocument(wordDoc);
 
                StatusMessage = "Document ready";
                ProcessingProgress = 100;
            }
            catch (Exception ex)
            {
                StatusMessage = $"Error: {ex.Message}";
                ProcessingProgress = 0;
            }
        }
    }
 
    private async void Play()
    {
        if (CurrentDocument == null)
            return;
 
        // Get selected text or use current page
        string textToRead = GetTextToRead();
 
        // Generate speech
        var audioData = await _textToSpeech.SynthesizeSpeechAsync(textToRead);
 
        // Play audio and highlight text
        _audioPlayer.Play(audioData);
        HighlightTextDuringPlayback(audioData.TextTimings);
    }
 
    // Additional implementation details...
}

[TestClass]
public class OcrEngineTests
{
    private TesseractOcrEngine _ocrEngine;
 
    [TestInitialize]
    public void Setup()
    {
        _ocrEngine = new TesseractOcrEngine("./tessdata", "eng");
    }
 
    [TestMethod]
    public async Task RecognizeText_WithClearText_ReturnsAccurateResult()
    {
        // Arrange
        var testImage = LoadTestImage("clear_text.png");
        string expectedText = "This is a test of the OCR system.";
 
        // Act
        string result = await _ocrEngine.RecognizeTextAsync(testImage);
 
        // Assert
        Assert.AreEqual(expectedText, result.Trim());
    }
 
    [TestMethod]
    public async Task RecognizeText_WithLowResolutionImage_AchievesMinimumAccuracy()
    {
        // Arrange
        var testImage = LoadTestImage("low_res_text.png");
        string expectedText = "Low resolution text for OCR testing.";
 
        // Act
        string result = await _ocrEngine.RecognizeTextAsync(testImage);
 
        // Assert
        double similarity = CalculateStringSimilarity(expectedText, result.Trim());
        Assert.IsTrue(similarity >= 0.85, $"Similarity was only {similarity:P}");
    }
 
    // Helper methods
    private Bitmap LoadTestImage(string filename)
    {
        return new Bitmap($"./TestData/{filename}");
    }
 
    private double CalculateStringSimilarity(string s1, string s2)
    {
        // Implementation of Levenshtein distance or similar algorithm
        // ...
    }
}