package main

import (
    "fmt"
    "os"
    "github.com/civicfs/mailparser"
)

func main() {
    // Simple parsing
    data, _ := os.ReadFile("email.eml")

    parser := mailparser.NewParser()
    mail, err := parser.ParseBytes(data)
    if err != nil {
        panic(err)
    }

    // Access parsed data
    fmt.Println("Subject:", mail.Subject)
    fmt.Println("From:", mail.From)
    fmt.Println("To:", mail.To)
    fmt.Println("Text:", mail.Text)
    fmt.Println("HTML:", mail.HTML)
    fmt.Println("Attachments:", len(mail.Attachments))
}

parser := mailparser.NewParser()
file, _ := os.Open("email.eml")
defer file.Close()

mail, err := parser.Parse(file)

parser := mailparser.NewParser()
parser.MaxMessageSize = 50 * 1024 * 1024  // 50MB limit
parser.MaxHTMLLength = 5 * 1024 * 1024    // 5MB HTML limit
parser.ChecksumAlgo = "sha256"             // Use SHA256 instead of MD5

mail, err := parser.ParseBytes(data)

// Headers
subject := mail.Subject
date := mail.Date
priority := mail.Priority
messageID := mail.MessageID
references := mail.References

// Addresses
from := mail.From[0].Address
fromName := mail.From[0].Name

// Body content
plainText := mail.Text
htmlBody := mail.HTML
textAsHTML := mail.TextAsHTML

// Attachments
for _, att := range mail.Attachments {
    fmt.Printf("Attachment: %s (%s, %d bytes)\n",
        att.Filename, att.ContentType, att.Size)
    fmt.Printf("  Checksum: %s\n", att.Checksum)
    fmt.Printf("  CID: %s\n", att.CID)

    // Save attachment
    os.WriteFile(att.Filename, att.Content, 0644)
}

// Get specific header
contentType := mail.Headers.Get("content-type")

// Get all values for a header
received := mail.Headers.GetAll("received")

// Check if header exists
hasDate := mail.Headers.Has("date")

// Convert HTML to plain text
text, err := mailparser.HTMLToText("<p>Hello <strong>world</strong></p>")
// Result: "Hello world"

// Convert text to HTML with linkification
html := mailparser.TextToHTML("Visit https://example.com", true)
// Result: "<p>Visit <a href=\"https://example.com\">https://example.com</a></p>"

// Sanitize HTML (remove dangerous elements)
safe, err := mailparser.SanitizeHTML("<div>Safe<script>alert('xss')</script></div>")
// Result: "<div>Safe</div>"

// Extract links from HTML
links, err := mailparser.ParseHTMLLinks(htmlContent)
for _, link := range links {
    fmt.Println(link)
}

// Simple parser with automatic CID to data URI conversion
mail, err := mailparser.SimpleParser(reader, false)
// CID links in HTML are automatically replaced with data URIs

// Manual CID replacement with custom URLs
parser := mailparser.NewParser()
mail, err := parser.Parse(reader)

// Custom URL callback
err = parser.UpdateImageLinks(mail, func(att *mailparser.Attachment) (string, error) {
    // Upload to CDN and return URL
    url := uploadToCDN(att.Content, att.ContentType)
    return url, nil
})

// Decode format=flowed text
decoder := mailparser.NewFlowedDecoder(true) // delSp=yes
decoded := decoder.Decode(flowedText)

// Or use the convenience function
decoded := mailparser.UnwrapFlowed(flowedText, true)

// Encode text as format=flowed
flowed := mailparser.WrapFlowed(longText, 78, true)

parser := mailparser.NewParser()

// Size limits
parser.MaxMessageSize = 50 * 1024 * 1024  // 50MB
parser.MaxHTMLLength = 5 * 1024 * 1024    // 5MB

// Skip automatic conversions
parser.SkipHTMLToText = true   // Don't generate text from HTML
parser.SkipTextToHTML = true   // Don't generate TextAsHTML
parser.SkipTextLinks = true    // Don't linkify text
parser.SkipImageLinks = true   // Don't process CID links

// Keep CID links instead of converting
parser.KeepCIDLinks = true

// Checksum algorithm
parser.ChecksumAlgo = "sha256"  // or "md5" (default)

mail, err := parser.Parse(reader)

type Parser struct {
    MaxMessageSize   int64  // Maximum email size in bytes (0 = unlimited)
    MaxHTMLLength    int64  // Maximum HTML size to parse (default: 10MB)
    SkipHTMLToText   bool   // Skip HTML to text conversion
    SkipTextToHTML   bool   // Skip text to HTML conversion
    SkipTextLinks    bool   // Skip link detection in text
    SkipImageLinks   bool   // Skip CID image processing
    KeepCIDLinks     bool   // Keep cid: links instead of converting
    ChecksumAlgo     string // "md5" or "sha256" (default: "md5")
}

type Mail struct {
    Headers     Headers      // All email headers
    Subject     string       // Decoded subject
    From        []*Address   // Sender addresses
    To          []*Address   // Recipient addresses
    Cc          []*Address   // CC addresses
    Bcc         []*Address   // BCC addresses
    ReplyTo     []*Address   // Reply-To addresses
    Date        time.Time    // Parsed date
    MessageID   string       // Message-ID
    InReplyTo   string       // In-Reply-To
    References  []string     // References
    Text        string       // Plain text body
    HTML        string       // HTML body
    TextAsHTML  string       // Plain text converted to HTML
    Attachments []*Attachment // File attachments
    Priority    string       // "high", "normal", or "low"
}

type Attachment struct {
    Filename           string  // Attachment filename
    ContentType        string  // MIME type
    ContentDisposition string  // "attachment" or "inline"
    ContentID          string  // Content-ID header
    CID                string  // Cleaned content ID
    Content            []byte  // Decoded content
    Size               int64   // Size in bytes
    Checksum           string  // MD5/SHA256 hash
    ChecksumAlgo       string  // Hash algorithm used
    PartID             string  // MIME part identifier
    Related            bool    // Is related to HTML
    Headers            Headers // Part headers
}

type Address struct {
    Name    string // Display name
    Address string // Email address
}

// String returns formatted address
func (a *Address) String() string

type Headers map[string][]string

// Get returns first value for header
func (h Headers) Get(name string) string

// GetAll returns all values for header
func (h Headers) GetAll(name string) []string

// Set sets header to single value
func (h Headers) Set(name, value string)

// Add adds value to header
func (h Headers) Add(name, value string)

// Has checks if header exists
func (h Headers) Has(name string) bool

mail, err := parser.ParseBytes(data)
if err != nil {
    // Handle fatal parsing errors
    log.Printf("Parse error: %v", err)
    return
}

// Parser is lenient with:
// - Invalid base64/quoted-printable (falls back to original)
// - Missing boundaries (returns error for critical issues)
// - Unknown charsets (attempts UTF-8 fallback)
// - Empty parts (handles gracefully)

import "github.com/nodemailer/mailparser"

parser := mailparser.NewParser()
mail, err := parser.Parse(source)
if err != nil {
    // Handle error
    log.Fatal(err)
}

// Access parsed data
fmt.Println(mail.Subject)
fmt.Println(mail.From[0].Address)
fmt.Println(mail.Text)