Contributing to Mattermost PDF Dekont Parser Plugin

// ✅ Good: Clear, descriptive names
func extractRecipientName(text string) (string, error) {}
var recipientPatterns []FieldPattern
const MaxPDFFileSize = 10 * 1024 * 1024

// ❌ Bad: Unclear, abbreviated names
func getR(s string) string {}
var rp []FP
const MAX_SIZE = 10485760

// ✅ Good: Comprehensive error handling
func (p *Plugin) processPDF(content []byte) (*TransactionInfo, error) {
    if len(content) == 0 {
        return nil, errors.New("empty PDF content")
    }
    
    text, err := p.extractTextFromPDF(content)
    if err != nil {
        return nil, fmt.Errorf("text extraction failed: %w", err)
    }
    
    // Process text...
    return info, nil
}

// ❌ Bad: Ignoring errors
func (p *Plugin) processPDF(content []byte) *TransactionInfo {
    text, _ := p.extractTextFromPDF(content)
    // Process without error checking...
    return info
}

// ✅ Good: Single responsibility, clear interface
func (p *Plugin) extractRecipient(text string) (string, error) {
    pattern := regexp.MustCompile(`(?i)ALICI[^:]*:\s*(.+)`)
    matches := pattern.FindStringSubmatch(text)
    if len(matches) < 2 {
        return "", errors.New("recipient not found")
    }
    return strings.TrimSpace(matches[1]), nil
}

// ❌ Bad: Multiple responsibilities, unclear purpose
func (p *Plugin) processStuff(text string) (string, string, string, error) {
    // Extract recipient, description, amount all in one function
    // Complex logic mixed together
}

// extractRecipient extracts the recipient name from PDF text using 
// predefined patterns for Turkish bank receipts.
//
// The function searches for common recipient field labels like "ALICI",
// "ALAN", and "YARARLANICI" and returns the associated value.
//
// Parameters:
//   - text: The extracted PDF text content
//
// Returns:
//   - string: The recipient name if found
//   - error: Error if no recipient pattern matches
//
// Example:
//   recipient, err := p.extractRecipient("ALICI: AHMET YILMAZ")
//   // recipient = "AHMET YILMAZ", err = nil
func (p *Plugin) extractRecipient(text string) (string, error) {
    // Implementation...
}

// Package dekont provides PDF parsing functionality for Turkish bank receipts.
//
// This package implements a Mattermost plugin that automatically detects
// and processes PDF bank receipt uploads, extracting key transaction
// information such as recipient, description, and amount.
//
// Supported Banks:
//   - Türkiye İş Bankası
//   - Garanti BBVA
//   - Akbank
//   - Yapı Kredi
//   - Ziraat Bankası
//
// Example usage:
//   plugin := &Plugin{}
//   info, err := plugin.processPDF(pdfContent)
//   if err != nil {
//       log.Fatal(err)
//   }
//   fmt.Printf("Recipient: %s\n", info.Recipient)
package main

func TestExtractRecipient(t *testing.T) {
    tests := []struct {
        name     string
        input    string
        expected string
        hasError bool
    }{
        {
            name:     "İş Bankası standard format",
            input:    "ALICI: AHMET YILMAZ\nTUTAR: 1000 TL",
            expected: "AHMET YILMAZ",
            hasError: false,
        },
        {
            name:     "Garanti BBVA format",
            input:    "ALAN: FATMA KAYA\nMİKTAR: 500 TL",
            expected: "FATMA KAYA",
            hasError: false,
        },
        {
            name:     "No recipient found",
            input:    "Some random text without recipient",
            expected: "",
            hasError: true,
        },
        {
            name:     "Turkish characters",
            input:    "ALICI: ÖĞRETMEN ÇAĞLA ŞAHIN",
            expected: "ÖĞRETMEN ÇAĞLA ŞAHIN",
            hasError: false,
        },
    }

    plugin := &Plugin{}
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            result, err := plugin.extractRecipient(tt.input)
            
            if tt.hasError {
                if err == nil {
                    t.Errorf("Expected error but got none")
                }
                return
            }
            
            if err != nil {
                t.Errorf("Unexpected error: %v", err)
                return
            }
            
            if result != tt.expected {
                t.Errorf("Expected %q, got %q", tt.expected, result)
            }
        })
    }
}

func BenchmarkPDFProcessing(b *testing.B) {
    plugin := &Plugin{}
    pdfData := loadTestPDF("sample_large.pdf")
    
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        _, _ = plugin.processPDF(pdfData)
    }
}

func BenchmarkPatternMatching(b *testing.B) {
    plugin := &Plugin{}
    text := strings.Repeat("ALICI: TEST USER\n", 1000)
    
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        _, _ = plugin.extractRecipient(text)
    }
}

// Document your findings
/*
Bank: Example Bank
Receipt Types: EFT, Havale, Online Transfer
Field Patterns:
- Recipient: "HESAP SAHİBİ: [NAME]"
- Description: "İŞLEM AÇIKLAMASI: [DESC]"
- Amount: "TOPLAM TUTAR: [AMOUNT] TL"
*/

// Add to existing patterns
var recipientPatterns = []FieldPattern{
    // Existing patterns...
    {
        Name:  "Example Bank Recipient",
        Regex: regexp.MustCompile(`(?i)HESAP SAHİBİ[^:]*:\s*(.+)`),
        Cleaner: cleanRecipientName,
    },
}

func TestExampleBankExtraction(t *testing.T) {
    tests := []struct {
        name     string
        pdfText  string
        expected TransactionInfo
    }{
        {
            name:    "Example Bank Standard Receipt",
            pdfText: loadTestData("example_bank_receipt.txt"),
            expected: TransactionInfo{
                Recipient:   "JOHN DOE",
                Description: "Payment Description",
                Amount:     "1,000.00 TL",
            },
        },
        {
            name:    "Example Bank EFT Receipt",
            pdfText: loadTestData("example_bank_eft.txt"),
            expected: TransactionInfo{
                Recipient:   "JANE SMITH",
                Description: "EFT Transfer",
                Amount:     "2,500.50 TL",
            },
        },
    }

    plugin := &Plugin{}
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            info, err := plugin.processPDFText(tt.pdfText)
            if err != nil {
                t.Fatalf("Unexpected error: %v", err)
            }
            
            if info.Recipient != tt.expected.Recipient {
                t.Errorf("Recipient: expected %q, got %q", 
                    tt.expected.Recipient, info.Recipient)
            }
            // Test other fields...
        })
    }
}